Everything Omniscio does

the core: spawn, monitor, and manage many Claude Code sessions at once across projects

• Concurrent sessions — run many Claude Code sessions in parallel across unlimited projects.
• Background process management — each session runs as a managed child process, spawned, monitored, and reaped by the app.
• Multi-provider sessions — run sessions on Claude, Codex, Gemini, and other engines side by side, each isolated.
• Auto vendor routing — pick a model once and never touch the vendor: every non-Claude session (DeepSeek, GLM, Kimi, MiniMax, Meta, Qwen, OpenRouter) is served by the first row of its model family's supply list that can serve — your own key with the maker or a reseller, or Omniscio credits — set in Settings → Accounts → Who pays & who serves.
• Real-time status dashboard — every session's live state shown at a glance in the sidebar and inbox.
• Attention-first inbox — sessions needing you surface to an inbox; you respond and move on, no babysitting.
• Per-session live output stream — watch the agent's output stream into each panel in real time.
• Keep-alive panel pool — recently-viewed panels stay mounted so switching back is instant.
• Invisible concurrency pacing — spawns/searches/git are paced box-wide to protect the machine, never the user.

a fixed status vocabulary that drives color, sorting, and notifications

• Eleven session statuses — running, needs-you, error, stalled, starting, ready, terminating, ended, archived, paused, waiting.
• Color coding — Running green, Needs-You amber, Error/Stalled red, Waiting ember-orange (capacity park), Primary accent.
• Pending-action detail — the attention state carries why: question, plan approval, permission, rate-limited, suspended.
• Attention floats to top — needs-you / error / stalled sessions sort above idle ones.
• "Stay on it" during revival — a session you're watching come back to life isn't yanked away.
• Status-driven notifications — OS + in-app alerts fire on transitions into attention states.

talk to a session while it's still working

• Send while running — type mid-turn; the app delivers into the live process or kills+respawns cleanly, context preserved.
• Interrupt without killing — stop the current output (Esc or Stop) and keep the session alive for the next instruction.
• Esc-key interrupt guard — mashing Escape can't fire duplicate interrupts.
• Provider-aware interrupt — non-Claude sessions route interrupt through their own engine so the turn really stops.
• Live streaming ticker — a "streaming… Nm Ns" ticker shows the running turn's elapsed time.
• Interrupt acknowledgement — an "interrupt sent" cue the instant the gesture registers.

full create-to-retire lifecycle with honest state transitions

• Create / spawn — start a fresh session in any project.
• Always resumable — ended sessions resume on the next message.
• Pause / unpause — kill the running agent and park the session; flip it back when ready.
• Snooze — hide an attention session until a chosen time; auto-wakes when due.
• Save (shelve) — flag valuable/completed work into a collapsible "Saved" sidebar section.
• Archive / unarchive — retire a session (clears draft/snooze, triggers worktree merge) or restore it.
• Close / terminate — stop a session's process and remove its panel.
• Stop sticks — a session you stop stays stopped; auto-restart, agents and the auto-lander never revive it until you restart or message it.
• Crash recovery — sessions running when the app died auto-resume on next launch.
• Genuine-error persistence — a session you saw go red stays red across restart.
• Runaway-spawner guard — a session that spawned children is never auto-resumed after a crash.
• Pop-out window restore — popped-out sessions reopen automatically next launch, even after a crash.
• In-session activity notes — automatic pause/resume/archive markers appear inline in the transcript.
• Move to project — relocate a session to a different project, with undo.

keep critical sessions one click away

• Pin to top — pin a session so it sorts above the list in its project.
• Pin/unpin toggle — from the header and the overflow menu.
• Optimistic with rollback — pin flips instantly; a silent failure reverts with a toast.

never lose an unsent message

• Auto-save drafts — unsent composer text saves continuously and survives session switches.
• Three-layer durability — in-memory → localStorage → SQLite, so a hard refresh keeps your text.
• Pasted images & text-chips persist — pasted images and large pasted-text blocks survive reload.
• Cross-client draft sync — draft clears echo across desktop + paired mobile without clobbering active typing.
• Identity-scoped wipe — drafts blanket-clear on account change so text can't leak to the next user.
• Teardown flush — a graceful close flushes pending drafts losslessly.

per-session spend and usage tracked automatically

• Per-session USD cost — accumulated cost tracked per session, shown as a header chip.
• Every session shows its cost — the dollar chip appears for every session with a known cost, from $0.00 onward, whatever the billing model.
• Estimated-cost marker — token-priced engines show a "≈" prefix to read honestly.
• Turn count & token totals — turns and input/output tokens shown in Session Stats.
• Turn duration badges — each finished turn shows "took Nm Ns".
• Cross-compaction duration — compaction dividers show total active time, excluding idle gaps.

see how full a session's context is, and get warned before it fills

• Context donut/bar — a header indicator shows real context usage with color thresholds.
• Details popover — click for a detailed breakdown of context usage.
• 75% & 90% warnings — persistent amber dividers at "context filling" and "compaction imminent".
• Warn-once per fill-up — de-duped so a respawn/restart doesn't re-fire.
• In-message toggle — turn either threshold off without opening Settings.
• Efficient polling — the authoritative query runs once per turn, gated on visibility + fullness.

prevent runaway costs on pay-per-use keys

• Per-session hard cap — force-kill a session when its cost crosses a limit.
• Per-session soft warning — a one-time warning well before the hard kill.
• Per-account daily cap — stop sessions + block new spawns once a key's daily spend crosses a limit.
• Per-provider daily cap — optional per-vendor daily spawn+kill cap (off by default).
• Subscription exemption — subscription sessions are never spend-capped.
• Runaway-spend anomaly alert — an alert when a metered vendor's daily spend spikes.
• Fail-open safety — an unreadable ledger never kills a paid session you're running.

reverse lifecycle actions with Ctrl+Z

• Ctrl+Z undo — reverse your last session action (pause, snooze, archive, move, rename, close, color).
• Multi-level history — a bounded stack walks back through recent actions.
• Field-aware arbiter — undoes the action from a text field when pristine, yields to native text-undo once you type.
• Undo toast (opt-in) — a focus-independent Undo button on a toast.
• Honest reversal — undo of pause/close returns the row to "ended", never faking a live agent.

rename a session by hand (AI titles are separate)

• Inline rename — edit the title in the header.
• Rename from menu — via the overflow menu.
• Optimistic with rollback — updates instantly; a failure rolls back with a toast.
• Rename undo — Ctrl+Z restores the prior name.

send images, PDFs, and large pasted text with a message

• Paste images — sent inline to the agent as image blocks.
• PDF attachments — delivered as native document content.
• Text-document attachments — large text docs saved to the workdir and referenced.
• Pasted-text chips — big text blocks become collapsible chips spliced into the message.
• Per-session storage — attachments saved to per-session directories.
• Pending strip + lightbox — preview queued images/chips before sending.

3+ images in an AI reply become one swipeable carousel instead of a tall stack

• Count badge — a corner counter (like 3 / 12) shows which image of how many.
• Mobile swipe — swipe through the images without flipping to the next session.
• Desktop arrows — prev/next buttons, greyed at the ends.
• Tap to open full-screen — opens the current image in the existing viewer.
• Inline for 1–2 — a single or pair of images stays stacked as before.
• Display-only — copy and export keep the original message.

move between sessions with a flick on a phone

• Horizontal session swipe — swipe left/right for previous/next session.
• Scroll-aware commit — only commits once a scrollable child is pinned to its edge.
• Velocity + offset thresholds — ignores accidental micro-drags.
• Prev/next arrows — optional header arrows on mobile.
• Swipe-to-dismiss overlays — a downward flick closes big mobile overlays.

queue a message to a session for a future time

• Schedule a response — pick a future time to deliver a composed message (Ctrl+Shift+L).
• Scheduled attachments — images, PDFs, and text-chips delivered with the message.
• Status-aware delivery — delivers into a live process (interrupting) or resumes an ended/paused session.
• Auto-unpause / un-archive — a due message wakes a paused/archived/snoozed target.
• At-most-once delivery — atomic claim guards against double-delivery.
• Retry then give up — up to 3 attempts across restarts, then a system message.
• Visible failure alert — a deduped inbox alert when a scheduled reply can't be delivered.
• Cancel scheduled — clear a pending scheduled message before it fires.

label and cross-organize sessions

• Free-form tags — ad-hoc tags on a session (max 10, 30 chars).
• Library tags — reusable named tags applied across sessions.
• Header tag chips — tags render as a chip strip under the title.
• Mobile tag collapse — multiple tags collapse to first + "+N" on mobile.
• Tags Library hub — a hub to manage tags and see tagged sessions cross-session.
• Tag chip context menu — edit/remove a tag from its chip.

turn a transcript into a shareable document

• Copy as Markdown — copy the visible conversation with a token-count toast.
• Copy since last compaction — copy only from the last compaction divider forward.
• Export to file — save the transcript as Markdown, Word (opt-in), or PDF.
• Export to Google Docs — publish the transcript to a new Google Doc (opt-in).
• Visible-only export — strips tool-call markers and system rows; keeps prose + your messages.
• Raw thread export — a troubleshooting file with every stored message verbatim, each labelled shown, folded or hidden (unredacted).
• Size preview — the menu shows words · chars · ~tokens before you export.

give a session its own OS window

• Pop out to window — open a session in a standalone window.
• Geometry memory — popped-out windows remember position/size.
• Restore on launch — reopen automatically next start (crash-safe).
• Push routing — detached windows still receive their session's live updates.

the per-session action hub

• Overflow action menu — snooze, pause, send-later, copy link, archive, rename, and more in one menu.
• Message filter — filter the transcript by All / Agent / You.
• Events filter — a day-grouped list of lifecycle/system events for troubleshooting.
• Aside mode — ask a throwaway side question in a branch, excluded from the main transcript.
• Copy deep link — copy a deep link to the session.
• Attach to task — link a session to a task.
• Session resources popover — a diagnostic view of the session's live process tree.
• Per-session MCP servers — configure MCP servers for one session.
• Customize session bar — promote chosen menu actions to one-tap header buttons; right-click a menu action to pin it, or use the Settings checklist.
• Fixed scroll policy — hardcoded, non-configurable transcript scrolling with jump buttons.

your own regex rules that turn matching conversation text into inline badges

• Your own regex → a badge — each rule is a regex; its matches in message text (agent output and your own messages) render as an inline badge instead of plain text.
• Tone & icon — pick a badge color (neutral / accent / success / warning / danger / info) and an optional icon from a small curated set.
• Label & link templates — build the badge's text and an optional clickable http/https link from the match, using `$0` (whole match) and `$1`..`$9` (capture groups).
• Live "test it" preview — see the badge and its resolved link on a sample line before you save.
• Manage the list — add, edit, reorder (first match at each position wins), toggle, and delete rules in Settings → Sessions → Custom Render Rules.
• Master toggle — one switch disables all custom rendering without deleting your rules.
• Safe rendering — real UI badges (no raw HTML), http/https-only links, code blocks and existing links skipped, and invalid / zero-width / greedy regexes guarded; zero cost when you have no rules.

a control-group project whose sessions spawn a vanilla, blank-context agent for testing and comparison

• Vanilla session spawn — every session inside Clean Room runs the engine with none of your customizations and none of Omniscio's added layers.
• Full customization strip — no global CLAUDE.md rules, memory, skills, project instructions, or connected MCP tools reach the session (via the CLI's own safe-mode).
• Omniscio-layer strip — the awareness note, Plain Speak, conversation markers, publish/convert/download shims, and the question-widget instruction are all omitted.
• Hook-free, empty scratch folder — no PreToolUse/PostToolUse hooks fire, and the session starts in a fresh empty working directory with no repo or files.
• Real engine kept — it is still Claude Code with its own base identity and native tools, so it is a fair control group, not a raw model or a permission jail.
• Per-session engine picker — choose the engine per session (Claude by default, plus the Claude-compatible DeepSeek / Kimi / GLM / MiniMax).
• Built-in sidebar project — appears among the projects like Session Search, not a folder on disk.

add, organize, and manage the code repositories the app works in

• Add any local folder — becomes a project; all languages/frameworks.
• Quick create with folder — type a name; the app makes the folder under your default projects directory.
• GitHub import/clone — paste a repo URL to clone and add in one step.
• Browse-your-GitHub tab — a signed-in device flow lists/searches your repos to pick and clone.
• Duplicate-path guard — a folder already tracked is deduplicated.
• Auto-detected icons — a 10-tier cascade scans favicons, manifests, package files, and app icons.
• Custom icon / emoji / glyph — set the icon to an image, emoji, or built-in glyph; remove or re-detect.
• Color-coding — a per-project color for instant identification.
• Rename & edit — change display name and settings.
• Project pinning — pin active projects above the scrollable list.
• Delete + undo — soft-delete keeps files on disk; restorable.
• Permanent erase — an irreversible hard-erase of stored data.
• Relocate / recreate folder — move a project's path or rebuild a missing folder.
• Provider & deploy pickers — a per-project default AI provider and deploy profile.

the left navigation rail listing projects with their live sessions

• Hubs as vertical bars, sessions as dots — thin accent bars for hubs, colored status dots for sessions.
• Status-colored indicators — reflect Running/Needs-You/Error/Waiting per project and session.
• Pinned section — pinned projects above the scrollable list.
• Per-project attention count — a pill badge for how many sessions need you.
• Project context menu — edit, notes, files, appearance, pin, recipes, delete, erase.
• Copy path / show in explorer / open docs — reveal the folder or open the project's docs.
• Open in new window — pop a project into its own workspace window.
• Collapse / edge gutter — collapse the rail; a thin gutter re-expands it.
• Keyboard nav — J/K move between sessions.
• Mobile projects list — a touch-optimized variant for phone/web.

collapsible section headers and category groups that organize the sidebar

• Create dividers — named section headers to group projects.
• Collapsible groups — collapse/expand a divider; state persists.
• Drag-and-drop reordering — long-press-drag reorders projects and dividers.
• Cross-group moves — drag a project into another divider atomically.
• Category parent groups — integrations auto-nest under fixed category groups (Dev Tools, Communication, Creative, Productivity, Insights, AI Tools, Automation).
• Category rollups — each parent group has a summary rollup panel.

a per-project scratchpad markdown file

• Per-project markdown notes — each project gets its own note file.
• Notes dialog — open, edit, and save from the context menu.

aggregate spend across all of a project's sessions

• Aggregate cost view — total USD, tokens, and session counts in the Codebase Stats "Costs" tab.
• Load-error state — distinguishes a failed fetch from a genuine zero-spend project.

unified full-text search across every conversation and channel

• Ctrl+K command palette — one modal searches all conversation messages across projects/sessions.
• Cross-channel results — also searches SMS, Slack, Telegram, RSS, webhooks, scratchpads, and PM items.
• Search-as-you-type — debounced live search with last-word prefix matching.
• Advanced syntax — exact phrases, `-word` negation, `OR`, powered by SQLite FTS5.
• Rich filters — by project, channel, source (agent/you/system), scope, session status, tag, date range.
• Sort by recency or relevance — newest, oldest, or BM25 ranking.
• Snippet previews with highlighting — matched text shown in context.
• Session-grouped results — duplicate hits collapse to one row per session with a match count.
• Cursor pagination — 30 results/page with load-more.
• Keyboard navigation — arrows move, Enter opens, Esc closes.
• Mobile hero layout — a full-screen search with a filters bottom-sheet.
• Ask AI escalation — hand the query to the AI Session Search agent.

meaning-based session finding when keywords aren't enough

• Local embedding search — session summaries embedded on-device; finds by meaning at zero API cost.
• Blended into Ctrl+K — semantic matches surface above keyword hits on the "relevant" sort.
• Similarity-scored matches — results show a "% similar" score.
• Settings status readout — disabled / downloading / indexing / ready / error with an index count.
• Checkpointed backfill — indexes existing sessions in batches, resuming after a crash.
• Auto-disable circuit breaker — repeated embedding crashes auto-disable with a one-click re-enable.
• AI Session Search agent — "Ask AI" spawns an agent that searches your sessions conversationally.
• Escalation ladder — the agent climbs semantic → full-text → session-list → transcript-read → brute-force.
• Clickable session links — returns deep links that open in-app.
• Quick Launch search tab — a floating tab that submits a query straight to the search agent.

custom-protocol URLs that jump straight into a place in the app

• Dual-scheme parsing — accepts both the legacy and brand URL schemes.
• Open inbox / project / session — foreground the inbox, open a project by fuzzy name, or jump to a session/message/turn.
• New session with prompt — spawn a session pre-seeded with a prompt.
• Fuzzy project matcher — resolves names exact → starts-with → contains, accent-folded.
• Open a note / mind map / setting / super-prompt — deep routes into those surfaces.
• Open / fork a share — open a share in-app, or fork it into a brand-new session from the share page.
• Cold-start buffering — a link that launches the app fresh is replayed once the window mounts.
• Agent-safe navigation — a view-switch link becomes a click-to-go toast for agents, not a forced jump.
• Hardened parsing — rejects oversized URLs, malformed encodings, control-character injection.

a built-in file browser in a resizable right sidebar

• Lazy-loaded directory tree — loads children on demand.
• Files / Changes tabs — toggle between the file tree and the git changes view.
• Syntax-highlighted viewing — ~30-language highlighting.
• Format preview — markdown, SVG, HTML, Mermaid, LaTeX render with a Raw/Preview toggle.
• Image preview — images render inline with dimensions and size.
• In-place editing — edit markdown and save with lost-update protection.
• File context menu — open in editor, show in native explorer, copy path, delete to recycle bin.
• Keyboard navigation — roving-tabindex tree nav.
• Truncation banner — large files load a capped preview.

a slide-over panel that opens files referenced in agent messages

• Message-link file peek — click a file path in a message to slide open its contents.
• Smart click routing — distinguishes file vs folder vs line-anchor links.
• Line-number anchoring — opens scrolled to a referenced line.
• Sibling image navigation — left/right through all images in the same message, with prefetch.
• In-peek markdown editing — edit and save with conflict detection.
• Project-scope gate — out-of-project paths prompt open-once / always-allow / cancel.
• Mobile HTTP image streaming — images stream over HTTP on phone/web.

side-by-side/unified review of uncommitted changes rendered inline

• Monaco diff editor — original vs modified with real syntax highlighting.
• Unified / side-by-side toggle — switch layouts with the V key.
• Collapse unchanged regions — long identical runs fold away.
• Ignore-whitespace / word-wrap toggles — re-fetch with whitespace suppressed; wrap long lines.
• Adjustable font size & tab width — per-file toolbar controls.
• Optional minimap — the code minimap on the diff.
• Inline git blame — per-line author, date, and commit on toggle.
• Line annotations — attach an ephemeral note to any line.
• AI change summary — an on-demand plain-English explanation of what a file's diff does.
• Binary / too-large placeholder — a friendly notice instead of an empty editor.
• New-file synthesis — untracked files render as an all-additions diff.
• Safety caps — size and timeout limits so a huge diff can't hang the app.

see only what an agent changed since it launched, or all uncommitted changes

• Project vs Session mode — all uncommitted changes, or changes since the session's start commit.
• Commit-range comparison — pick two commits and diff between them.
• Multi-repo discovery — finds nested/sibling repos and groups changes per repo.
• Tree / flat toggle & status filters — group into a folder tree or flat list; filter by change type.
• Auto-refresh on output — re-queries git status as the agent writes code (debounced).
• Not-a-repo empty state — a clear message when the folder isn't under git.

per-file and per-hunk approve-or-discard with keyboard shortcuts

• Accept / reject file — mark reviewed (Y) or discard via git (X, confirmed).
• Accept all / reject all — bulk-review remaining files.
• Per-hunk accept/reject — approve or revert individual change blocks.
• Review summary bar — reviewed count and bulk actions.
• Discard all changes — a confirmed working-tree reset.
• Keyboard-driven review — J/K navigate, Y/X accept/reject, V toggle, O open, R refresh, B blame.
• Open in external editor — jump the selected file into the system editor.

repo state at a glance, plus commit and push without a terminal

• Status badges — Modified/Added/Deleted/Renamed/Copied/Unmerged/Untracked per file.
• Insertion/deletion counts — per-file added/removed line counts.
• Repo status bar — branch, short HEAD, and changed-file count.
• Sidebar changed-file badge — a live count of uncommitted files per project.
• Commit box — write a message and stage-all-and-commit (per-repo in multi-repo projects).
• Push current branch — push with humanized errors.
• Injection-safe git — all git runs spawn the binary directly (no shell).

each session optionally runs in its own git worktree, auto-merged when done

• Per-session worktree — a session works on its own branch in an isolated directory.
• Three-level enable cascade — per-session → per-project default → app-wide default.
• Auto dependency copy — copies node_modules/lockfiles/.env into the worktree.
• Auto-merge on completion — enqueues a merge back to the base branch when the session ends.
• Per-project merge queue — serializes merges so concurrent sessions don't collide.
• Conflict handling — a conflict raises a "Resolve" action that spawns an AI session.
• Startup recovery — reconciles orphaned/stale worktrees on restart.
• Dirty-work protection — teardown never destroys uncommitted work or a live run.

on-demand per-project repository analysis in a 7-tab modal

• File-walk stats — total files, lines of code, bytes, per-extension breakdown.
• Health tab — TODO/FIXME count, `any`-type usage, large-file flags, secret findings.
• Git tab & insights — commits, contributors, churn hotspots, knowledge silos, stale files, active branches.
• Deps tab — vulnerability and outdated-package counts from an audit.
• Coverage tab — detects and runs the test suite (vitest/jest/pytest/cargo) and parses coverage.
• Test-to-source ratio — classifies test vs source files and computes the ratio.
• Secret scanning — credential-pattern scan with a false-positive filter and per-project ignore list.
• Costs tab — the project cost rollup.
• Cache by commit — results cached per git HEAD so reopen is instant.
• Fix-in-session — spawn an agent to address findings.
• Background pre-warming — pre-computes each project's stats under load gates so the modal opens instantly.

personal usage analytics across multiple tabs

• Overview & Trends — top-line usage summary and trends over time.
• Spend & Feature Usage — cost breakdown, per-feature spend, which features you use.
• Hotkey usage & efficiency — how often each shortcut fires and where you mouse instead.
• Usage tab — API credit usage, per-account bars, heatmap, daily projection.
• Records tab — personal records with a day-sessions drill-down.
• Project stats table — per-project usage comparison.

complete backup to ZIP and safe two-phase restore

• Full backup export — ZIP of all data, sanitized settings, recipes, and attachments (secrets excluded).
• Two-phase import — preview (validate, show counts/warnings) then execute.
• Pre-import backup — snapshots the live DB and config before overwriting.
• Full-replace transaction — the import runs as one atomic transaction.
• Zip-bomb / row-count guards — caps entry count, uncompressed size, and per-table rows.
• Schema/platform warnings — warns on older schema or cross-platform restore.
• Column-whitelist safety — only real columns are inserted (blocks crafted-backup injection).
• Settings-only export/import — a lightweight settings JSON with merge-on-import and secret stripping.

scheduled self-pruning backups plus encrypted off-machine copies

• Triggered backups — on startup, on a timer, and on demand.
• Retention ring + bit-rot floor — keeps the newest N and ≥2 physical copies so one bad sector can't wipe all.
• Corruption detection + restore — a boot integrity check offers restore-from-backup.
• Pre-migration & pre-update snapshots — separate snapshot rings before schema upgrades and app updates.
• Setup Backup to Gmail — emails an encrypted setup backup to your own Gmail on a schedule.
• Backup Mirror — writes an AES-256-GCM-encrypted bundle to a chosen (cloud) folder, auto-syncing.
• Cloud-folder auto-detection — suggests detected Dropbox/OneDrive folders as one-click targets.
• Mirror restore + fresh-machine migration — replace-all or merge from a mirror archive or file.
• Staleness / failure alerts — alerts after repeated failures or when backups go stale.

configurable automatic deletion of old data

• Session data retention — auto-delete old ended/archived/paused sessions (1–365 days).
• Reduce-retention confirm — lowering the window warns before it deletes.
• Scratchpad auto-delete — opt-in purge of untouched Quick Capture notes.
• Communications content erasure — opt-in permanent erase of old message content after a grace period.
• Vault trash sweep — a deleted Vault (KMS) note stays recoverable by hand from the vault's .trash folder only until it passes the same window, then it is permanently deleted.
• Active-data protection — active sessions are never auto-deleted. Approval rows are cleared once they pass the retention window.

press a hotkey and speak to drive the app

• Push-to-talk hotkey — Alt+V or a global hotkey starts listening; a mic button too.
• 3-layer intent parser — regex (<1ms) → on-device embedding (~20ms) → LLM fallback (~300ms).
• 50+ built-in actions — create/send/interrupt/pause/snooze/archive sessions, navigate views, toggle theme, control TTS, Gmail, PM.
• Command chaining — "open settings and then check voice status" runs commands sequentially.
• Custom voice commands — define your own trigger phrases mapped to actions (up to 50).
• Three dictation modes — single, continuous, buffered.
• Automatic silence detection — stops recording after your configured pause.
• Three STT providers — Deepgram Nova-3, ElevenLabs Scribe v2, Groq Whisper.
• Voice response confirmation — optional spoken reply: short, conversational, or off.
• Live app context — the parser knows the current view/sessions so "archive that" resolves.
• Daily STT spend cap — a USD ceiling across paid speech-to-text engines.

system-wide push-to-talk that types your speech at the cursor in any app

• Type at the OS cursor — cleaned transcript pasted wherever your cursor is, in any application.
• Global hold + toggle hotkeys — system-wide hold-to-talk or press-to-toggle keys.
• Floating idle pill (HUD) — an always-on click-to-dictate pill; hideable.
• Auto-submit into the app — when the app is frontmost, optionally send the dictated draft.
• Pre-warmed recorder — a hidden capture window cuts first-dictation latency.
• Auto health check — self-tests the speech server and mic permission at startup.
• Never loses a dictation — audio is saved as you speak; a failed transcription is retried automatically and kept for a one-click retry.

hear the agent's replies spoken aloud

• Manual play button — three-state button reads the last AI message.
• Auto-read mode — optionally auto-speak when you first open a "Needs You" session.
• Three TTS providers — Fish Audio, Grok (xAI), or ElevenLabs.
• 50+ voices per provider — with preview and custom voice IDs.
• Chunked streaming playback — a tiny first chunk for fast time-to-first-syllable.
• Smart text processing — strips markdown, code, tool markers, and tables so you hear prose.
• Summarization modes — verbatim, summarize, or auto before speaking.
• Speed & volume control — adjustable playback speed and volume.
• Disk LRU cache — caches synthesized audio to avoid re-billing.
• Daily read-aloud spend cap — a USD ceiling across the speech path.

a spoken 75–120-word catch-up on what a session did while you were away

• On-demand voice briefing — a plain-English recap of accomplishments/decisions/blockers.
• Four triggers — header speaker button, Ctrl+Shift+J hotkey, "brief me" voice command, auto-on-open.
• Configurable model + prompt — choose the model and override the briefing prompt.
• Smart caching — reuses a briefing until new messages, a model change, or a prompt change.

multi-turn spoken back-and-forth and spoken replies

• Report Back — the AI's spoken-prose reply after a voice command is read back.
• Layer 2 conversational assistant — up to ~12 turns with on-screen context awareness.
• Layer 3 session voice — ask a spoken question about the currently open session.
• Layer 4 ask the live agent — queue a spoken question to a running agent and hear its answer.
• Per-layer daily spend caps — independent USD ceilings so voice never runs away on cost.
• Voice history recording — every conversation turn persisted for later review.

drive the project/task boards by voice

• PM voice actions — create item, move item, status update, read item, list items by voice.

an always-listening hotword that arms voice with no keypress

• Dual engine — free built-in openWakeWord (bundled, no key) or paid Picovoice.
• Bundled wake words — "Hey Omniscio" (default), plus "Computer".
• Action mode — a wake word runs the spoken text as a command or types it as dictation.
• Adjustable sensitivity — a fire threshold you can tune.
• Focus-only mode + auto-pause — listens only while focused; yields to active dictation.
• Test button — try the wake word with an auto-stop.

calibrated silence/speech thresholds saved per microphone

• Per-device thresholds — saves calibrated silence-floor and speech-threshold per mic.
• Silence timeout — a configurable pause before a command auto-stops.

global rules that auto-respond to unattended sessions so they finish hands-free

• Global auto-response rules — condition-based rules matched against a session's finished output.
• Four condition types — keyword, project, tag, or time-of-day window (windows wrap past midnight).
• Six rule actions — reply, retitle, archive, start a new session, raise an inbox note, or triage.
• Triage action — set title, apply a tag, and/or set inbox color in one shot.
• Reply from a Quick Reply — pull canned text from a saved snippet.
• First-match-wins ordering — rules evaluated in display order.
• Pre-emptive evaluation — matched sessions never flash amber or notify first.
• Cross-engine support — rules fire for non-Claude sessions too.
• Loop & spend guards — no-progress loop cap, start-session daily cap, loop-breakers, rate-limit exclusion.
• Auto badge + provenance — auto-replied turns carry a green "auto" badge linking to the rule.

a sidebar hub unifying Rules and Auto-replies

• Two-section sidebar — collapsible Rules and Auto-replies sections.
• Accordion editors — click a row to expand its inline editor.
• Quick-create buttons — new rule / new auto-reply pre-selecting the category.
• PII-safe telemetry — category-change and row-expand events with an allow-list.

reusable multi-step orchestrations run as CLI sub-sessions

• Named multi-step recipes — ordered steps with shared parameters.
• Global & project-scoped — store recipes everywhere or per-project.
• Three execution modes — same-session, multi-session, or parallel.
• Parameter slots — typed parameters with labels, defaults, and required flags.
• AI-evaluated follow-ups — each step decides to continue, retry, or move on.
• Pipeline expansion & sub-recipes — a step can fan out into a wave, or call another recipe.
• Real-time progress + cost — live step status, per-step and cumulative cost.
• Cost cap + time cap — per-run spend and wall-clock ceilings that abort a runaway.
• Resume on failure — resume from a checkpoint; completed steps skipped, cost carried.
• Run control — pause, resume, stop, or inject an operator turn mid-run.
• In-run approval gates — a step can pause for approve/reject.
• Execution history + run memory — DB-backed history with timing, costs, and a run summary.
• AI recipe drafter — describe a recipe in plain English; AI instantiates or synthesizes it.
• Pattern library — bundled, tested recipe patterns to instantiate from.
• Approval gate on save — a CLI-authored recipe lands "pending" until approved.

fire a saved recipe on a recurring cadence

• Cron-style schedules — attach a recurrence to a recipe.
• Split approval gate — arming is approval-gated (paid); disarming applies immediately.
• Bounded dispatch + duplicate guards — drains a backlog without a paid burst; no double-fires.
• Upcoming-runs preview — list the next scheduled fire times.

a full time-triggered job scheduler on the local control server

• Four job types — script, recipe, session (spawn), or workflow.
• Standard cron expressions — with natural-language phrasings translated by the CLI.
• Run modes — one-off, limited (max N runs), or recurring.
• Per-job timezone & encrypted env — schedules fire in a set timezone; secret env values encrypted.
• Run history + Run Now — per-job run log with output/errors; fire any job immediately.
• Enable/disable & job chaining — pause a job or trigger another on completion.
• Approval-gated creation — new jobs queue an inbox approval with a plain-English description.
• Self-healing — a failing job's error is AI-diagnosed and an auto-fix proposed (per-job toggle).
• Watchdogs — zombie-run reaper, liveness detector, overdue/dark-scheduler alerts.
• Retention purge — daily cleanup of old run history.

local reminder and trickle-feed schedulers

• Scheduled messages — a subject+markdown note delivered to yourself on a recurrence (no paid spend).
• Drip feeder — queue a pile of items and trickle them into the inbox on a schedule.
• Loop drips — a single-item drip repeats forever (e.g. "send me this photo daily at 9am").
• Snooze — hide a session/inbox item until a chosen time, with auto-return.
• Idle release scheduler — schedules session release on idle.

a reusable prompt-template library that pre-fills a new session's first message

• Prompt catalog — a large curated bundle plus your own prompts.
• Two-pane picker — a minimal Find/Browse home, then list + live preview.
• Launch-into target — pick which project the prompt launches into.
• Tag filtering + "Help Me Choose" — filter by tag; an AI advisor recommends a prompt.
• Prompt editor — title, summary, description, body, and a stock first response.
• Stock first response — a pre-written opening shows instantly; the model spawns on your first reply.
• Tombstones & duplicate — soft-delete/restore user prompts; copy a builtin into an editable one.
• Remote refresh — polls a remote catalog for new curated prompts.
• Linkable prompts — deep links open a Run / Copy / Open-in-picker menu.

contextual behavioral tips surfaced from usage signals

• Master switch, off out of the box — Settings → Coaching turns the whole engine on; nothing is surfaced until you do.
• Tip catalog — tips triggered by tracked actions/counts across shortcuts, voice, productivity, navigation.
• Per-tip lifecycle — shown/dismissed/completed/snoozed state per tip.
• Cooldown + daily cap — a startup delay, per-tip cooldown, and daily ceiling prevent spam.
• Category toggles — enable/disable coaching by category.

schedule recurring AI codebase audits, and import external automation setups

• Per-repo audit automations — named scheduled audit runs subscribed to a project.
• Custom audits — author your own audit definitions.
• Run-now — run an audit on demand (approval-gated paid session).
• Findings + reports — structured findings and run history per run.
• OpenClaw port — import existing OpenClaw recipes and schedules into the app.

a virtual "Mail" project bringing your Gmail inbox alongside your code

• Mail sidebar project — with a live unread-count badge.
• Full thread view — read conversations inline with rich HTML and expandable recipients; every attachment shows on its message and saves with one click.
• Compose / reply / forward — send, reply, reply-all, or forward without leaving the app.
• Gmail search — full Gmail query syntax, paginated.
• Archive, mark-read, star — optimistic UI with undo.
• Category tabs — Primary, Social, Promotions, Updates, Forums.
• Email snooze & undo send — hide a thread until later; a delayed-send cancel window.
• Multi-select bulk actions — batch archive/read/label.
• AI reply suggestions + thread summary — one-tap drafts and auto-summaries of long threads.
• Compose draft preservation — unsent drafts saved on close, restored on reopen.
• Markdown-to-HTML send + sanitization — sends proper HTML mail; strips malicious inbound HTML.
• Keyboard-driven — single-key archive/star/reply/nav plus category chords.

view and send your phone's texts from the desktop via Pushbullet

• Phone SMS on desktop — a hub bridging Pushbullet's SMS API.
• Conversation list — threads with previews and unread badges.
• Send / reply — through the paired device.
• Real-time incoming sync — a WebSocket delivers new messages instantly.
• Archive with auto-unarchive — archived threads resurface on a new message.
• OS notification per text — a chime + toast that deep-links to the conversation.
• Wizard setup — enter token → select device → connect.
• Contact images & MMS — pulls avatars and renders picture messages.
• AI reply suggestions — one-tap draft replies.

send/receive from your phone's actual number with no third party in the path

• Self-hosted Android bridge — uses an open-source local SMS gateway on your phone.
• Inbound webhook — the phone POSTs each received text to the app (HMAC-verified).
• Outbound over your SIM — the app tells the phone to send the text.
• Shared inbox intake — flows into the same SMS UI/notifications as Pushbullet.

a Telegram account as a first-class messaging project

• Telegram project — conversations + messages in their own sidebar project.
• Phone-based auth — send-code → sign-in → optional 2FA; session stored encrypted.
• Send / edit / delete / forward — full message operations.
• Real-time + background sync — live events plus periodic catch-up with a watchdog.
• Mute / archive / snooze / dismiss — per-conversation management.
• Media download & search — fetch photos/files; search conversations.
• AI reply suggestions — one-tap drafts.

talk to your Omniscio agents from Telegram through a bot you create with BotFather (separate from the personal-account Telegram Integration)

• BotFather token — verified with Telegram before it is saved; stored encrypted and never shown again.
• Pairing / allowlist access — unknown senders get a one-time code you approve; user and group allowlists fail closed; groups need an @mention by default.
• One session per chat — every DM, group, or forum topic maps to its own durable agent session; follow-ups continue it, `/new` starts fresh.
• Replies in the same chat — the agent’s final answer comes back to the same chat or topic, formatted and split to fit, with a typing indicator while it works.
• Restart-safe polling — long polling with durable update dedup, backoff, and an alert if another program grabs the bot or the token is revoked.
• CLI parity — status, pairing approvals, chat unlinking, and allowlists via `/telegram-bot/*`.

real-time Slack DMs, channels, and mentions without a public URL

• Socket Mode — an outbound WebSocket; no inbound webhook needed.
• Monitors DMs, channels, mentions — ingests messages into a Slack channel project.
• Send + threads — reply into channels/threads with thread mapping.
• Reconnect with backoff — exponential backoff and quick acks.
• Wizard setup — enter tokens → pick channels → connect.

one standardized interface so every messaging integration behaves the same

• Channel adapter interface — each integration is one adapter + one register line.
• Channel registry — aggregates conversations, unread totals, and cross-channel search.
• Composite IDs — addressing so IDs never collide across channels.
• Fault-tolerant startup — one adapter failing doesn't block the others.
• Per-channel virtual hubs — an auto-created sidebar space per enabled channel.
• Capability flags — realtime, send, threads, richText, search declared per adapter.

subscribe to feeds and read articles inside a channel project

• RSS project — each feed entry is its own conversation.
• Per-feed polling with dedup — periodic refresh that ignores duplicates.
• Article reader — sanitized HTML body with Open Original + Archive.
• Feed management UI — add/edit feeds, URL validation, per-feed refresh, status dots.
• RSS daily digest — a scheduled per-feed digest email.

turn any external service's webhook into an inbox channel

• Localhost webhook server — receives JSON payloads at a per-source URL.
• Webhook project — incoming payloads render as messages.
• Per-source config — configurable port, URL display + copy, and a test button.

all conversations and session alerts in one triage view

• All comms in one place — SMS, Gmail, and channels aggregated with sessions.
• Channel filtering tabs — filter by All / SMS / Gmail (and channels) with unread badges.
• Native viewer routing — clicking a row opens the correct native viewer.
• J/K navigation — keyboard move through inbox conversations.
• Attention badge — a combined session + messaging attention count.
• Clears as you read — opening an SMS thread removes it from the inbox and clears its unread dot in the same moment; the app's own automatic selections never remove a thread you did not open.

user-defined rules that act on incoming messages automatically

• Condition + action chain — 1–10 ordered actions per automation, after the spam filter.
• Condition types — always / rule (glob, keyword, regex) / AI (structured JSON, fail-open).
• Action types — auto-respond, label, archive, whitelist, summarize, forward, notify, spawn a session.
• Template variables — sender/body/channel/subject in action config.
• Natural-language authoring — describe a rule in plain English; a parser builds it.
• Preset templates — prebuilt single- and multi-action starting points.
• Rate limiting — per-automation cooldown, concurrency cap, circuit breaker.
• Run activity log — per-run, per-action results recorded.

hybrid classification for SMS and Gmail via the automations pipeline

• Toggle hierarchy — master → per-service → per-service AI.
• Rule pipeline — allow rules → block rules → AI fallback → fail-open.
• Claude Haiku fallback — classifies uncertain messages.
• Filtered section UI — a collapsible "FILTERED (N)" list with the method shown.
• "Not Spam" restore — one-click un-flag returns a conversation.

your calendar as a project plus agenda notifications

• Calendar project view — month/week/agenda backed by the Google Calendar API.
• Channel adapter — events surface in the unified inbox/search.
• "Starting soon" reminders — a configurable minutes-before alert.
• Add/changed notices — separately-toggleable notifications on event changes.
• Quick add — natural-language event creation.
• Calendar AI chat — an AI assistant over your calendar.

search and read your Drive files

• Drive channel adapter — read-only search surfaced in unified search.
• Doc import/publish — import a Google Doc; publish markdown to a Doc with tables.
• MCP Drive server — exposes Drive to agent sessions (search, list, read, info, quota; read-only).

read and query spreadsheets; resolve contacts

• Sheets channel adapter — read-only search over Sheets.
• AI Sheets assistant — natural-language queries over sheet data.
• Contacts service — resolves and ranks Google Contacts for recipient auto-complete.
• Shared OAuth — one googleapis OAuth across Gmail/Calendar/Drive/Sheets/Contacts.
• Google Workspace MCP — an MCP server exposing Workspace tools to agent sessions.

surface what needs you without babysitting

• OS notifications — desktop alerts on needs-you, stalled, error, auto-responded, auth-expired.
• 3-way behavior — always / only-when-backgrounded / never.
• In-app toasts — 19 categories, each with its own on/off switch except Errors and Warnings, which always show.
• Notification sounds — 8 built-ins + system sounds + custom uploads, per-type assignment.
• Pre-decoded audio + per-minute cap — sounds replay smoothly; at most one chime per type per minute.
• Quiet recovery sounds — "restored/resolved" notices skip the alarm chime.
• Click-to-focus — clicking a toast restores the window and deep-links to the session.
• Auth-expired alert — a silent OS notice when a token fails to refresh.
• Auto-focus on needs-you — optionally bring the window forward.
• Text-to-speech read-out — optionally speak the alert.

control noise globally, per-project, and what happens after you reply

• Silence mode — mute all notifications globally or until a set time.
• Per-project mute — silence chosen noisy projects.
• Per-channel toggles — separate on/off for incoming SMS and calendar reminders.
• Off-dashboard alert — a "Go to Session" toast and nav badge when you're elsewhere.
• Post-send navigation — stay / next-in-project / next-in-inbox / clear panel, configured separately for inbox vs project.

a backgrounded phone or browser still gets notified

• Mobile FCM push — paired phones get Firebase push on needs-you / error / ended.
• Web push — PWA/browser push from a real per-device subscription.
• Content-free privacy mode — optionally strip message text, keeping only deep-link IDs.
• Invalid-token pruning — dead device tokens are pruned server-side.
• Broken-phone watchdog — an opt-in alert if a phone connects but never reports a load.

batches noisy inbox alerts so you're interrupted once, not per-item

• Batch gate — needs-you, SMS, digest, and approval items queue instead of each firing.
• Rule triple — fire on a count threshold, a time threshold, or both.
• Toolbar bell pill — off / armed / tripped states, pinnable.
• Whitelist bypass — chosen sessions always alert individually.
• Pierce states always fire — errors/auth/rate-limit are never silenced.
• Inbox-hide overlay — the armed state visually quiets sidebar dots, badges, and counts.
• Click-and-hold peek — temporarily reveal hidden items without ending the cycle.
• Auto re-arm — returns to quiet once the inbox drains.
• Pomodoro integration — optionally auto-enables during focus blocks, off during breaks.

a once-a-day AI catch-up across all your channels

• AI summary via Haiku — a cheap Claude-generated recap with a daily $ cap.
• 9 configurable sources — sessions, SMS, Gmail, Calendar, Telegram, Slack, RSS, PM events, PM feed.
• Custom schedule — a user-set hour and minute.
• 7-day catch-up — backfills recent history on first run.
• Follow-up Q&A — ask questions about the digest after it's generated.
• Per-alert dismissal + permanent suppressions — dismiss items; permanently hide recurring alerts.
• Per-section toggles + per-project exclusions — hide whole sections or leave projects out.
• Category hotkeys — act on the digest when its viewer is active.

periodic recaps beyond the daily

• Weekly summary — a Monday-morning recap with AI coaching suggestions.
• No-op without a key — quietly does nothing for OAuth-only accounts (costs nothing).
• Meeting digest schedule — an opt-in daily/weekly "catch me up" meeting recap.
• Claim-before-spawn — a once-per-period key prevents double-firing across restarts.

the turn-end AI pipeline that reads each agent reply and either rewrites or triages it

• Plain Speak rewrite — rewrites a completed reply into a glance-readable plain-language card.
• Original view toggle — flip between the plain-language card and the raw message.
• Delete-only section reviewer — blanks card sections that don't earn their place.
• Jargon scrub — grammar-safe de-jargoning of the card.
• Gate-report native card — dev-pipeline gate reports render natively (free), never a paid rewrite.
• Literal-read skip gates — skips the rewrite on interrupts, rate-limit, and auth/API errors.
• Inbox Pilot triage — a cheap classifier sorts each turn into keep/hide/archive/snooze/respond.
• Auto-archive / auto-reply / scheduled respond — the Pilot can clear low-value turns or reply for you.
• Per-session enable toggles — Plain Speak and Inbox Pilot each opt-in per session.
• Global rules editor — plain-English rules tell the classifier how to triage.
• Preview + pause-all — dry-run the pipeline; one master switch pauses it app-wide.
• Decisions audit log — every classification/rewrite persisted with reason, tokens, and cost.

auto-generated next-step replies plus saved reusable responses

• Suggestion chips — 3 auto-generated next-step replies per session (shared across Session/SMS/Email).
• Prefetch + Alt+1/2/3 send — generated ahead of time; a keyboard shortcut sends the match.
• Flash-before-send — a brief visual confirmation on activation.
• Rate-limit recovery — suggestion generation survives rate limits by switching accounts.
• Response snippets — save frequently-used replies with optional auto-submit and usage tracking.
• Quick Reply picker (Zap) — a dropdown of saved quick replies.
• Quick-reply nudge pill — detects repeated phrases you type and offers to save them.
• Style profile — learns your writing voice to shape email/SMS suggestions.

automatic human-readable names for every session

• Auto-generated titles — names a session from its conversation content.
• Configurable prompt — customize the title-generation instructions.
• Cheap-provider routing — runs on a cheap utility model to keep cost near zero.
• Commit-message drafts — AI-drafted conventional-commit messages and change summaries.

a persistent structured self-coaching system built on real sessions

• Coaching hub — a dedicated sidebar space, seeded on enable.
• Interview library — dozens of seeded interview prompts to start a conversation.
• Save from transcript — turns a finished interview into a durable first-person artifact.
• Versioned artifacts — every save is a new version; history never overwritten.
• Progressive context — prior artifacts auto-fed into each new interview.
• Core profile — a synthesized who-you-are summary, regenerated only when artifacts change.
• Coaching snacks — short follow-up sessions generated from your artifacts + profile.
• Check-in scanner — a periodic heartbeat that can drop a gentle journaling nudge.
• Notification chime — a once-per-attention chime when a coaching session needs you.
• Artifact export + embeddings — export artifacts; a semantic index of them.

a structured self-assessment folded into your profile

• Two inventories — rate yourself across Symptoms and Strengths.
• Dated takes — each assessment is a "take"; copy prior ratings forward.
• Per-category rollups — deterministic scoring, no AI spend.
• Notable-items summary — surfaces the most-present items into the coach's context.
• Change-since-last-time trends — shows what shifted between takes.
• Local-only — never leaves your computer.

AI condensation across surfaces, routed to the cheapest capable model

• TTS summarization — condenses a long message before read-aloud.
• Account-switch context transfer — compacts session history into a briefing when switching accounts.
• Compaction summary viewer — an on-demand "Show summary" reads the CLI's compaction summary.
• Email / SMS thread summaries — an AI recap of a conversation.
• LLM provider routing — one internal service routes every utility AI call to the cheapest capable provider (Groq/Together/DeepSeek/OpenRouter/OpenAI/Anthropic) with a transparent Anthropic fallback, circuit breaker, and per-feature cost tagging.

a multi-account credential system authenticating every spawned session

• Multi-account OAuth login — add multiple Claude accounts, each tracked independently.
• API key accounts — add an Anthropic API key, encrypted at rest.
• Account switcher — lists accounts in best-next switch-priority order.
• Automatic load balancing — spreads sessions across accounts by lowest utilization.
• Usage dashboard — real-time 5-hour + 7-day credit usage per account with stale warnings.
• Context transfer on switch — dead sessions get a compacted briefing instead of losing history.
• Rate-limit / capacity recovery — rate-limited sessions auto-recover on the current or fallback account.
• Model picker — the current Claude lineup plus legacy models, per session.
• Reasoning-effort control — per-session thinking level: Auto / Low / Medium / High / Max.
• Non-Claude provider picker — Codex, Gemini, DeepSeek, Kimi, GLM, MiniMax, Cursor, Grok/GPT, Pi, and more as harness.
• Hardware-swap hardening — detects dead-decrypt credentials and self-heals on re-auth.

13 complete visual redesigns plus unlimited custom themes

• 13 built-in skins — Glassmorphism, Linear, Aurora, Neon, Spotify, Luxury, Vercel, Liquid Glass, and more.
• Dark / Light / System — each skin has dark and light palettes.
• Live preview — themes apply with no restart.
• Accent color system — each theme drives buttons, links, and active indicators.
• Custom `.theme.json` themes — author themes with ~50 CSS variables; import, open folder, delete.
• AI-assisted theme guide — a built-in guide teaches the AI to create a theme file.
• CSS-injection-hardened — theme values are validated so a shared file can't break out.
• Sidebar position + text size — left/right sidebars; separate desktop and mobile text size.
• Chat depth & motion dials — message-shadow depth and a motion/polish elevation dial.

a unified glass title bar and a stack of status banners

• Glass drag bar — a frameless frosted title bar; the whole bar is a window drag region.
• App icon → inbox & attention badge — the favicon jumps to the inbox; an accent count of needs-you sessions.
• Animated logo — the orb swirls in the title bar, Quick Launch, the loading card and the Windows downloader while in use; right-click it to turn it off.
• Custom caption buttons — minimize/maximize/close on Windows; native traffic lights on macOS.
• Standalone window title bars — for detached windows.
• Offline / reconnecting / connection-lost banners — network state, gated so blips don't flash.
• App-frozen banner — "app may be frozen — waiting" when the main loop stalls; auto-clears.
• Safe Mode banner — shown when the app booted in Safe Mode.
• Credential / backup / extensions nudges — first-run offers to add a key, import a backup, or install extensions.

fully rebindable in-app shortcuts and OS-level global hotkeys

• Rebind any action — customizable in Settings via inline capture.
• Multiple combos per action — an action can hold several bindings.
• Conflict detection — flags a combo bound to multiple actions, scoped per area.
• Chord bindings — two-key "X > Y" sequences.
• OS-reserved guard — rejects binding reserved combos.
• One-handed preset — a one-click left-hand-only layout, reversible.
• Global hotkeys — bring-to-front, Omni briefing, Quick Launch, voice push-to-talk.
• Global-hotkey conflict report — reconciles what actually registered with the OS.
• CLI-instant changes — shortcut-only settings apply immediately over the CLI.

a two-phase first-run experience with cinematic reveal and auto-install

• Guided first-run — 10 steps (11 on macOS): Language and look → Tell us about you → How your data is handled → Choose your AI → Connect your AI → Add an API key (optional) → Install the essentials → Grant permissions → Choose agent autonomy → Share your feedback → What happens next.
• Cinematic intro — full-bleed intro slides with a fading overlay.
• Theme gallery step — pick a skin during setup.
• Project step auto-launch — creating the first project auto-launches its first session.
• Fire-and-forget toolchain install — the setup slide installs recommended tools in the background.
• Post-onboarding install check — re-checks and toasts if any tool failed.
• Auto-start demo tour — a 34-step interactive demo on injected sample data (no DB writes).
• Re-runnable — re-launch the wizard anytime from Settings.
• Cascade onboarding — a parallelism-cascade first-run redesign subsystem.

detect and one-click install a large curated CLI catalog

• Curated tool catalog — ~40 tools across AI agents, git, cloud, containers, runtimes, browsers, media, security.
• First-run recommended sweep — a default subset auto-installs; heavier tools are opt-in.
• Auto-detect installed tools — probes binaries and shows green/amber status.
• Just-in-time install — some tools install on demand when a flow needs them.
• Install provenance — a consent screen shows each tool's source.
• Retry / update per tool — re-run install or update from Settings.
• Update alerts for Claude Code and Codex — an inbox card with a one-click Update now when either agent CLI falls behind; the update runs in a terminal on your computer.
• Update alerts for your other tools — the same card and one-click update for Git, GitHub CLI, pnpm, OpenCode, Bun and the other recommended tools (a download page for the hand-installed ones), with its own switch.

a guided-tour overlay system plus a behavioral nudge engine

• 12 standard tours — Welcome, Core Workflow, Recipes, Gmail, SMS, Automations, Voice, Settings, and more.
• Tour chaining — each tour's last step suggests the next.
• Spotlight + overlay steps — darkens the screen and highlights a real UI element.
• Rich step blocks — text, bullets, tips, prerequisites, try-it, and keyboard-shortcut blocks.
• Contextual auto-offers — feature tours offer themselves on first use.
• 34-step interactive demo — injects fake projects/sessions into the real dashboard.

inline rendering of five file formats in the viewer

• Markdown preview — GFM with syntax highlighting.
• SVG preview — sanitized to strip escape hatches.
• HTML preview — in a fully-sandboxed iframe (no JS, forms, popups, or network).
• Mermaid diagrams — async render with a red error card on failure.
• LaTeX math — KaTeX display mode, sanitized output.
• Raw / Preview toggle — defaults to Preview; resets on file change.

a searchable, room-organized settings surface

• Full-text settings search — per-section indexes with keywords/synonyms; deep-link to any setting.
• "Rooms" layout — reorganized, better-named settings groups (shipped as default).
• Settings hubs — grouped hub pages: Keyboard Shortcuts, Email, Inbox, Automations.
• Setup Assistant — re-run onboarding, run the demo, launch tours.
• CLI-driven settings — settings patchable over the control server (with approval gating).

multi-language UI with English fallback

• Language picker — only languages past a coverage threshold appear.
• Fallback to English — any untranslated string falls back.
• 34 languages — European, Chinese, Japanese, Korean, Hindi, Arabic/Urdu/Persian (RTL), and eight Philippine languages.
• Offered by default — every language ships in the picker with no reveal step; English stays the default, and first-run OS detection never auto-switches you to a non-English language.

a universal, theme-aware tooltip layer over every control

• Global native-title interceptor — styles every plain `title=` app-wide.
• Rich tooltips — portal-mounted, hover-delayed + focus-triggered, optional multiline/interactive.
• Hotkey key-caps — a hotkey control renders its key as a cap in the tooltip.
• Theme-customizable — tooltip colors driven by CSS vars.
• Touch-safe — suppresses hover tooltips where hover isn't supported.

a WebSocket + HTTP server that mirrors the app to a phone browser/PWA

• WebSocket + HTTP listener — streams UI state and dispatches actions to remote clients.
• Mobile-optimized responsive UI — a full touch layout with a bottom tab bar and drill-down.
• QR code pairing — scan an on-screen QR to connect a phone instantly.
• 256-bit token auth — a per-install bearer token gates every route, compared constant-time.
• Private Tailscale access — by default only your own devices signed in to Tailscale can reach it; public internet access (Tailscale Funnel) is an off-by-default switch with a warning.
• Connected device management — see and revoke paired devices.
• Installable PWA + share-target — install to the home screen; share screenshots/content in.
• WebSocket compression + delta batching — 60–80% smaller payloads over slow links.
• Bootstrap hydration — one handshake frame hydrates the whole remote store.
• Freeze-aware keepalive — won't drop a healthy phone when the desktop stalls.
• Security hardening — brute-force limiting, DNS-rebinding defense, same-origin guard, settings redaction.
• File Peek + messaging over web — view files and use SMS/Telegram from the phone.

launch Claude Code sessions on remote SSH servers, not just the local box

• Remote session launch — run a session's process on an SSH-connected server.
• Password-bootstrap wizard — enters a one-time password, then installs keys for key-based auth.
• Ed25519 key generation — app-managed keypairs per remote.
• TOFU host verification — trusts a new host once, rejects a changed key.
• App-isolated known_hosts — keeps host keys out of your `~/.ssh`.
• Per-remote config + ProxyJump — host/port/user/key/workdir/env and multi-hop jump hosts.
• Connection testing — test reachability and Claude availability before launching.
• Injection-hardened validation — hostnames/usernames reject unsafe characters.

a bearer-authed HTTP control plane on 127.0.0.1:19519 covering every surface of the app

• Localhost HTTP server — port 19519, with an off-switch.
• Bearer-token auth — a token in the OS vault, auto-delivered for skills.
• Four caller identities — full-trust, in-app-session, agent-session, and narrow mcp-capability tokens.
• Deny-by-default paid spawn — the session-spawn route refuses agent tokens unless the owner opts in.
• Session spawn — create a real session in a project, with force-title and harness knobs.
• Spawn pacing + idempotency — a durable queue releases spawns steadily; a request-id de-dupes retries.
• Provenance headers — trace every action/spawn back to its origin session.
• Approval-gated actions — many mutations land as inbox "pending" rows until approved.
• Per-family + per-action approval overrides — turn approval on/off per action family, or auto-approve one exact kind.
• Read budgets + activity log — sensitive reads throttled; every call audited to a "Recent CLI Activity" card.
• Capabilities intent-search — map a plain-English goal to a route.
• Kill switches — per-feature CLI toggles act as panic buttons.
• Broad route coverage — projects, sessions, tags, recipes, cron, automations, settings, share, bookmarks, scratchpads, SSH, web-access, AHK, messaging, voice, vault, coaching, PM boards, integrations, alerts, diagnostics, backup.

publish self-contained HTML artifacts to a public capability URL

• Share Engine — renders a conversation/artifact into one fully-inlined HTML file.
• Relay-backed publisher — a Cloud Function mints the token and signed upload URLs.
• Selection / message / session scopes — share a text selection, one message, or a whole session.
• Publish from CLI — publish from a file path or pasted text (the mobile artifact flow).
• Password protection + expiry — gate a share behind a password; set an expiry or "never expires".
• Republish in place — refresh content while keeping the URL.
• Revoke + delete — take a share offline server-side.
• Send to channel — deliver a share link out via a messaging channel.
• Share comments — viewers can comment.
• View poller + alerts — track view activity.
• Shares panel — manage published shares in-app.

save URLs, paths, programs, commands, and in-app jumps one click away

• Eight kinds — Folder, URL, Path, Executable, Command, plus Session/Project/Virtual navigation jumps.
• Toolbar popover — a searchable hierarchical tree.
• Launch behavior — URLs in the browser, paths in the OS default app, executables detached, commands with a first-run confirm.
• In-app nav bookmarks — jump to a session/project/virtual by id, with live labels and broken-link detection.
• Quick-bookmark a session — Shift+B, context menu, or popover, with undo.
• Nested folders + reorder — up to 5 levels, drag-to-reorder, spring-loaded auto-expand.
• CLI control + hardening — 6 routes, with executable launch rejected over the CLI.

link external doc bundles/lists into a project's auto-context

• Vendored CLI — spawns the ContextDock CLI; API key via env, never logged.
• Link bundles/lists/docs — a snapshot written into the project's docs folder.
• First-message injection — the snapshot inlined into every new session's first message.
• Three picker tabs — Bundles, Lists, and full-library search.
• Compression levels — Original / Key Points / Summary per doc, with running token totals.
• Bundle pinning + preview — pin bundles; view the rendered markdown.
• Manual refresh + unlink undo — snapshots don't auto-update; unlink with a re-link undo.
• Rate-limit governance — one chokepoint paces requests under the per-key cap.

a real folder-backed AHK project with a managed hotstrings file

• AHK project — a real linked project with a Monaco editor.
• Managed hotstrings file — generated from a table, with an atomic write and clobber guard.
• File watcher + reload-on-save — watches for changes and reloads the running script.
• AI text-correction block — optional proofread/shorthand keys wired to the CLI.
• Add as hotstring from anywhere — the AI Text Correction panel saves what you typed and its correction as a permanent hotstring, and reloads your script so it works at once.
• Script index AI pipeline — a 2-stage extraction turns scripts into a searchable index.

clipboard history accessible over the control server

• History list — read recent clipboard entries.
• Copy back — re-copy a stored entry.
• Pin / delete / clear — manage the history.

debug logging, exports, feedback, and detachable windows

• Debug log ring buffer — a 2,000-entry in-memory log with live streaming in Settings.
• Diagnostic bundle — assembles device/version/log context for reports.
• Log export — a ZIP of all application logs.
• In-app feedback — bug/feature reports sent with auto-collected diagnostics.
• Detachable windows — pop a session/panel into its own window with per-window push routing.
• Main-loop heartbeat — tracks main-loop stalls, feeding freeze detection and the web keepalive.

a background daemon that merges ready branches into the main branch locally, never pushing

• In-process land engine — replays a branch's commits and advances the base via one atomic compare-and-swap.
• ~60s supervisor tick — lands probe-clean `ready-to-merge` branches one at a time.
• Comes on with the Dev Pipeline — enabling the Dev Pipeline arms it and watches every repository the pipeline covers; your own explicit on/off and repo list always win, and any repo can be set to observe-only so it reports "would land" without moving a ref.
• Never writes to a remote — no push, no pull, no remote ref ever moves. The one remote contact is a read: on a partial clone it fetches the specific missing git objects a branch needs before landing.
• 3-strike escalation — after repeated hand-backs, briefly freezes master and reopens the author session to rebase.
• Auto-spawn remediation — on give-up, starts a throwaway session to rebase-and-re-tag the branch. On by default, up to 4 at a time; these are billable sessions.
• Give-up alert self-clears — the "merge by hand" card withdraws once the branch later lands.
• Land-event history — records landed + conflict outcomes.

a SHA-bound tag, set only after a full check run, that authorizes autonomous landing

• Full gate run — lint + typecheck + tests + build before a branch can be tagged.
• SHA-bound tag — the tag embeds HEAD; a later commit invalidates it.
• Hook-enforced push block — refuses push / PR-create unless the tag is valid and current.
• Auto-land authorization — a valid tag is the standing approval for the auto-lander.
• Shared check-slot pool — tests/typecheck/lint draw from one machine-wide cap so parallel agents can't saturate the box.
• Scoped agent commands — changed-files-only test/typecheck/lint for cheap iteration.
• Guard lane — cross-cutting guard tests always run at the gate.
• Bundle preflight — a fast main+preload compile catches "green gate, red build" breaks.

heavy verification runs on rented scale-to-zero cloud VMs instead of the local box

• Five hooked gates — tests, typecheck, lint, build-verify, and E2E can offload with `--cloud`.
• Scale-to-zero fleet — Windows + Linux runner VMs wake on demand and self-stop when idle.
• Durable cloud queue — a kill-proof GCS-backed queue with a fail-open ladder to legacy tunnel or local.
• Enforce / queue-only modes — route heavy work to cloud (or wait), never a false-red or a local storm.
• Cloud spend cap + alert — a hard daily ceiling downgrades to local, with a spend alert.
• Per-VM immutable envs + build cache — one dependency install per VM; cached build output speeds E2E.
• Fleet self-healing — spot-preemption recycle, disk auto-heal, mirror-corruption self-heal.
• 3-hourly scheduled build net — builds master on a VM and alerts (email + inbox) only on a real, reproduced break.

every session runs in an isolated git worktree, created and torn down through safe chokepoints

• Create concurrency gate — caps simultaneous worktree creation so a spawn burst can't saturate the disk.
• Single create chokepoint — all creation routes through one gated path.
• Paces, never caps — queues creates FIFO; never declines a spawn or reduces session count.
• Retire-then-sweep teardown — removal instantly renames the folder to trash; a background sweeper deletes it paced.
• Dirty & live-run vetoes — never destroys uncommitted work or reaps a live dev-pipeline run.
• Stranded-worktree reaper + backlog surge — cleans loose worktree dirs, ramping cadence when a pile-up is detected.
• Worktree Cleanup dashboard — an in-app scheduler with status card, history, and run-now.
• Choose the triage engine and model — two dropdowns picking which AI runs the paid stranded-worktree triage session, each with a Default option (DeepSeek V4.1 Flash). The model list follows the engine you pick and only offers combinations that can actually run.

a torn runtime dependency that fails a local gate is repaired by name and retried once

• Failure-text detection — extracts the torn package name(s) from the tool error.
• Scoped repair + one retry — reinstalls only those packages and retries once.
• Fail-closed — genuine failures return their real code; a bulk problem fails loud.
• Predev integrity gates — self-heal a torn tree or missing Electron binary before launch.

machine-wide gates that pace agent work so heavy load never freezes the box (slow the agents, never the user)

• Heavy-job broker — caps how many heavy background job-trees start at once, widening spacing as CPU heats up.
• Disk-pressure & RAM-floor holds — hold new heavy admissions during a disk storm or a RAM collapse.
• Search admission — thread-caps + gates agent `rg`/`grep` and batches the `find -exec` fork-bomb.
• Git admission — a light pool caps agent-shell git walks and the app's own git polls under load.
• Spawn admission — paces agent package-manager tree-starts and programmatic session spawns box-wide.
• Fail-open + kill-switched — every governor degrades to normal, never an outage; user sends are never paced.

a live view of the app's own processes for diagnosing load

• Process discovery — walks the app's process tree.
• Per-process CPU/memory — sampled with inline sparklines.
• Kill a process — with a guard so a stale snapshot can't target a recycled PID.
• Service pause/resume — pause/resume background services from the panel.
• Zero cost when closed — timers clear when the last viewer leaves.

tracks metered API spend and enforces per-feature daily caps

• Per-model cost logging — records each API response's cost, priced from a single source of truth.
• Per-feature daily caps — a shared gate sums today's spend per feature (KMS, mind-map, coaching, council, writer).
• Fail-open caps — a transient DB outage reads as allowed so a paid feature isn't starved.
• Non-fatal — silently swallows DB failures so tracking never breaks a feature.

app-enforced git safety for spawned agent sessions

• Bundled PreToolUse hook — auto-wired into each session via a session-private settings file.
• Protected-branch & destructive-op blocks — stops an agent committing/pushing to master or stashing over other WIP.
• Per-repo exclusion + time-boxed pause — exempt a repo or pause the guard.
• Fires in autonomous mode — a hook, not a permission card, so it survives bypass modes.

off by default; turn it on in Settings → Features) — machine-wide git safety for EVERY Claude session, reusing the Git Guardrails engine

• Machine-wide — installs one hook into your global Claude config, so every Claude Code session on the machine is guarded, not just the ones Omniscio spawns.
• Same blocks, reused engine — protected-branch commits/pushes/edits and destructive stash, via the same classifiers as Git Guardrails.
• Cross-platform — works on Windows, macOS, and Linux.
• Shared pause + exclusion, clean revert — the same time-boxed pause and per-repo exclusion as Git Guardrails; turning it off removes it cleanly.

off by default; turn it on in Settings → Features) — keeps pasted API keys out of your saved history

• Paste detection — spots an API key / token / password pasted into the composer and offers to protect it.
• Handle substitution (Claude-binary engines) — stores the value locally under an opaque `AMCSECRET-<hex>` handle; the model only ever sees the handle, and a bundled PreToolUse hook swaps in the real value at execution.
• History scrub (every engine) — the real value is redacted from the local DB, search index, drafts, exports, on-screen chat, and (after the session ends) the Claude transcript.
• Fail-safe — on any error the literal handle stays and the action fails harmlessly; never a leak, never a blocked command.

installer plumbing, action tracing, and workspace/verify tools

• Toolchain management — install, check (concurrency-gated), and update the external CLIs the app drives.
• Session provenance — trace inbox actions and spawns back to the originating session ("Generated by" / "Spawned by").
• Self-serve workspaces — create and switch between the workspaces (orgs) you belong to.
• Web-app verify (Obscura) — a tool that functionally checks a web app the agent builds (load, elements, no console errors).
• Database encryption — encrypt the local DB at rest (off by default), sealed by the OS keychain with a recovery code.
• Smart Share Reaper — old, unviewed "never-expires" shares get a Keep/Delete prompt with a grace expiry.

a private knowledge base your agents can read, write, and cite (default off; enable in Settings)

• Notes & vault — capture structured knowledge the app and your agents can search and cite.
• Agent read/write — sessions query and update the vault via the knowledge tools, metered by per-feature caps.
• UI says "Vault" — the persisted store keeps its internal names; the interface calls it Vault / The Vault.

manage the reusable skills your agents can use, and see which cost the most overhead

• Skills panel — browse, enable, and disable your global, project, and plugin skills from a dedicated surface.
• Skill overhead insight — a companion view flags which skills add the most token overhead so you can prune.
• Bundled vs your skills — distinguishes skills Omniscio ships from ones you or a plugin added.

a sandboxed, read-only AI tutor that answers questions about Omniscio and hands off build requests

• Read-only tutor — answers "how do I…" questions about the app without touching your projects.
• Hand-off, not do — asked to build something, it points you to spawning a real session instead of thrashing.

manage the MCP tool servers available to your agent sessions

• Global server list — add, enable, and disable MCP servers centrally.
• Per-project & per-session overrides — choose which servers a project or a single session gets.
• Secret-safe — a credential-bearing server fetches its secret at call time, never in plaintext config.

a guided flow to declutter your inbox by sender

• Sender walkthrough — an AI-guided pass over your senders to keep, archive, or unsubscribe in bulk.
• Classic layout option — a simpler flat sender list for those who prefer it.

one-tap AI summaries of long emails and threads

• Summarize a message or thread — condense a long email into its key points.

a panel that watches your open pull requests and helps you land them

• Open-PR queue — a live list of your pull requests, each with a one-line AI summary.
• Babysit to merge — track checks and merge-readiness from one place.

invite workspace members to specific channels with roles

• Per-channel roles — invite members as owner, member, or read-only.
• Post controls — decide who can post (everyone, or owners only).

ask for tailored music recommendations from inside the app

• Recommendation helper — get music suggestions via a bundled helper skill.