--- title: Quick Launch Modal --- # Quick Launch Modal ## What it is Quick Launch is a global-hotkey floating composer for starting a new Claude session from anywhere on your computer — think Spotlight on macOS or Alfred on Windows. Press the hotkey (default **Ctrl+Space**), a small centered window pops up over whatever app you're in, you type (or dictate) a prompt, hit Send, and a brand-new Claude session starts running the prompt in your chosen project's folder — and if you launched Quick Launch from another app, it leaves you right there rather than yanking you into Omniscio (see the focus note below). No app-switching to get the modal up; no app-switching to dismiss it (Esc or click outside). The modal is **enabled by default**. The hotkey, the on/off toggle, and the default-project picker all live at **Settings → Quick Launch** (their own dedicated page). What it looks like: - A 720×660 px frameless, opaque, always-on-top window, horizontally and vertically centered on your **primary** display (re-centers on every open in case you docked/undocked a monitor between opens). The size is **one fixed geometry for every tab** — no tab or overlay ever resizes the window (a live resize used to flash a white strip for a frame on Windows; entrance-animation contract I21). - Three things inside: a textarea for the prompt (wrapped in a rounded inset card with its own subtle fill + a focus accent ring on the card itself, its edges aligned with the tab strip above), a small chip row with the active **Project** (its real icon — Claude logomark, Gmail glyph, language-type badge, or custom-uploaded image — followed by the name) + the **microphone** button (shown only when voice input is enabled — off by default, see "Dictate" below) + the **Send** button, and a thin info strip for inline errors. - The window is "kept alive" across opens — the React tree mounts once and state persists. **By default your unsent draft (the typed message, any pasted-text chips, and any staged attachments) is kept** when you close without sending — Esc or click-away leaves it intact, and the next open resumes it **on whichever composing tab you left it on** (the New Session tab or a repo tab — both share the same draft), so it's right there; it no longer yanks you onto the generic New Session tab. (Only if you'd closed from a tab that can't show the draft — say Calendar — does the next open land on the New Session tab so the draft isn't hidden.) **Submitting always clears it**; the **Reset (eraser) button** in the composer wipes it on demand (text, chips, and attachments together); and turning **off** the _Remember unsent Quick Launch text_ setting makes every close start blank instead. The draft lives in memory only, so a full app restart always starts fresh. - A thin **tab strip across the top** lets you switch the body to a different "quick-add" surface without leaving the modal. The default pinned tabs (left → right) are **Session** · **Search** · **Ask Omniscio** · **Automation** · **Alarm** · **Task** · **Calendar** — Session first, then the three tabs that start a session, so the strip opens on what you actually came to do. Three of those seven are feature-gated off out of the box (Alarm needs Alarms on, Task needs Tasks on, Calendar needs Google Calendar connected), so a brand-new install shows exactly four: **Session · Search · Ask Omniscio · Automation**. **Drip** and **Bookmark** used to be pinned by default and no longer are — they are still full tabs, one click away from the strip's **"+"** or **Settings → Quick Launch**. If your strip is still the untouched old default, Omniscio moves you onto the new one **once**, automatically, next time it starts; if you have ever reordered, removed, or added a tab, your strip is treated as yours and left exactly as it is. You can also pin **repo tabs** — a tab for a specific repo that opens the composer locked to it, so starting a session there is one click with no project-picking (see "Repo tabs" on the [second page](quick-launch-modal-part-2.md)). Each tab swaps the body for a focused mini-form for that thing — the project chip + microphone + Send strip is replaced by whatever input layout the tab needs. The strip's right end holds a small **"+" button** — click it to add another tab: a registry action you've enabled but not pinned (e.g. Search, Ask Omniscio), or **"New session in a repo…"** to pin a repo tab — next to a **gear icon** that deep-links to the settings card for full pin/unpin/reorder. You can also **drag the tabs right in the strip** — grab any tab (Session included) and drop it left or right to reorder; the new order saves instantly and persists across opens and restarts. A quick tap still just switches to that tab — only an actual drag reorders. **Right-click any tab** for a small menu with a **Global hotkey** field at the top: press a key combo to assign a global shortcut that opens Quick Launch straight to that tab (the same shortcut you can set in Settings, now assignable right on the tab), or press the **×** to clear it. Below it, every tab **except Session** also gets a **Remove from Quick Launch** option that unpins it on the spot — no trip to Settings; re-add it any time from the **"+"** or the settings card. (Session's menu shows the hotkey field only — it stays pinned and can't be removed.) When you pin more tabs than the fixed-width window can show, the tab row **scrolls horizontally** instead of pushing anything off the edge — a round **◀ / ▶ chevron** fades in on whichever side has more tabs (click it, spin the **mouse wheel** over the tabs, or press **Ctrl+Tab** to scroll), while the **"+"** and **gear stay pinned** at the right and are never clipped. The **Alarm** tab is gated by **Settings → Notifications → Alarms**, the **Calendar** tab by **Settings → Google Workspace** (Calendar Integration), and the **Ask Omniscio** tab by **Settings → Ask Omniscio** — disabled tabs are hidden from the strip (the strip just shrinks; no empty slot). If you unpin every non-Session tab the strip collapses to Quick Launch's single-pane shape — unless you still have an action or repo available to add, in which case the strip stays (just the Session tab + the **"+"**) so pinning one back is one click away. (The strip carries no always-visible shortcut labels, but **hovering one of the first nine tabs reveals its direct-jump shortcut — Ctrl+1 … Ctrl+9 — as a tooltip**; **Ctrl+Tab** / **Ctrl+Shift+Tab** still cycle through them.) The composer is its own Electron `BrowserWindow` (separate from the main Omniscio window), with its own React process. That's deliberate: the modal can pop up while Omniscio's main window is minimized or in the background, and the cross-process boundary is the suppression seam that lets dictation work without firing main-window voice commands (see "Voice dictation" below). Because it's a separate window, when you dismiss Quick Launch **on purpose** — submit an action, press **Esc**, or **Ctrl+W** — keyboard focus is handed back to the main Omniscio window right where you were, so your app hotkeys (e.g. **E** to archive) keep working without having to click back into the app first. This only happens when Omniscio was already where you were: if you summoned Quick Launch over a different app, focus stays with that app on close. (Clicking away to another app to dismiss it also leaves your focus alone.) ## Where to find it ### Open the modal Press your configured Quick Launch hotkey from anywhere on your computer. Default: **Ctrl+Space**. If the modal is already visible: - And **focused** (the usual case — Quick Launch auto-hides when it loses focus): the second hotkey press **closes the modal**, exactly like Escape or Ctrl+W. Ctrl+Space is a true toggle — press to open, press again to dismiss. (If something is open on top — a menu, a dropdown, a popover, the emoji picker, a palette, or a sub-picker like the Ctrl+P project picker — the second press closes that first, then the window on the next press — same as Escape/Ctrl+W.) - And **NOT focused** (a rare state — e.g. an OAuth sign-in or file dialog is holding focus): the second press refocuses the window AND selects all text in the textarea — so you can either keep typing to extend the draft or just start over by typing. ### Settings All Quick Launch settings live on their own dedicated **Settings → Quick Launch** page: ### Quick Launch Hotkey A keyboard-shortcut input field. Click the field, then press the combination you want (e.g. `Ctrl+Alt+L`). Click the **X** on the right to clear (which disables the hotkey). At least one modifier key (Ctrl/Cmd/Alt/Shift) is required — single-key shortcuts are rejected. Default: `CommandOrControl+Space`. Behind the scenes the value is stored as an **Electron accelerator string** (e.g. `CommandOrControl+Space`, `Alt+Q`). `CommandOrControl` resolves to Cmd on macOS and Ctrl on Windows/Linux. The hotkey is registered through Electron's `globalShortcut` API on app launch and re-registered when you change it. Conflicts with another app's global shortcut will cause registration to fail silently — pick a different combination if Ctrl+Space is already taken by another app (notably IME / language-switching on Windows, some input-method tools on macOS). ### Enable Quick Launch On/off toggle. Default: **on**. When off, the hotkey is ignored and the floating composer never appears. The hotkey field is not cleared — it's preserved so you can flip the feature back on later without re-entering your shortcut. ### Remember unsent Quick Launch text On/off toggle. Default: **on**. When on, closing the Quick Launch composer without sending **keeps** your unsent Session draft (the typed message, any pasted-text chips, and any staged attachments) so the next open resumes it. Turn it **off** to make every close start from a blank composer — the old "click-away discards your draft" behavior. Either way, **submitting always clears** the draft, and you can clear it on demand with the **Reset** (eraser) button in the composer. The draft is held in memory only (never written to disk), so a full app restart always starts blank. ### Show engine & model picker On/off toggle. Default: **off**. When on, the Session tab shows a single compact **engine chip** that opens the **Engine** + **Model** pickers described under _Pick an engine and model_ above, so you can start a Quick Launch session on a different coding engine or model. When off (the default), the tab always starts sessions on your default engine and model and is byte-for-byte unchanged from before the picker existed. ### Quick Launch Default Project A dropdown of all your real (non-virtual) projects, plus a special **"Last used project"** option at the top. Default: **Last used project**. - **Last used project** — Quick Launch starts each session in whatever project Quick Launch used last time. The first time you ever use Quick Launch (or if the last-used project has since been deleted), it falls back to the currently-active project in Omniscio. - **A specific project** — Quick Launch always starts in that project, regardless of what you did last time or what's active in Omniscio. You can always override the chosen project for the current invocation by clicking the project chip in the modal — that doesn't change the default setting, just the destination for that one session. ### Default project for quick tasks A dropdown of your **Tasks projects** — shown **only when Tasks is enabled** (with it off there are no projects to pick, so the card is hidden). Default: **Inbox**. It sets which project the **Task tab's** Project picker opens on for a quick capture. - **Inbox (the default)** — quick tasks land in your Inbox list unless you pick another project in the popup. - **A specific project** — the Task popup opens pre-selected to that project every time. You can always override the destination for a single capture by choosing a different project in the Task popup — that doesn't change this default, just where that one task goes. Stored as `quickLaunchTaskDefaultListId` on AppSettings (`null` → Inbox; a since-deleted project falls back to Inbox at use time). Invariants: [quick-launch-task-schedule-contract.md](../../.claude/memory/contracts/quick-launch-task-schedule-contract.md). ### Quick Launch Tabs A two-column card listing every action the registry knows about: **Pinned** on the left (drag-handle reorderable; uncheck a row's checkbox to unpin it), **Available** on the right (check the row's checkbox to pin — a row whose feature is **off** is **grayed out with its checkbox disabled**, so you turn the feature on first, then pin it). On narrow widths the two columns collapse to a single stack. The list of actions is data-driven from `QUICK_LAUNCH_ACTIONS` — adding a new tab in code automatically surfaces it here. Each row shows a small **hover "i" info icon** beside its name (in both columns) — point at it, or Tab to it, and a tooltip explains what that tab does, so opaque names (**Drip**, **Web Clip**, **Super Prompts**, **Add Hotstring**, **Team Time**) are self-explaining without opening anything. Repo rows show their project name + icon, so they carry no "i". Defaults: six actions are pinned (Session, Alarm, Task, Drip, Bookmark, Calendar) in registry order; **Search** and **Ask Omniscio** ship in the registry but default to **unpinned** so existing users keep their tab strip unchanged and discover the new tabs via the Available column. **Session is always pinned** — you cannot unpin or remove it (its checkbox is checked and disabled), **but you can reorder it freely**: it has a drag handle like every other pinned row and can sit anywhere in the list (and in the Control Space strip). A pinned action whose feature is off (e.g. Alarm when alarms are off, Calendar when not connected, **Email** when Quick Email is off) stays in the pinned list but shows a short **why-it's-hidden note** next to the row — e.g. _"Turn on Quick Email to show this tab"_ — and is skipped by the tab strip until re-enabled, so a tab you pinned is never silently missing. (A pinned **Email** tab appears as soon as Quick Email is on, even with zero saved recipients — it opens to its add-a-recipient screen.) Persistence: the pinned/ordered list is stored as `quickLaunchPinnedActionIds: string[]` on AppSettings — a list of stable string IDs (not enum values), so a newer Omniscio build can add tab IDs without breaking older saved settings (unknown IDs are silently dropped, then the missing-from-default backfill restores them on read). This also means _unpinning_ a tab and then upgrading to a build that adds a new tab will pin only the new one (not the ones you previously unpinned). The composer's gear icon (top-right of the tab strip) deep-links you straight to this card — clicking the gear hides Quick Launch, foregrounds the main Omniscio window, navigates to **Settings → Quick Launch**, and scrolls/flashes the card. Repo tabs (pinned `repo:` entries) also appear here as rows — resolved to the repo's name + icon, removable via the row checkbox, drag-reorderable like any other pinned tab. They're added either from the composer's **"+"** ("New session in a repo…") **or from this card's "Add a repo session tab" dropdown** below the columns — the Available column itself only lists registry actions. That dropdown lists your spawnable, not-yet-pinned, non-deleted projects (and is hidden when there's nothing to add); picking one pins it immediately. A repo row whose project no longer exists is pruned automatically once the card has your project list loaded. **Adding a tab without leaving the modal:** the tab strip's **"+" button** (just left of the gear) opens a small dropdown of what you can add — every registry action that's enabled but not yet pinned, plus **"New session in a repo…"** to pin a repo tab. **Session is never listed** (it's always pinned). Pick an action and it's pinned instantly and saved to `quickLaunchPinnedActionIds`, exactly as if you'd checked it in the **Available** column here (the "+" reuses the same `SETTINGS_UPDATE` path — no separate save); the repo item opens a project picker first. The "+" hides when there's nothing left to add (no unpinned action AND no spawnable repo). This is the quick path; **right-clicking a tab in the strip** assigns/clears its **global hotkey** inline and (except on Session) removes it in place, and the gear → this card is where you do bulk **unpin / reorder** (and add a repo tab via the **Add a repo session tab** dropdown). **Per-tab hotkeys (open a specific tab from anywhere):** below the pinned/available columns, a **Tab hotkeys** sub-section lists every tab with an optional "press keys…" capture field. Assign a global shortcut (e.g. `Ctrl+Alt+C`) and pressing it from anywhere on your computer pops Quick Launch open _already on that tab_ — the same idea as the Ctrl+Space hotkey, but it lands on a chosen tab instead of Session. It works **even if the tab isn't pinned**: the hotkey-opened tab is shown in the strip for that one open and reverts on the next open. A combo needs at least one modifier (Ctrl/Alt/Shift); the X clears it. You can assign the **very same shortcut inline from the composer** — right-click the tab and use the **Global hotkey** field at the top of its menu; it's the same capture field, so the two screens always agree. **Repo tabs take a hotkey too** — their shortcut opens a new session straight into that project — and every **pinned repo tab** shows up as a row in this Tab hotkeys list alongside the standard tabs. - **Gated by the main Quick Launch toggle** — there's no separate on/off switch. If "Enable Quick Launch" is off, per-tab hotkeys don't register either. - **Disabled tabs are skipped** — assigning a hotkey to a tab whose feature is off (e.g. Calendar when `calendarEnabled` is off, or Email when `quickEmailEnabled` is off) is harmless: it persists but won't register until the feature is on. - **Conflicts lose gracefully** — a per-tab combo that collides with an existing Omniscio hotkey (focus, Omni, Ctrl+Space, KMS, a recipient hotkey, or an earlier tab hotkey) is skipped and logged; the earlier hotkey wins. Per-tab hotkeys register last. - **Storage:** `quickLaunchTabHotkeys: Record, accelerator>` on AppSettings (defaults ship Calendar → `CommandOrControl+Alt+J`, Task → `Alt+Space`, and Email → `Alt+E`; a missing key backfills on read). Editing it re-registers the global shortcuts live (no restart), whether you set it from Settings or inline via the tab's right-click menu. Full invariants (`hotkeys-register-last` … `repo-tabs-hotkey-capable`): [quick-launch-action-registry-contract.md](../../.claude/memory/contracts/quick-launch-action-registry-contract.md). ### Settings search Quick Launch is reachable from **Settings search** (the search box at the top of Settings) via these queries: - `spotlight` / `quick` / `instant` / `alfred` — jumps to the Quick Launch hotkey card. - `enable quick launch` / `disable quick launch` / `turn off quick launch` — jumps to the toggle. - `default project` / `home project` / `launcher target` — jumps to the project picker. - `quick task` / `task project` / `default task project` / `inbox` — jumps to the **Default project for quick tasks** card (shown when Tasks is on). - `quick launch tabs` / `pinned actions` / `manage tabs` / `extensions` — jumps to the tabs card. Pin **Search** or **Ask Omniscio** from the Available column to add them to the strip. - `tab hotkey` / `tab shortcut` / `per-tab hotkey` / `open to tab` — jumps to the same tabs card, where the **Tab hotkeys** sub-section lives. Plus the usual synonyms: `launcher`, `floating composer`, `global shortcut`, `dictate`, `command palette`, `omnibox`, etc. ## How it behaves ### Type and send Type your prompt. The Session tab follows your global **Submit Key** setting (Settings → Sessions): by default **Enter** submits and **Shift+Enter** inserts a newline; switch it to _Ctrl+Enter to send_ and **Ctrl+Enter** (or **Cmd+Enter**) submits while **Enter alone** inserts a newline. **Esc** hides the modal and, by default, **keeps** your unsent draft for next time — press the **Reset** (eraser) button to clear it now, or turn off _Remember unsent Quick Launch text_ (Settings → Quick Launch) to always start blank. The Reset button is disabled only while the draft is fully empty (no text, no chips, and no staged file). **Ctrl+Z** (or **Cmd+Z** on Mac) undoes your last edit — a whole word/burst at a time, not one character — and **Ctrl+Y** (or **Cmd+Y**) redoes, the same text undo/redo as the main chat box. The box holds up to **500,000 characters** — the same cap as the main chat box — and as you approach it a small live character counter appears at the bottom-right (amber past 450,000, red past 490,000); typing or pasting stops at the cap. When you submit: 1. Omniscio comes to the front **only if you launched Quick Launch from inside Omniscio** — if you launched it from another app, you stay in that app (the session is still created; Quick Launch just doesn't pull you away). 2. A new Claude session is spawned in the selected project's folder. 3. Your prompt is sent as the first user message. 4. The Quick Launch modal hides itself. ### Pick a project The chip row shows the active project's icon + name, with a small **down-caret** on the right so it reads as expandable. Click the chip (or press **Ctrl+P**) to open a narrow fuzzy-search overlay **anchored to the bottom-left of the modal** — it covers the chip area, not the whole window, so the rest of the modal stays click-able for dismissal. Each row shows the project's icon (Claude logomark, Gmail glyph, language badge, custom upload). Projects that don't have any of those — real folders without a custom uploaded icon — render a small **initial-letter glyph** (the project's first letter on a colored tile) so the row never looks empty. The tile uses the project's own color when it has one set; otherwise the color is derived deterministically by hashing the project name into a fixed 8-color palette, so a given project always gets the same tint and neighbouring projects rarely land on the same color. The picker renders the glyph a little larger than the inline project chip does, so each row reads as a legible, clickable target. Long names ellipsize so the panel keeps its narrow width. Type to filter, arrow keys to navigate, Enter to pick, Esc to close the picker (Esc inside the picker dismisses the picker only — the modal itself stays up). The choice persists until you change it. ### Pick an engine and model (optional) Off by default. Turn on **Settings → Quick Launch → Show engine & model picker** and a single compact **engine chip** — showing the current engine (e.g. "Claude Code") with a down-caret — appears next to the project chip. Click it (or press **Ctrl+E** — **Cmd+E** on Mac) to open a small popover holding the **Engine** and **Model** pickers, so they stay tucked behind one control instead of always sitting in the composer row. The chip's tooltip advertises the shortcut, matching Ctrl+P (project) and Alt+S (snippets). They start on the project's default engine and model (the same default the sidebar **+** would use), so leaving them alone starts the session exactly as it does today. Change them to start _this_ session on a different engine (Claude Code, Codex, Gemini, Cursor, …) or a different model, without leaving Quick Launch. - Inside the popover, **Engine** lists **every** coding engine — the ones you've set up are selectable, and one you haven't configured yet is shown **dimmed with a short reason** ("Set up", "Install", "Add key") rather than hidden, so you can see what's available. A **"Set up more harnesses…"** row at the bottom jumps to Settings → Accounts to configure one. A dimmed engine can't be picked, so a pick never starts a session that can't run. "Claude Code" is one entry that spans Claude plus its compatible vendors (DeepSeek / Kimi / …); which one you get is decided by the model you pick under it. - **Model** opens the selected engine's models, grouped by company. Picking one starts the session on that model; **Use default** inherits the engine's own default. The popover closes on **Escape**, another **Ctrl+E**, or a click outside it. - The picks apply to **this launch only** — they reset to the resolved default the next time you open Quick Launch, exactly like the project chip. They also reset **the moment you change the target repo mid-open** (either by picking a different project from the chip, or by switching to a different repo tab), because an engine you chose for one repo should never carry over into another; the chip immediately falls back to the new repo's own default. While it re-checks that new repo, the chip briefly hides rather than showing the previous repo's engine. When the setting is off the tab is unchanged (no chip, no extra network call). ### Which engine a Quick Launch session actually starts on Every Quick Launch send into a real repo resolves the engine the same way the sidebar **+** does: **your explicit pick for this launch → the repo's default engine → your global default → Claude**. Set a repo's default under **Edit project**, or via the "Make it my default → Only this hub" option on the pickers. This holds **whether or not the engine chip is switched on** — that setting only controls whether the chip is _visible_, never how the session starts. (Until this was fixed, the setting also chose the spawn path: with the chip hidden — the default — Quick Launch ignored per-repo defaults entirely and always started Claude, so a repo pinned to Codex or Gemini silently launched on the wrong engine.) One consequence worth knowing: if a repo's default engine isn't actually installed or configured, the send now **fails with a clear message** (a toast plus a desktop notification naming what's missing) instead of quietly falling back to Claude. That matches how every other way of starting a session already behaves. Internally the send goes through the shared session-launch core (`launchSessionInMain`) — the same one the Super Prompts tab and the sidebar **+** use — so every engine, not just Claude, starts correctly. The Ask Omniscio, Session Search and Automation tabs are unaffected: they aren't repos and have no per-repo default to honor. ### Attach files Three input methods, all producing the same `pendingAttachments` chip row: - **Click the paperclip button** in the tab's button row — opens the native OS file picker. Accepts **images** (PNG / JPG / etc.), **PDFs**, **modern Office** (`.docx` / `.xlsx` / `.pptx`), and plain text. Multi-select is allowed; the row caps at **20 chips** total to protect the submit IPC's per-bucket validator. - **Paste an image** from the clipboard — captured as an attachment chip. - **Drag a file** onto the modal — same treatment. Available on the **Session, Session Search, Ask Omniscio, and Automation tabs** with identical wiring — the attachment state is owned by `QuickLaunchModal`, so paste/drop/picker in one tab persist when you flip to another. The paperclip's title tooltip lists the accepted formats so the user can confirm without leaving the modal. **What you can do with a chip.** The chips are interactive — the same gestures as the main Omniscio composer. **Click an image chip** to open a fullscreen preview lightbox (zoom / pan, prev / next between images, a copy button, Ctrl+C). **Right-click an image chip** for a small menu — Copy / Save Image As… / Remove. **Middle-click a chip**, or click its **×**, to remove it. **Drag a chip** to reorder — the order is what reaches Claude on submit. **Documents** (PDF, `.docx`, …) show a file-icon chip with **only** remove (you can't render an arbitrary file inline), matching the main composer. **Send with no text (attachment-only).** You don't have to type anything to go with a file — stage an attachment and **Send** lights up on its own, just like a regular session. The new session opens showing **just your file** (no caption is added). Behind the scenes a one-shot launch still needs a first message, so a brief _"take a look at the attached file(s)"_ instruction is sent to the agent invisibly — it never appears in your chat. (Mechanism: the Session tab submits that fallback as `text` while passing `displayText: ''`, and `MessageBubble` renders an empty-content operator row with attachments as image-only — see `QuickLaunchModal.handleSubmit`.) Two behaviors are unique to this window. Because Quick Launch is a self-hiding overlay, **Escape (or Ctrl+W) closes the preview first and leaves the window open** — a second Escape closes the window. And **Save Image As…** is opt-in here (the main composer's pending menu has no save); it opens a native Save dialog, and the same blur-suppression guard the paperclip uses keeps the window from vanishing mid-dialog while that dialog holds focus. The attachment travels with the prompt to the new session (same path as the main composer's attachments — images inline as base64 vision blocks, PDFs as native document content blocks, modern Office files extracted to Markdown text, plain text saved to the workdir + path-injected into the prompt). **Modern-Office caveat:** `.docx` / `.xlsx` / `.pptx` are extracted to text on a best-effort basis (100 KB cap; complex layouts, embedded images, and formulas drop out — same as the main composer). Legacy `.doc` / `.xls` / `.ppt` are rejected at the picker. If you need the original layout preserved, export to PDF first. When the file picker is open, Quick Launch's blur-dismiss is suppressed for the duration (paired with the existing OAuth-flow suppression flag) so the native dialog stealing focus doesn't auto-hide the modal. The `alwaysOnTop` window level is dropped while the dialog is open so the picker doesn't render behind the QL window, and restored on close. ### Paste a large or formatted block The **New Session** and **Ask Omniscio** composers share the main chat box's text-paste behavior. Paste **rich text** (Google Docs, a web page, Word on the web) and the formatting is converted to Markdown; paste a **very long block** (over ~5,000 characters) and it collapses into a removable **"pasted text" chip** instead of flooding the box — on Send the full text is spliced back into your prompt at the spot you pasted it. Hold **Shift** while pasting to force plain text. The chip is **remove-only** here (click it and nothing opens; click its × or middle-click to drop it) — the click-to-edit modal lives in the main chat composer, because this window's Escape would close the whole composer before a nested editor could. The single-line **Search** tab is text-only (no chip). See [paste-rich-text.md](paste-rich-text.md). ### Dictate (voice) The microphone button appears **only when voice input is enabled** (Settings → Voice & Speech → Voice Commands) — it's off by default, so out of the box there is no mic here, matching the main composer. With voice on, click the microphone button (or use voice if your global voice hotkey is set). The modal records your voice via the same speech-to-text pipeline as the main window, but transcripts get **appended to the modal's textarea** instead of triggering main-window voice commands. So you can say "create a session in the trading project" and that literal phrase ends up in the textarea ready to send — it does NOT execute as a voice command. This works because while the Quick Launch window has focus, Omniscio suppresses its main-window voice intent parser. The microphone still works, transcripts still flow, but the parser that would normally turn "go to dashboard" into a navigation action stays dormant until the modal loses focus or closes. A partial-transcript preview appears next to the mic icon as you speak. When you stop, the final transcript is appended to the textarea. ### Insert a snippet Your saved **Snippets** (Quick Replies) are reachable straight from the Session tab — no need to start the session first, then open the picker in the main window. Press **Alt+S**, or click the **quick-reply button** (the speech-bubble icon next to the paperclip), and the _same_ Quick Replies picker you use inside a session opens, anchored to the bottom-left of the composer: folders you can drill into, a search box that flattens across every folder (with breadcrumbs), and **1**–**9** number keys to fire the bottom rows by hand. (The number badges honor your **Settings → Quick Replies → Number-key quick send** toggle, same as in a session.) - A **plain snippet** inserts its text **at the cursor** in the prompt box — its own paragraph with a blank line above and below, exactly like the in-session insert — so you can keep editing before you send. - An **auto-submit snippet** is appended to whatever you've drafted and **immediately starts the session** (the same as picking an auto-submit reply in a session, which sends right away). Quick Launch foregrounds Omniscio with the new session already running. - **Right-click a snippet** opens the same **Copy · Edit · Delete** menu as the in-session composer. **Copy** copies the reply's text to the clipboard (closing the menu is the confirmation). **Edit** jumps to the main window's Quick Replies manager with that reply's editor already open — Quick Launch is a separate window, so it hands off cross-window (it hides QL, foregrounds the main window, and opens the editor) rather than editing in place. **Delete** removes it, guarded by an inline two-step confirm (**Delete** → **Confirm delete** / **Cancel**) right in the menu — deliberately NOT a pop-up dialog (this transient window has its own Escape/blur model). Unlike the in-session composer there's **no Undo** on the QL delete; the confirm step is the safety net. The in-session composer's right-click delete keeps a Ctrl+Z Undo — see [use-quick-responses.md](use-quick-responses.md). Both go through `QUICK_REPLY_DELETE`, so a delete in either place refreshes the other. - **Dismissing the right-click menu closes ONLY the menu** — pressing **Esc** or clicking anywhere outside it dismisses the menu while the picker (and the window) stay open, matching the in-session composer. The window's Escape is main-process-owned, so this "close the menu first" behavior is layered on top of the picker-close below. **The quick-reply button toggles** — click it again to close the picker (the cursor returns to the composer). **Esc** (when no right-click menu is open) closes the picker first (the window stays up; a second Esc closes Quick Launch), and clicking outside the window dismisses Quick Launch as usual. The **Manage Quick Replies** link in the picker footer closes Quick Launch so you can edit your library in the main window. Selecting a snippet bumps its use count, so the picker self-sorts over time just like in a session. ## For agents The rest of Quick Launch is on two companion pages: [part 2](quick-launch-modal-part-2.md) carries every other tab the strip can hold, the per-repo tabs, and the mobile quick-actions sheet; [part 3](quick-launch-modal-part-3.md) carries the implementation view — the window manager and hotkey registration, the per-tab component map, the design decisions behind it, and the `AppSettings` fields it reads. ## Related - [tray-and-window.md](tray-and-window.md) — describes the global focus hotkey (Ctrl+Shift+M). Quick Launch is the second global-hotkey surface alongside it. - [send-a-message.md](send-a-message.md) — Quick Launch submits via the same `createSessionWithPrompt` path. Composer behaviors (slash commands, paste handling, attachment limits) are inherited. - [voice-system.md](../../.claude/memory/voice-system.md) — the full voice / dictation pipeline. Quick Launch reuses everything except the intent parser, which it suppresses for the duration of its focus. - [keyboard-shortcuts.md](keyboard-shortcuts.md) — global shortcut catalog; Ctrl+Space is the Quick Launch default but can be rebound from Settings → Quick Launch.