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 Ctrl+Alt+V pop-up (and the composer button, if you switched it on), 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 size caps (up to 3,000 copies and the newest ~300 screenshots). 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 (off by default) — a small clipboard icon in the tool row of both the AI‑session message box and the Team Chat message box (desktop). It isn't there out of the box: switch it on with Settings → Sessions → "Clipboard history (Win+V)". Clicking it opens a popover; from there you can insert a copy into your message — text drops at your cursor, an image attaches just like a pasted image (same size limit, and Undo works). (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.) Esc closes the popover and puts you back in the message box. To hide the button again, right-click it and choose "Remove from bar" (with an Undo toast for a one-click revert), or turn that same setting off.
• 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) and its other windows (a popped-out session, Writer, the Scratchpad) 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; each one is also left on your clipboard, and the list doesn't reshuffle while you click (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 — the background watcher keeps the list current while it's closed, so you never see it show an older list and then reshuffle a beat later. The pop-up opens on the monitor your mouse is on, sized to fit that screen.

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), which keeps counting up on its own while the list sits open. 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 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 second is a small clipboard icon in the chat composer's tool row — off by default; once switched on it sits in the message box of both a session and a Team Chat channel or DM, on desktop. The switches that control the feature live in Settings → Features (the on/off switch), Settings → Sessions (the composer button, 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 use the composer icon (switch it on first). The clipboard icon in the chat composer's tool row is off by default. Turn on Settings → Sessions → "Clipboard history (Win+V)" and it appears in both a session's message box and the Team Chat message box (desktop). Hide it again by right-clicking the icon and choosing "Remove from bar" (an Undo toast lets you revert immediately), or by turning that setting back off.
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 a row only when that copy actually landed; either way it's left on your clipboard, so a manual Ctrl+V always works. A plain click still pastes that one and closes. If a copy has nowhere to go — a dialog is open, or it's an image aimed at a text-only box — Omniscio puts it on your clipboard and tells you so with a toast, instead of dropping it. 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. If the save fails, your edit stays open so nothing you typed is lost. (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 ✕ — then click it once more to confirm — to drop just that item (the Delete button under the preview works the same way), 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 — or the older "Clipboard Viewer Ignore" marker some password managers still use — Omniscio skips it, the same signal Win+V honors.
• Erasing your data erases it too. Erase all local data and a factory reset both wipe the clipboard history — the list in memory and the encrypted file on disk. And because a deleted history must stay deleted, Omniscio never lets a save that was already on its way write it back afterwards.
• Agents can't wipe it. An AI session's own limited access key can read your history but can't clear it or delete copies from it — only you (or a tool holding Omniscio's full-access key) can.
• A damaged file is kept, not overwritten. If the saved history ever can't be read (say, after a Windows account or keyring change), Omniscio sets that file aside under a new name — its screenshots with it — and starts a fresh one, rather than silently saving over it.
• 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 content on demand to show you — the full text, or an image at preview size, with the full-resolution image fetched only when you open View full size or insert it — it's never cached in the app's screen, 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) checks the system clipboard on a short timer using Electron's clipboard module. It runs on the enabled setting (re-checked each tick), not on window focus, so it keeps capturing while Omniscio is in the background — which is the whole point of a clipboard manager. On Windows it reads the clipboard only when the clipboard's own change counter moved, so an idle clipboard costs nothing and two copies made in quick succession are both kept. An image is kept as the exact bytes the clipboard holds: an oversize one is turned away on its size alone before anything decodes it, two different screenshots of the same size stay two separate copies, and the only decode is the small thumbnail.

• 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) 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), and memory caps (up to 3,000 entries, the 300 newest images within a 40 MB image budget so copied screenshots can't bloat memory; oversized single items are skipped). When Omniscio itself borrows the clipboard — Quick Launch's "grab my selection" puts a probe on it, copies, then puts your clipboard back — those writes go through writeClipboardUnrecorded, so they are never recorded as copies: your older clipboard is not moved to the top with a fresh time, and the probe never shows up as a row. The put-back keeps everything your clipboard held, including formatting and a password manager's "do not record" marker.

• Picker UI. A self-gating composer control (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 a cached read: clipboard:history-list serves the main process's in-memory list and never reads the system clipboard on the open path (that read can block behind whichever app owns the clipboard); freshness comes from the background watcher and a focus nudge, and the pre-warmed pop-up follows the list while hidden. Locked by contract list-fetch-is-a-cached-projection. 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 content only when you open its detail view, into transient renderer state — for an image, the preview-size picture, with the full-resolution one sent only when asked for (includeFullImage: View full size, insert, annotate). 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 (on by default — "Keep across restarts"). With the setting ON (the default), the full history is saved encrypted — one file for the list (persistence.ts), plus each screenshot in its own encrypted file in a folder beside it (image-sidecars.ts), written once when the screenshot is first saved, so a save never re-writes the screenshots it already saved and keeping hundreds of them costs a save no more than keeping a few. Each screenshot file has a random name (never derived from the picture), is removed after the next save once nothing in the history uses it, and is wiped with the history. Both use 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 encryption runs off the app's main thread, so saving never makes the app stutter. The write is atomic (each save writes its own temp file, then swaps it in) so a crash can't corrupt it, and every save, delete and load runs one at a time in a single queue — a delete cancels any save still waiting, so a cleared or switched-off history can never come back. A save that fails is retried. It's reloaded on the next launch (merged in, so a copy you make during startup isn't lost and a pinned favourite keeps its pin) and flushed on quit. A saved file that can't be read is set aside under a new name, never overwritten. Because sensitive copies never enter the history in the first place, they're never written. Turning the setting off — or the whole feature, or erasing all local data — deletes the file. With the setting OFF, nothing touches the disk. Locked by contract keep-across-restarts and its neighbours.

• Inspecting a copy — focused zoom, full-size, and text editing. The shared detail view (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) summons a frameless, always-on-top pop-up (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; each open places it on the monitor under your mouse and re-fits it to that screen, so it never spills off a smaller display. Its panel is visible whenever the window is, and a reopen waits (briefly, with a cap) for the fresh list before revealing it with a quick scale-in, so a reopened picker never flashes its previous contents (contract I22). A mouse that just happens to rest over the list when the pop-up opens doesn't pick a row, and hovering doesn't move the selection while you're editing or viewing an image. Like Quick Launch, its click-away/blur dismiss survives a transient console focus-steal: the shared two-stage discriminator (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). 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, via koffi → SetForegroundWindow + one SendInput batch that first lets go of any Shift, Alt or Win key you're still holding, so the app receives a clean Ctrl+V). 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, 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). Any other Omniscio window you were in — a popped-out session, Writer, the Scratchpad window — is brought back and the copy is pasted into it just as your own Ctrl+V would. If a copy can't land where it was aimed (a dialog is open, or an image into a text-only box), it is put on your clipboard and a toast says so. 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 }) writes the copy to the system clipboard (so a missed insert can still be pasted by hand) without moving it to the 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. The paste reports whether the copy actually reached its destination, and a brief ✓ flashes on the row only when it did. 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 (on-by-default, encrypted persistence on by default, 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 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, the vault note editor (its popped-out window or the vault docked as the active view), and Omniscio's other windows (a popped-out session, Writer, the Scratchpad), where it pastes as a normal Ctrl+V; from an open Team Chat thread reply box it leaves the copy on the clipboard for a manual Ctrl+V (a v1 scope limit). 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.
• 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 covers the composer; the separate question of getting formatted text into that box is on paste rich text. 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 — the composer this picker lives in
• paste-rich-text.md — how pasting INTO the composer works (separate from this copy-history feature)