---
title: Clipboard history
---

# Clipboard history

> **On by default — and you can turn it off.** The switch is **Settings → Features → "Clipboard history"**. Because it records everything you copy system-wide, read **Privacy** below; turning it off stops capture, hides the composer button and the Ctrl+Alt+V pop-up, and deletes the saved-on-disk copy.
>
> _(Before 2026-08-26 this shipped switched off with no way to switch it on — the feature appeared in the composer but its history was always empty. If you remember it being broken, that was why; it is fixed and your existing install is switched on automatically.)_

## What it is

A clipboard manager built into Omniscio: a small background watcher remembers the recent things you copy — **text and images, from any app on your PC** — so you can grab an older copy without re-finding the source. It is Omniscio's own version of the Windows **Win+V** clipboard history.

By default your history is **kept across restarts** — the recent copies come back the next time you open Omniscio, saved in an **encrypted** file on your PC (**"Keep clipboard history across restarts"**, Settings → Sessions, **on by default**). It doesn't pile up forever: anything you haven't used in **14 days** is cleared automatically (pinned favorites are exempt), on top of the "keep the newest ~50" cap. Prefer it not to touch the disk? Turn that switch off and the history becomes **in-memory only** — wiped every time Omniscio restarts. See **Persistence** below.

You reach it two ways:

- **A button in the chat composer** — a small clipboard icon in the tool row of both the **AI‑session message box** and the **Team Chat message box** (desktop). Clicking it opens a popover; from there you can insert a copy into your message — text drops at your cursor, an image attaches. (In a session you can also **start a new session** from a copy; Team Chat has no "New session," since a chat isn't a session.) You can hide this button — **right-click it and choose "Remove from bar"** (with an Undo toast for a one-click revert), or turn off Settings → Sessions → "Clipboard history (Win+V)" — if you only want the pop-up.
- **A standalone pop-up (Ctrl+Alt+V, Windows only)** that appears **anywhere**, even when Omniscio isn't your focused app. It's a **two-pane picker** — your copies on the left, a **live preview** of the highlighted one (near full-size) on the right. **Click a copy — or press Enter — to paste it** into whatever app you were typing in — Omniscio's own message boxes (a session's, or the **Team Chat** channel/DM box) included (hover or arrow through to preview first); it optionally auto-pastes for you. It's fully keyboard-driven: **↑/↓** (or **W/S**) move · **Enter** or **V** pastes · **C** copies the selected · **A** annotates a selected image · **1–9** paste that numbered copy · **/** jumps to search · **Esc** or **Ctrl+W** closes. **Shift+V** — or a **Shift-click** (or Ctrl-click) — pastes a copy and keeps the window open, so you can grab several one after another and each drops into your message on its own line (a plain click, **Enter**, or **V** pastes just that one and closes the window). The highlight follows whatever you're using: hover with the mouse and the row under it is selected; the moment you use the keyboard, the mouse stops interfering (so the highlight doesn't split) until you move the mouse again. The default shortcut is **Ctrl+Alt+V** — not Win+V, which Windows reserves for its own clipboard history — so it works alongside Windows' Win+V with nothing to turn off; rebind it any time in Settings → Keyboard Shortcuts.

Whichever way you open it, your **latest copy is already at the top the instant it appears** — Omniscio checks the clipboard the moment you open the history, so you never see it show an older list and then reshuffle a beat later.

Both surfaces show the same recent copies, newest first — text entries show a short preview, image entries show a thumbnail, and every row shows **its size and how long ago** you copied it: a text copy's **character count and approximate token count** (e.g. "1,234 chars · ~310 tokens"), an image copy's **file size** (e.g. "2.3 MB"), plus the relative time ("7m ago" / "2h ago" / "3d ago"; hover the time for the exact date). Beyond what Win+V does, you can **inspect** any copy full-size — zoom right into an image (it stays locked on the picture, never drifting into empty space) or hit the **View full size** icon in the image's corner to open it in a large viewer — **edit a text copy** before you use it (which saves it as a **new** copy and keeps the original), **annotate an image copy** — mark it up with Omniscio's built-in image annotator (arrows, boxes, text, blur) and the marked-up version lands back on your clipboard as a **new** copy with the original kept — **pin** favorites to the top, and **search** the list — none of which Windows' clipboard history offers.

**Formatting is kept, too.** When you copy a **hyperlink** or other formatted text, Omniscio remembers the formatting — re-copy or paste that item into a rich editor (an email, a document) and the link comes back looking right, while pasting into a plain text box (a chat message, a code editor) still gives you clean text. Nothing extra to do; it just works for any copy that carries formatting.

## Where to find it

There are two ways in. The first is a small **clipboard icon in the chat composer's tool row** — it sits in the message box of both a session and a Team Chat channel or DM, on desktop. The second is a **standalone pop-up** you summon with **Ctrl+Alt+V** from anywhere on Windows, even when Omniscio is not the app in front of you. The switches that control the feature live in **Settings → Features** (the on/off switch), **Settings → Sessions** (keep the history across restarts, and auto-paste), and **Settings → Keyboard Shortcuts** (rebind or disable the pop-up's shortcut).

## How it behaves

### How to use it

1. **Nothing to switch on.** It's already running — skip to step 2. (If you turned it off and want it back, it's **Settings → Features → "Clipboard history"**.)
2. **Press Ctrl+Alt+V (Windows).** The standalone pop-up appears wherever you are — it works alongside Windows' own Win+V, so there's nothing to turn off. To rebind or disable it, see **Settings → Keyboard Shortcuts → "Clipboard history"**.
3. **Or click the composer icon.** When enabled, a clipboard icon also appears in the chat composer's tool row — in both a session's message box and the Team Chat message box (desktop). Hide it by **right-clicking the icon and choosing "Remove from bar"** (an Undo toast lets you revert immediately), or from Settings → Sessions → "Clipboard history (Win+V)", if you only want Win+V.
4. **Preview or inspect a copy.** In the **Win+V pop-up**, the highlighted copy shows in the right pane at near-full size — the whole text (scrollable and selectable) or the image (shown fast at preview quality — hit **View full size** for the full-resolution zoom), plus its size, an approximate token count (text copies), and when you copied it; hover or arrow through the list to preview each one. In the **composer popover**, click a row to open that same detail. For an image you can **zoom** on it in place (it stays centered on the picture), click the **View full size** icon in the image's top-right corner to open it in a large, zoomable viewer, or hit **Annotate** to mark it up in Omniscio's image annotator (the marked-up picture comes back as a **new** copy; your original is kept).
5. **Use a copy.** In the **Win+V pop-up**: **click a copy (or press Enter) to Paste** it — copies it and auto-pastes into the app you came from (turn auto-paste off in Settings → Sessions to just copy); **Copy** and **Delete** sit on each row and under the preview. To paste **several copies at once**, **Shift-click** (or Ctrl-click) each copy you want — each one pastes into your message immediately (on its own line) and the window stays open, so you just keep clicking; a brief ✓ flashes on each row you click. A plain click still pastes that one and closes. From the **composer popover**: **Insert into message** (drops the text at your cursor, or attaches the image), **New session** (text copies only — a fresh session seeded with that text), or **Copy** (back on the system clipboard for Ctrl+V anywhere).
6. **Edit a text copy.** On a text copy, hit **Edit**, tweak the text, then **Save**. The edited text goes onto your clipboard and into your history as a **new** copy — your original copy stays exactly as it was. (Editing is text-only; it stays plain text.)
7. **Pin favorites.** Click the ★ on a row to pin it — pinned copies sort to the top, survive as newer copies push older ones out, **never expire with the 14-day cleanup**, and (with "Keep across restarts" on, the default) come back after a restart (up to 8 pins).
8. **Search.** Type in the search box at the top to filter the list by each copy's preview text.
9. **Remove one / clear all.** Hover a row and click **✕** to drop just that item, or **Clear** in the header to empty the whole history. Because clearing removes **every** copy — pinned favorites included — and can't be undone, **Clear** asks you to confirm first: in the **Win+V pop-up** the button turns red and changes to **"Sure?"** — click it again to wipe everything (it quietly reverts to "Clear" on its own if you don't, and an accidental fast double-click won't slip through); in the **composer popover** it pops a quick "are you sure?" dialog.
10. **Keep it across restarts (on by default).** Your copies — text, images, and pins — come back after you restart Omniscio, saved in an **encrypted** file on this PC. Anything older than **14 days** (counting from the last time you used it, pins excepted) is cleared automatically — so it keeps a deep history, up to about two weeks of copies (thousands of items for a heavy copier). The list shows your most recent copies (about 50 at first, so it opens fast); to reach an older one, click **Show more** at the bottom of the list to reveal the next batch, or type in the search box (it searches your whole history, not just the rows on screen). To keep the history in memory only instead, turn **"Keep clipboard history across restarts"** (Settings → Sessions) off — that wipes it on every restart and deletes the file. (Existing installs get this on-by-default too: a one-time update switches it on for anyone who still had the old "off" saved from before it became the default. If you deliberately turn it off after that, it stays off.)
11. **Turn it off.** **Settings → Features → "Clipboard history"** — capture stops within about a second, the in-memory history is wiped, the encrypted on-disk copy is deleted, the composer button disappears and Ctrl+Alt+V stops opening the pop-up. Off means off; flip it back on any time.

### Privacy

Because it captures every copy system-wide, the watcher can see sensitive things (passwords, card numbers). Several safeguards apply:

- **One switch you control** — Settings → Features → "Clipboard history". It's on out of the box, and turning it off is a real off: capture stops, the in-memory history is wiped, and the encrypted on-disk copy is deleted.
- **Saved encrypted by default; sensitive copies never captured.** With **"Keep clipboard history across restarts"** on (the default), your history is written to disk **encrypted with your Windows account's key** (the same protection Omniscio uses for your logins) — unreadable on another machine or account — and anything older than 14 days is dropped automatically. Turn the switch off to keep the history **in memory only** (erased every restart, nothing on disk). Either way, sensitive copies are skipped **before** capture, so a password or card number never enters the history — and therefore is never written to disk.
- **Skips items apps mark sensitive.** When a password manager (or any app) tags a copy with Windows' "exclude from clipboard history" markers, Omniscio skips it — the same signal Win+V honors.
- **Never logged or sent anywhere.** Clipboard contents never reach a log file, Sentry, or any network call. The on-screen list only ever holds a short text preview + a small image thumbnail; the full text and full-resolution image stay in Omniscio's main process. When you click a copy to **inspect** it, Omniscio fetches just that one item's full content on demand to show you — it's never cached, and it's dropped the moment you go back; still nothing is written to disk or logged.

### How it works

- **Capture.** A main-process background service ([clipboard-history-service.ts](../../src/main/services/clipboard-history/service.ts)) polls the system clipboard roughly once a second using Electron's `clipboard` module. It runs on the enabled setting (re-checked each poll), **not** on window focus, so it keeps capturing while Omniscio is in the background — which is the whole point of a clipboard manager. It only decodes an image when an image is actually present, and only re-encodes when the content changed, so an idle clipboard is cheap.
- **Rich text (hyperlinks / formatting).** When a copy carries a **rich-text (HTML)** flavor — what your OS puts on the clipboard alongside the plain text when you copy a hyperlink or formatted selection — Omniscio captures that too and writes **both** back when you re-copy, so a paste into a rich target keeps the formatting while a plain target still gets clean text. The formatting rides along with the text copy (it's the same entry, not a new kind), so de-duplication and the "don't re-capture my own paste" guard are unchanged — they key on the plain text, so a clipboard round-trip that re-encodes the HTML can't confuse them. It stays entirely in the main process (never shown in the app, never logged) and folds into the same size cap as the text, so a huge rich copy is skipped just like a huge plain-text one. Scope is HTML (hyperlinks + web rich text); Word/Outlook's private RTF format isn't captured, but virtually all rich sources also provide HTML. Locked by contract **I32**.
- **Storage + rules.** A pure in-memory ring buffer ([store.ts](../../src/main/services/clipboard-history/store.ts)) holds the entries and all the bookkeeping: de-duplication (copying the same thing again just moves it to the top), self-write echo suppression (re-copying a stored item never adds a duplicate — keyed on the stable signature, not re-encoded bytes), and memory caps (≈50 entries total, a tighter image count + total-bytes budget so copied screenshots can't bloat memory; oversized single items are skipped).
- **Picker UI.** A self-gating composer control ([ClipboardHistoryComposerControl.tsx](../../src/renderer/src/features/clipboard-history/ClipboardHistoryComposerControl.tsx)) renders nothing unless the feature is visible. It has a **list** view (search + pinnable rows) and an **inspect detail** view. It loads the list when opened and stays live via the `clipboard:history-changed` push while open. Opening the list is **capture-fresh**: the `clipboard:history-list` request runs `listClipboardHistoryFresh`, which reads the clipboard synchronously and folds in your newest copy **before** returning — so the just-copied item is already at the top on the first paint, instead of showing the last-polled (stale) list and then visibly reshuffling when the next ~1s background poll catches up. It deliberately does **not** fire a "list changed" push for that on-open capture (the caller already has the copy in the result, so a push would just trigger the reshuffle it's avoiding); de-dup, echo-suppression, and persistence are all unchanged. Locked by contract **I34**. It talks to the main process over six list/inspect channels (`clipboard:history-list` / `-copy` / `-delete` / `-clear` / `-get` / `-set-pinned`), plus three for the picker window (`-paste` / `-window-close` / `-window-shown`). The list stays projection-only (preview + thumbnail); `-get` returns one entry's full content **only** when you open its detail view, into transient renderer state. Insert-into-composer and "new session with this" route through the session composer (`useSessionPanel`), so they work whether or not the perf-mode isolated composer is on. The list + inspect views are extracted into shared components (`ClipboardHistoryListView` / `ClipboardHistoryDetailView`) reused by both the composer popover and the picker window; a `clipboardHistoryShowInComposer` setting — flipped from Settings **or** a right-click "Remove from bar" item on the icon (which sets it false and shows an Undo toast) — hides the composer button without disabling the feature.
- **Persistence (opt-in — "Keep across restarts").** With the setting OFF (default) nothing touches the disk. With it ON, the full history is saved to a single **encrypted** file ([persistence.ts](../../src/main/services/clipboard-history/persistence.ts)) using the same OS-keyring encryption (safeStorage / DPAPI) Omniscio uses for your credentials — machine- and account-bound, so a copied file can't be read elsewhere; if that encryption is ever unavailable, Omniscio writes **nothing** rather than fall back to a readable file. Saves are **batched** (a few seconds after a change, at most once per burst) and skipped when nothing changed, so it never churns the disk; the write is **atomic** (write-a-temp-then-swap) so a crash can't corrupt it, and it's **reloaded on the next launch** (merged in so a copy you make during startup isn't lost) and **flushed on quit**. Because sensitive copies never enter the history in the first place, they're never written. Turning the setting — or the whole feature — off deletes the file. Locked by contract **I30**.
- **Inspecting a copy — focused zoom, full-size, and text editing.** The shared detail view ([ClipboardHistoryDetailView.tsx](../../src/renderer/src/features/clipboard-history/ClipboardHistoryDetailView.tsx)) sizes an image's box to **hug the fitted picture** (via `fitImageBox` over the measured pane), so zooming stays locked on the image with no empty margin to drift into — reusing the same fit regime the app's shared image viewer is proven in, with **no change to the shared `ImageCanvas`**. A **View full size** icon in the image's top-right corner (a compact overlay, not a button row below the image) opens that shared viewer (`ImageLightboxShell` via a thin `ClipboardImageLightbox` wrapper, which also hugs the image); in the frameless Win+V window it drops the desktop titlebar offset (`isClipboardHistoryWindow`). For a **text** copy, an **Edit** button makes the textarea editable (plain text only); **Save** writes the edited text via the generic `clipboard:write-text` channel, which the capture poller records as a **new** entry — a distinct value, so the original is untouched. While an overlay (edit or the full-size viewer) is open, the picker window's bare-key model and the composer popover's click-away-to-close **stand down** so they don't fight it. Locked by contract **I24–I27**.
- **Picker window + hotkey (Windows).** A global hotkey (default `Ctrl+Alt+V`, in [global-hotkeys.ts](../../src/shared/global-hotkeys.ts)) summons a frameless, always-on-top pop-up ([window.ts](../../src/main/services/clipboard-history/window.ts)) that reuses those shared views in a **two-pane** layout — the list on the left, the detail view as an always-on **live preview** on the right (fetched per selection, debounced, with the same stale-guard as the composer's inspect). It's keyboard-driven: it opens focused on the list, then **↑/↓** — or **W/S** — select (the preview follows and scrolls the row into view), **Enter** or **V** or a row click pastes, **C** copies the selected, **A** annotates a selected image (image-only), **1–9** paste the Nth visible copy, **/** focuses search, and **Esc** or **Ctrl+W** closes. A **modified click** (Shift/Ctrl/Cmd) — or **Shift+V** — instead pastes that copy into your Omniscio message **immediately** and keeps the window open — so you can grab several one after another, each landing on its own line, with a brief ✓ flashing on each row (contract **I29**); a plain click, **Enter**, bare **V**, and **1–9** stay single-item (and close). **Hovering** a row selects it too, so the preview follows your mouse — but the moment you drive with the keyboard the mouse's hover stands down, so the highlight never splits into a raised row under the mouse plus a separate coloured row where the keyboard is, until you move the mouse again. Because the **Edit** / **View full size** buttons live in that right-hand preview pane, reaching them means sweeping the cursor diagonally across the list; a **"safe triangle"** guard holds your selection while you're aiming at the pane, so the rows you pass over on the way don't hijack it and you edit/zoom the copy you actually picked (contract **I28**). It registers ONLY when the feature is on AND on Windows — the picker window + auto-paste are Windows-only in v1 (and on macOS `Super+V`/Win+V resolves to Cmd+V, the universal paste, so a manual rebind to it is never claimed there). Toggling the feature (or editing the shortcut) re-runs registration **live** — Omniscio claims the hotkey the moment you enable it and releases it when you turn the feature off, with no app restart. If you rebind it to Win+V and Windows still owns that, the failed registration surfaces a toast telling you to turn Windows' clipboard history off (or pick another key). The pop-up window is **pre-warmed and reused** between opens (not rebuilt each time), so pressing the shortcut is instant; and because a reused window would otherwise show its previous contents for a frame, it keeps its panel **invisible at rest** and reveals the fresh list with a quick scale-in on each open — the same flash-free technique the Ctrl+Space Quick Launch pop-up uses (contract I22), so a reopened picker never double-flashes. Like Quick Launch, its click-away/blur dismiss **survives a transient console focus-steal**: the shared two-stage discriminator ([hud-blur-dismiss.ts](../../src/main/services/window/hud-blur-dismiss.ts)) defers the hide and, when a Win32 console flashes during a session spawn and vanishes, keeps the picker open + reclaims focus instead of letting it hide mid-use — while a deliberate switch to another app still dismisses it ([hud-blur-dismiss-contract.md](../../.claude/memory/contracts/hud-blur-dismiss-contract.md)). The pop-up's rows wear a **"Tactile Deck"** look — raised cards where the highlighted copy lifts and glows in your accent (that highlight follows the selection, whether you're hovering or on the keyboard), and the preview pulled forward with depth. It's a **cosmetic skin scoped to this window only** (it uses Omniscio's theme tokens so it reads right in every theme, and drops the motion when you've asked the OS for reduced motion); it changes nothing about how the picker behaves — same keyboard model, same actions, same privacy (contract I23).
- **Auto-paste into another app (best-effort, Windows).** Picking an item in the pop-up always writes it to the system clipboard first, then — when `clipboardHistoryAutoPaste` is on — restores the app that had focus and synthesizes Ctrl+V ([paste-injection-win32.ts](../../src/main/services/clipboard-history/paste-injection-win32.ts), via `koffi` → `SetForegroundWindow` + `keybd_event`). It only ever fires into the exact foreign window you came from (never Omniscio), and skips silently when it can't — the item is still on the clipboard for a manual Ctrl+V (e.g. into an elevated/admin window, which Windows blocks).
- **Pasting into Omniscio itself (main composer or Quick Launch).** That synthesized-Ctrl+V path never targets an Omniscio window. So when you press Win+V while you're already in Omniscio — a session's message box, or the Quick Launch overlay — the pop-up instead **inserts the copy straight into that composer over IPC** (text at your cursor — a **large** text collapses into a removable "pasted text" chip, exactly as a normal Ctrl+V paste does, instead of flooding the box — an image as a pending attachment). The pop-up samples which window had focus at the moment you pressed Win+V (before it steals focus); if it was the main window it emits `clipboard:history-insert-into-session`, which the **active** session composer receives ([SessionPanel.tsx](../../src/renderer/src/features/sessions/SessionPanel.tsx), reusing `useSessionPanel`'s insert handlers so it works in either composer mode), and if it was Quick Launch it routes into QL's own composer, and if it was the floating **API‑key prompt window** (the one an agent pops to ask you to paste a key) it drops the copy straight into that field, and if it was the **vault (KMS)** — its own popped-out window, or the vault docked as the active view in the main window — it drops the copy into the note editor at your cursor (`clipboard:history-insert-into-kms`, sent to just that one window so it can never double-insert when the vault is open in two places). After the insert, the pop-up **re-activates that Omniscio window (`focus()` + `webContents.focus()`) so your cursor lands back in the message box, ready to keep typing** — the pop-up stole focus when it opened, and an always-on-top window hiding doesn't reliably hand focus back on its own, so without this deliberate hand-back the caret would be left outside the box (this mirrors what the paste-into-another-app path already does with `SetForegroundWindow`). The guaranteed clipboard-write floor still applies, so a manual Ctrl+V always works too. If Omniscio wasn't the focused window, nothing is inserted — the copy just sits on the clipboard (so Win+V never hijacks a paste meant for another app). **v1 scope:** the main window, Quick Launch, the floating API‑key prompt window, and the **vault note editor** (its popped-out window or the vault docked as the active view) — a _detached_ session pop-out leaves the copy on the clipboard for a manual Ctrl+V. Into the vault, **text** drops at your cursor; an image copy stays on the clipboard for a manual Ctrl+V (the vault imports it normally). Locked by contract **I39**.
- **Keep-open multi-paste — paste several, one after another (Shift/Ctrl-click).** A modified click on a row pastes that copy **immediately** into the Omniscio destination and **leaves the window open**, so you keep clicking and each copy drops into your message. Main's `pasteSelected(id, { keepOpen })` fetches the entry **read-only** (no clipboard write, no move-to-top — the list can't reshuffle under your cursor between clicks), appends **one** trailing newline to a text copy so successive pastes stack **one per line**, and routes it into the session composer or Quick Launch over IPC — but **without** hiding the window or handing focus back (the always-on-top picker keeps focus; the composer appends over IPC). An image keep-open-pastes too (as an attachment). A modified click into a **non-Omniscio** app can't keep the window open — Windows needs that app in front to paste — so it falls back to paste-and-close there. A brief ✓ flashes on each row you click. The picker list is `select-none`, so a Shift-click never smears a text-selection highlight across the rows. A **plain** click still pastes that one copy and closes. Locked by contract **I29**.

- **Annotate an image copy (image-only, desktop-only, cross-window).** An image copy shows an **Annotate** button (both the composer popover and the Win+V pop-up; **desktop only** — hidden on a paired phone, and in the Win+V window the bare **A** key does the same thing). It opens Omniscio's **existing** image annotator — the same snip editor the Screen Recorder uses, so there's one markup tool, not a second one. Behind the scenes Omniscio turns the copied image into a snip **silently** (no "screenshot captured" toast, your clipboard left untouched), brings the main window forward, and opens the editor on it; when you're done, the annotator's own **Copy image** puts the marked-up picture back on your clipboard, which the watcher records as a **new** copy — your original is untouched. Because the annotator lives in the Screen Recorder, a copy of the original image also lands in your Screen Recorder library. Locked by contract **I35**.

The invariants (default-off, in-memory, sensitivity-skip, caps, de-dup, echo-suppression, never-logged, rich-text (HTML) capture/restore, plus the picker-window gating + best-effort/never-target-Omniscio win32 auto-paste + the paste-into-composer/Quick-Launch/vault IPC routes (the vault-note-editor route, pop-out + docked, is I39) + the keep-open multi-paste + annotate-an-image-with-the-existing-annotator (I35) + the composer-icon toggle) are locked by [clipboard-history-contract.md](../../.claude/memory/contracts/clipboard-history-contract.md) and its tests.

### Limitations (v1)

- The Win+V pop-up + auto-paste are **Windows-only** in v1; on macOS/Linux the feature is the composer button only.
- **Keep-open multi-paste into a non-Omniscio app closes after one.** Shift/Ctrl-click keeps the window open only when you're pasting **into Omniscio** (your session box or Quick Launch) — Windows needs a non-Omniscio app in front to paste there, which would blur the pop-up shut, so a modified click into an outside app just pastes that one and closes (your copies are still on the clipboard for a manual Ctrl+V).
- **Auto-paste can't reach an elevated (admin) window** when Omniscio isn't itself elevated — Windows blocks synthesized keystrokes there. The item is still on your clipboard, so a manual Ctrl+V works.
- **Win+V into Omniscio's own message box** works from the main window — a session's message box **and the Team Chat channel/DM box** — the Quick Launch overlay, and the **vault note editor** (its popped-out window or the vault docked as the active view); from a **detached** session pop-out window, or an open Team Chat **thread** reply box, it leaves the copy on the clipboard for a manual Ctrl+V (v1 scope limits). Win+V into Team Chat **or the vault** pastes **text** (a copied image stays on the clipboard for Ctrl+V — the vault imports it normally, and Team Chat's in‑box clipboard **button** attaches images too).
- In the Win+V pop-up, **Escape or Ctrl+W closes the window** (Windows delivers those to Omniscio's main process before the page). So if you've opened an image **full-size** there, Escape closes the whole pop-up — use the viewer's **✕** or click outside the image to close just the viewer. In the composer popover (inside the main window) Escape closes just the viewer. The window is two-pane with an always-on preview, so there's no inspect sub-view to step back from — that Back-arrow flow is the composer popover only.
- **"New session with this"** works for text copies; starting a brand-new session directly from a copied **image** is a planned follow-up — for now, use **Add to message** to attach an image.
- **Search** matches the on-screen preview text, not the full text beyond the preview length.
- **Pins** come back after a restart with "Keep across restarts" on (the default) and never expire with the 14-day cleanup; with persistence turned off they last only for the current run. You can pin up to 8 at a time.
- No OCR yet — "pull the text out of an image" is a planned follow-up.
- Image identity isn't perfectly stable across a clipboard round-trip, so two different images of identical size copied back-to-back (with no accompanying text) can occasionally collapse to one. Rare and accepted for v1.
- **Formatting is HTML-based.** Two _different_ formatted copies that show the exact same visible text (say two links both reading "click here") collapse to one entry, keeping the most recent one's formatting — the same way two identical plain-text copies already merge. And a copy whose formatting is enormous (bigger than the per-item size cap) is skipped whole, just like an oversized plain-text copy. Word/Outlook's private RTF-only formatting isn't captured (it comes back as plain text); nearly all rich sources also provide HTML, which is.

## Related

If what you want is the message box this picker inserts into, [send a message](send-a-message.md) covers the composer; the separate question of getting *formatted* text into that box is on [paste rich text](paste-rich-text.md). The switch that turns this feature on and off is part of the gating system that holds every not-yet-released feature, which also explains why this one ships on by default while still being able to turn off.

- Omniscio’s unreleased-feature (“Lab”) gate — the gating system behind the on/off switch (this feature uses its on-by-default-but-still-turn-off-able state)
- [send-a-message.md](send-a-message.md) — the composer this picker lives in
- [paste-rich-text.md](paste-rich-text.md) — how pasting INTO the composer works (separate from this copy-history feature)