Omniscio

Vault images, media and links — pictures, attachments and web addresses

Images, media and the links that turn into something — how a picture is added, stored and displayed in a note, how attachments are kept from bloating the vault, and what happens when you paste a bare web address into a note.

On this page

What it is

This page covers everything that is not text: how images and attachments get into a note, how they are stored and shown, and how pasting a plain web address can turn into a titled link without you doing anything.

Where to find it

The Vault panel — images and attachments are added from inside a note, and the link behaviour happens wherever you paste a URL while editing.

How it behaves

Images & media (Phase 5)

Phase 5 turns KMS from a notes-only surface into a notes-plus-images vault. Every image you paste / drop / pick into the editor is dedup-stored under <vaultRoot>/assets/<sha256>.<ext>, rendered through the custom nothari-asset:// protocol so traversal-safe path resolution sits between the renderer and the filesystem, optionally analyzed by an LLM that emits a per-image title / description / OCR / tags / category, browsed in a full-screen Image gallery overlay, opened full-screen in a Lightbox, and surfaced in the Unified Search modal under the kind:image chip.

Inserting an image (Phase 5 Sub-PRs 5b – 5d)

Three input methods, all ending at the same content-addressed write: paste and drag-drop hand their bytes to kms:import-image-bytes, and the picker reaches it through kms:pick-and-import-images.

  • Paste — Ctrl+V while focused in the editor. The clipboard-image handler in the editor's paste plugin captures the Blob and, because the import is an async round-trip, drops a short-lived "Adding image…" loading placeholder at the caret SYNCHRONOUSLY (so a Ctrl+Z right after the paste undoes it — it used to insert nothing until the import finished, which is why an early undo did nothing and the image popped in afterward); when the bytes resolve, the real image swaps into that placeholder without adding a second undo step, so one Ctrl+Z always removes the paste. The node stores the portable vault-relative ref assets/<sha>.<ext> (NOT the absolute nothari-asset:// URL), so the vault stays self-contained + matches KMT-imported notes; the NodeView resolves it to the per-platform display URL via the active vault (resolveDisplayAssetUrl → getVaultAssetUrl). The loading placeholder never serializes to disk (the image-handling contract's touch-has-first-class-doors invariant).
  • Drag & drop — drop one or more image files anywhere in the editor surface. Multi-drop inserts in source order. Non-image MIME types are silently rejected.
  • Picker — the editor toolbar's ⋯ More menu carries an Image row that opens an OS file picker scoped to image extensions. Same insertion path. (Pre-2026-05-22 this lived as an inline button in the toolbar's media group; the 2026-05-22 collapse moved it into the overflow.)

In all three cases the bytes are hashed (SHA-256), and if the resulting <sha256>.<ext> already exists under <vaultRoot>/assets/, the importer reuses the existing file rather than writing a duplicate — pasting the same screenshot into ten different notes leaves you with one file on disk and ten assets/<sha>.<ext> references. The importer also bumps a refcount row in the nothari_assets table so a future cleanup pass can find truly-orphaned bytes.

The note→image references that back each image's note count live in nothari_asset_refs. These are reconciled synchronously when the note is saved (writeNoteBody / createNote call reconcileNoteAssetRefs), not only later by the file-watcher/indexer — so a just-pasted image's count is right immediately rather than only after the ~debounce window before a reindex. The indexer reconcile stays the backstop for EXTERNAL edits (the image-handling contract's asset-refs-reconcile-synchronously invariant).

Editing an image in place (resize · replace · copy · caption · details)

Each editor image is a VaultImage NodeView with a full set of in-place controls — inline caption/alt-text rows (revealed on selection, not hover) plus a right-click menu (opened by a long-press on touch, since a phone has no right-click — same menu, same items):

  • Resize — hover the image and drag any corner handle. WIDTH is persisted as an INVISIBLE, list-safe marker inside the image's markdown link title — never block <img>/<figure> HTML (that would collapse a numbered list on the next save; see kms-markdown-serialization-contract.md). Height stays automatic so the aspect ratio is locked. The inline image is static — pan/zoom lives in the Lightbox, never in the document — so a drag resizes and a double-click (or Enter on the focused image) opens the Lightbox without the two fighting. A plain single click does NOTHING, so a stray click while reading or editing a note can't pop the viewer; the right-click menu's Open in lightbox is the third door.
  • Replace… — right-click → Replace opens a file picker; the new image is imported and EVERY note that referenced the old one is rewritten in place (one backend pass via kms:replace-image).
  • Copy image — right-click → Copy image puts the actual picture on the clipboard (paste into Gmail / Docs / etc.), falling back to copying the link when the browser blocks image-clipboard writes. "Copy URL" still copies the nothari-asset:// link as text.
  • Caption + alt text — inline rows that reveal only when the image is SELECTED (clicked) — never on hover — and hide at rest, so a plain hover no longer pops "Add caption"/"Add alt text" clutter up under every image the mouse passes over (and the row reclaims the space). A written caption stays visible for reading; alt text (the screen-reader description, not on-screen content) stays selection-gated even when set. (These rows are the ONLY place to set caption/alt — "Edit details" edits different, per-image metadata — so selecting the image is how you reach them.) The caption round-trips through the inline link title (![alt](src "caption")), never block <figure> markdown. Caption + alt-text are per-PLACEMENT (node attributes), so the same image can carry different captions in different notes. (the image-handling contract's caption-rows-reveal-on-selection invariant)
  • Edit details… — a dialog to hand-edit the AI-derived title / description / tags (the per-IMAGE metadata in nothari_image_analysis). Saving writes the row with model: 'manual' and PRESERVES the machine-extracted OCR text.
  • Remove from note — right-click → Remove deletes the image from the note body. The menu preventDefaults its mousedown so clicking it does NOT blur the editor — otherwise TipTap's chained .focus() (deferred to requestAnimationFrame) would leave the editor momentarily unfocused and a follow-up Ctrl+Z would land on <body> instead of undoing the delete. With focus kept on the editor, Ctrl+Z restores the image (the image-handling contract's touch-has-first-class-doors invariant).

Images on the web / phone client

The browser can't resolve the nothari-asset:// protocol, so the web/mobile client renders KMS images through a same-origin, token-gated HTTP route GET /vault-asset/<vaultId>/<relativePath> that reuses the SAME serveVaultAsset security core as the desktop protocol handler — identical path-safety, symlink refusal, extension allow-list, and SVG hardening. The displayed src is chosen per-platform by getVaultAssetUrl; note bodies always store the canonical nothari-asset:// URL.

Image IMPORT on the web can't ride the WebSocket IPC bridge (a Uint8Array doesn't survive the JSON transport), so the mobile editor's Insert image action (in the ⋯ action sheet) POSTs the raw file to POST /vault-asset/<vaultId>?ext=<ext> → importImageBytes, then inserts the returned asset. The upload route is authenticated upstream (the same resolveAuthedToken gate as every web data route) and streams with a 50 MB cap. A failed upload surfaces an error toast that names WHICH failure it was, instead of silently closing the action sheet — unsupported type, too large (413), contents that don't match the file's type (415), or a transient network / server error — so a file the user has to change is never reported as "please try again" — parity with desktop paste/drop (the image-handling contract's upload-never-fails-silently invariant). On a phone every image surface is reachable by touch (desktop's right-click + hover + Ctrl+Shift+G don't exist there): a plain tap does nothing (a stray tap while reading can't pop the viewer); press-and-hold opens its edit menu (Replace / Edit details / Copy / Remove / Open full-screen — the touch twin of the desktop right-click menu, via the shared useLongPress hook, cancelled on scroll), whose Open full-screen item is the touch door to the Lightbox; the editor's ⋯ action sheet → Image gallery row opens the vault Gallery; and caption + alt-text are tappable rows under the image. The image container carries .mobile-press-target so the iOS long-press callout can't pre-empt the hold. Locked by kms-image-handling-contract.md touch-has-first-class-doors.

Behavior + invariants for everything in this section are locked by the KMS image-handling contract.

Asset storage layout

<vaultRoot>/
├── *.md                          # notes
├── .trash/                       # soft-deleted notes
└── assets/                       # all image bytes, content-addressed
    ├── 3a7c1e...f29.png
    ├── 9b4d0a...c16.jpg
    └── e5f8b2...a01.webp

The assets/ directory is automatically created on the first import, ignored by the note watcher (the watcher's .trash/ rule extends to assets/ for the same ping-pong reason — the asset writer drops a file there, the watcher would see it as a new "note", reindex, double-write). Direct hand-editing of assets/ is technically supported but unusual — most users will never look at it. If you delete an asset file from disk while a note still references it, the renderer renders a broken-image placeholder rather than crashing; the next analyzer cycle drops the analysis row for that sha.

nothari-asset:// protocol (Phase 5 Sub-PR 5a)

The renderer references vault images via a custom Electron scheme:

nothari-asset://<vaultId>/<relativePathFromVaultRoot>

The relative path is always the Vault's own content-addressed form, assets/<sha256>.<ext>. A picture the Vault did not store — an Obsidian embed, a web image, a file linked by any other path — has no such ref, so it renders as a broken image link.

The protocol handler is the single security gate before any vault image touches the editor. It resolves the URL through resolveInsideVault() to prevent path traversal (literal .., URL-encoded ..%2f, absolute Windows / POSIX paths, NTFS alternate-data-stream : tricks all reject as 400 Bad Request), refuses to follow symlinks via lstat() (a symlinked .png inside the vault could point at ~/.ssh/id_rsa — 403 Forbidden), and serves only the allow-listed image MIME types: png, jpg, jpeg, gif, webp, svg, avif (every other extension — .exe, .html, .js, .lnk, .pdf, etc. — returns 415 Unsupported Media Type, and path.extname is checked on the FINAL extension only so a double-extension polyglot like foo.png.exe rejects on .exe).

Every successful response carries X-Content-Type-Options: nosniff so a polyglot image with HTML bytes appended can't be MIME-sniffed into a scriptable document, plus Cache-Control: private, max-age=600 so a panel re-render doesn't refetch every embedded image. SVG responses get extra hardening (mirrors the attachment.ts pattern): Content-Disposition: attachment (top-level navigation downloads instead of rendering) plus Content-Security-Policy: default-src 'none'; script-src 'none'; sandbox so even a bypass would render in a unique sandbox origin with no script execution. The scheme is registered as privileged with bypassCSP: false set EXPLICITLY so vault assets obey the same CSP as every other image source — the renderer's CSP img-src includes the literal nothari-asset: token (no wildcards).

The gallery is a view of the centre pane, not a right-pane panel: with a vault open, press Ctrl+Shift+G, pick Open image gallery in the command palette, or — on a phone, which has neither — use the editor's ⋯ action sheet, whose vault-gated Image gallery row opens the same view. A close button at the end of the toolbar returns you to the note.

It shows a thumbnail grid of every asset under <vaultRoot>/assets/ for the active vault, newest first.

Behavior:

  • Thumbnails use the same nothari-asset:// URL the editor uses — Electron caches them after first paint, so re-opening the gallery after browsing is instant.
  • The toolbar carries a filename search, a sort dropdown (Newest / Oldest / Largest / Most-referenced), All/Used/Orphaned scope pills, and — when any analyzed image carries that data — AI tag + category filter dropdowns, plus the live result count. "Clear filters" resets them. The list feed (KMS_LIST_IMAGES) left-joins each on-disk asset with its tags/category from nothari_image_analysis (one vault-scoped query via listImageAnalysisLite), so the dropdowns filter in-grid without opening the Unified Search modal.
  • Each tile's badge is the number of notes that reference that image; an unreferenced image shows an amber 0 (orphaned).
  • An Analyze all button in the toolbar kicks off the bulk-analyze flow (see "AI image analysis" below). It is gated on nothariEnabled === true and stays disabled until at least one image is un-analyzed. Clicking it asks main for the dry-run estimate first, confirms the count and estimated cost, then runs serially with live "Analyzing N of M" progress from kms:image-analysis-progress. With no API-key account configured the run is refused with a message to add an AI key in Settings.
  • Right-click any tile (long-press on touch) opens the image context menu: Show in notes lists the notes that reference the image (each row opens that note), Replace… runs the same kms:replace-image flow as the editor's image menu (confirming first when more than one note uses it), Copy URL copies the nothari-asset:// link (confirmed only after the clipboard write succeeds), and Delete from vault confirms via danger-variant useConfirmDialog. Delete fires kms:delete-image. If the asset is referenced by any note, the handler refuses with image-still-referenced and the refcount (rendered as a toast telling the user how many notes hold it, so they clear the references first). If unreferenced, the file is permanently deleted: it does not go to the trash, there is no restore path for images, and the image's AI title, description, tags and OCR text are erased with it. Unlike deleting a note, this cannot be undone.
  • Opening the Gallery on mobile. Desktop opens this overlay via Ctrl+Shift+G or the command palette's "Open image gallery" — a phone has neither, so the editor's ⋯ action sheet carries a vault-gated Image gallery row (the touch entry point to the same overlay). Tapping a tile still opens the Lightbox.

Opens on a double-click (or Enter) of an in-note image — a plain single click no longer opens it — on click of a gallery tile, OR on click of an image hit in the Unified Search modal. Shape:

  • Full-resolution image, fit-to-viewport with letterboxing for non-matching aspect ratios.
  • Header: the file name as the title, a close button, and one info line — how many notes reference the image, its file size, its position in the vault's images, and the file name again.
  • Side rail: AI metadata when the image has been analyzed — title, category, model, description, tags chip strip, OCR text; otherwise it reads Not analyzed yet. with an Analyze with AI button that fires kms:analyze-image and refreshes the rail when the run finishes.
  • Footer: a Close button, nothing else.
  • Keyboard: Esc closes; Left / Right Arrow step to the previous or next image in the vault, whatever opened the viewer.

The lightbox is the same surface for both gallery browsing AND unified-search image hits — Sub-PR 5h didn't introduce a second viewer.

AI image analysis (Phase 5 Sub-PR 5f)

AI image analysis is not started from the Gallery or the Lightbox. Today it runs only when an agent or script asks for it through POST /kms/images/analyze, and every request waits for your approval first while Require approval: Vault image AI analysis is on, which is the default (see "Agent & CLI access to image metadata"). When it runs, KMS sends each image to the configured AI model and stores the response in the nothari_image_analysis table (migration v198 + v199; see below). Per-image record:

  • title — short noun-phrase summary (~3–7 words).
  • description — 1–3 sentence prose summary of the visible content.
  • ocr_text — every legible character the model extracted, line-broken.
  • tags — a JSON array of single-word tags (e.g. ["screenshot", "diagram", "ui"]).
  • category — high-level bucket (e.g. "screenshot", "photo", "diagram").
  • model + analyzed_at + input_tokens + output_tokens + cost_usd — provenance / cost-tracking fields.

The table uses (vault_id, sha256) as a logical unique key — re-analyzing the same image bytes UPSERTs in place rather than writing a duplicate row. A backing nothari_images_fts FTS5 external-content virtual table mirrors title + description + ocr_text + tags_json + category for the Unified Search images query; an ai/ad/au trigger triad keeps the FTS index in lockstep with the analysis table.

Schema note (migration v198 → v199 fix-up): Sub-PR 5f's original v198 migration shipped with an FTS5 column-name mismatch — the FTS5 column was tags while the content table column was tags_json. Because the FTS table is declared content='nothari_image_analysis', FTS5 reads the content column by the FTS5 column name during snippet(), 'rebuild', and integrity-check operations — the mismatch crashed snippet() with no such column: T.tags. The bug was invisible in 5f because no read path called snippet() until 5h introduced the unified-image search. Migration v199 (Sub-PR 5h) drops + recreates the FTS5 virtual table and the ai/ad/au triggers with tags_json as the column name, then runs the 'rebuild' command to repopulate the index from the existing content rows. v199 is content-preserving — no analysis rows are lost, only the FTS index is rewritten.

The analyzer sends one image per Anthropic API call (no batching — keeps individual costs visible in the cost dashboard). Spend hits api_cost_log via trackApiCost(accountId, 'kms-image-analyzer', model, in, out). AI features fail-with-clear-error when the active account is OAuth/login: per the project rule, "AI features call the Messages API which does not accept OAuth tokens — the analyzer falls back to the first available API-key account, and fails closed with a toast if none exists." Bulk-analyze iterates with rate-limit awareness: it polls listAnalyzedShas(vaultId) between calls so an interrupted run can resume without re-billing analyzed shas.

Agent & CLI access to image metadata (2026-06-11)

The AI image metadata is reachable headlessly, and the CLI control server is the one surface that serves it — agents (and the omniscio-control skill) read it through these routes:

  • CLI control server (runs in main, so it CAN disk-walk): GET /kms/images (asset list + tags/category), GET /kms/images/:sha (full analysis row or analysis:null), GET /kms/images/search?q= (FTS5 over the AI metadata). Read-only, same nothariEnabled 403-gate as the other KMS routes. Surface contract: kms-cli-routes-contract.md.

The per-session kms_* image tools that used to serve this metadata to spawned sessions were retired on 2026-09-19 — see Vault agent tools. The CLI routes above are the live path.

Triggering a new (billable) analysis from the CLI is never a direct call — POST /kms/images/analyze ({ vaultId?, sha256? }, sha set = one image, omitted = all un-analyzed) only ENQUEUES an approval-gated kms.analyze_images row (the kms-image-analysis approval family, danger:'cost', default ON), and the dispatcher runs image-analysis-runner.ts runImageAnalysis only after the user approves. While Require approval: Vault image AI analysis is on (the default), the route returns 202 (queued) with a cost-estimate preview, never 200 (applied-inline) — so no CLI caller can spend without an approval. Turning that switch off in Settings lets an agent's request run, and spend, at once. Mirrors POST /sms/send.

Image IPC surface (Phase 5)

All routes gate on settings.nothariEnabled === true. Every handler answers a { success, data } envelope, { success: false, error } on refusal; the channel constants live in src/shared/ipc-channels/kms.ts.

Import

  • kms:import-image-bytes (5d) — input { vaultId, bytes, sourceExt }, where bytes is the picked/pasted Uint8Array and sourceExt is one of png / jpg / gif / webp / svg / avif. Returns { relativePath, sha256, deduped }. This is the one content-addressed write every input method ends at: identical bytes reuse the existing assets/<sha>.<ext> instead of writing a second copy (deduped: true), and the refcount row is bumped here.
  • kms:pick-and-import-images (5d) — input { vaultId }. Opens the native multi-select image picker in main, reads each file serially so the dedup probe never races itself, and returns { results: { relativePath, sha256, deduped, sourceName }[], errors, cancelled }. A cancelled dialog is an empty results with cancelled: true, never an error.

Read

  • kms:list-images (5e) — input { vaultId }. Walks <vaultRoot>/assets/ and returns { images: { sha256, relativePath, extension, sizeBytes, mtime, noteCount, tags?, category? }[] }, capped at 5,000 entries. The Gallery's data source; the tag/category fields come from a single vault-scoped analysis query so the filter dropdowns need no second round-trip.
  • kms:get-image-metadata (5g) — input { vaultId, sha256 }. Returns { analysis }, the persisted nothari_image_analysis row, or null when the image has not been analyzed. The Lightbox's data source.
  • kms:get-image-refs (5g) — input { vaultId, sha256 }. Returns { refs: { noteId, noteTitle }[] }, every note that references the image, for the "Used in N notes" list.
  • kms:list-orphaned-assets (5g) — input { vaultId }. Returns { orphans }, every asset in assets/ that no note references. No in-app surface calls it — there is no Settings → Storage cleanup pane — so it is reachable only over the CLI/agent surface; the in-app way to find the same assets is the Gallery's Orphaned filter.

Mutate

  • kms:replace-image (5g) — input { vaultId, oldSha256, newBytes, newExt }. Imports the new bytes, then rewrites every note body's assets/<oldSha>.<ext> reference to the new one in a single transaction (the relative ref is the canonical on-disk form extractAssetRefs matches), reconciles refs per note, then erases the old asset and its AI analysis (and FTS entry) once no note references it any more — the privacy-relevant half of replacing a screenshot with a redacted copy. A still-referenced old sha is left in place. Identical bytes short-circuit to { unchanged: true } with no rewrite. Emits kms:images-changed with kind: 'replaced', plus kind: 'deleted' for the old sha when it was erased. The response carries previousShaRemoved and previousShaOrphaned so a caller can tell erasure from a cleanup that could not run.
  • kms:delete-image (5g) — input { vaultId, sha256 }. SECURITY-BEARING: a still-referenced asset is never deleted — the handler pre-checks the refcount and answers { success: true, data: { ok: false, error: 'image-still-referenced', refCount } }, a discriminated no-op rather than a transport error. Otherwise the asset file is deleted permanently (no trash copy, no restore path — the only unrecoverable Vault delete), its AI analysis row and search-index entry are dropped with it, { ok: true, deleted: true } is returned and kms:images-changed fires with kind: 'deleted'.
  • kms:update-image-metadata (5g) — input { vaultId, sha256, …edited title/description/tags }. Writes the same nothari_image_analysis row the analyzer writes, with model: 'manual', preserving the machine-extracted OCR text. Emits kms:images-changed with kind: 'analyzed'.

Analyze

  • kms:analyze-image (5f) — input { vaultId, sha256 }. Analyzes one image against the vision model, UPSERTs its nothari_image_analysis row and emits kms:images-changed with kind: 'analyzed'. The Lightbox's per-image Analyze button.
  • kms:bulk-analyze-images (5f) — input { vaultId, dryRun }. dryRun: true answers { count, estimatedCostUsd, skippedUnsupported } as a cost preview and makes no API call; dryRun: false first resolves an AI credential and refuses with the standard AUTH_REQUIRED "Add an AI key in Settings to analyze images." envelope when there is none, then analyzes the un-analyzed images serially, persisting each, emitting kms:image-analysis-progress per image and aborting before the next call once nothariImageAnalysisCostCapUsd is met. Returns { analyzed, skipped, skippedUnsupported, errors, totalCostUsd, cappedEarly }. There is no gallery button for this: the bulk pass is reached through this route (an agent or the CLI), never from the gallery.
  • kms:image-analysis-progress (5f) — push only, main → renderer: per-image progress (index, total, sha256, cumulative cost) for the bulk run.
  • kms:images-changed (5g) — push only, main → renderer: fires after any handler that mutates a vault's image set, with kind: 'added' | 'replaced' | 'deleted' | 'analyzed', so the renderer can choose a full refetch or a targeted invalidation.
  • kms:unified-search (3h + 5h) — see Unified Search modal. Phase 5 added the images section + kind:image chip.

URL unfurl (clean-URL paste)

This contacts other services, and there is no switch for it. Pasting a bare link into a note makes Omniscio call out straight away: a video link goes to that provider's public oEmbed endpoint and then, if that answers nothing, to the video page itself; a tweet link goes to Omniscio's tweet-screenshot relay together with your Omniscio sign-in token and the tweet id, so the relay can render the picture for you. The Show X/Twitter posts as screenshots setting and the AMC_DISABLE_TWEET_SHOT_CARDS switch belong to chat's tweet cards — neither turns the note-paste path off. Only the link leaves your computer, never the note or your other text; if you would rather nothing went out, paste the link where the unfurl does not fire (beside other text, or inside a code block) and nothing is fetched.

Pasting a clean URL (the pasted text, after trim, IS the URL — no surrounding text) into a note unfurls it, ported from the standalone Nothari app:

  • YouTube (youtube.com/watch?v=…, youtu.be/…, /shorts/…) and Vimeo (vimeo.com/<id>[/<hash>]) → the link text is replaced with the video's title, so the note shows [Real Title](url). The title comes from each site's public oEmbed endpoint (no API key); when oEmbed fails or returns nothing, it falls back to reading the video page's og:title (the endpoint that still answers when Vimeo's abuse WAF 403-blocks /api/oembed.json from an IP — see tasks-v2.md "Paste a video link"). Resolved titles are cached for the process + in-flight-deduped, so a duplicate/rapid re-paste never re-hits the provider.
  • X / Twitter (…/status/<id>) → a rendered screenshot of the tweet is fetched through an Omniscio relay, stored in the vault's content-addressed asset store, and inserted as an inline VaultImage (sized ~25% of editor width, column-aware) at a schema-valid slot next to the pasted link — nested INSIDE the current bullet when you paste into a list (rather than being lifted out and dropped outside the bullets), or the next block in a plain paragraph; the plain link stays as a fallback.
  • Triggers only on a whole-string URL paste, and never inside a code block. While the fetch is in flight a render-only ProseMirror Decoration marks the link (never serialized — a slow fetch can't persist a placeholder).
  • Any failure (offline, deleted/private tweet, service rate limit, no open vault) degrades to the plain link with a soft "kept the plain link" toast — never a crash.

Why main-process: the renderer may not make outbound network calls, so the fetch runs in main behind two IPC channels — kms:fetch-video-title → { title } and kms:fetch-tweet-screenshot → { relativePath, sha256 } (the renderer builds the nothari-asset:// src). Titles are HTML-entity-decoded + whitespace-collapsed (NOT markdown-escaped — the serializer owns that). The oEmbed hosts and the Omniscio relay are fixed (only a numeric tweet id / percent-encoded url param is user-influenced). The og:title fallback is the one request whose host comes from the user's URL, so it is re-validated against a video-host allow-list BEFORE the fetch AND on the final (post-redirect) URL, and the body read is size-bounded — keeping the "no SSRF" surface intact.

Tweet pictures: the screenshot is made by an Omniscio service, so there is nothing for you to set up. The app sends the tweet's numeric id — and your sign-in token, when you are signed in — to an Omniscio relay that fetches the rendered image and returns it. If the relay or the screenshot service is busy or out of credit, the paste keeps the plain link instead.

The vault itself is the KMS page; the editor's own syntax is the editor. Turning a clip from the web into a note is on KMS web clipper.

Last verified 2026-09-23