Omniscio

Vault AI, windows and sharing — summaries, asking your vault and publishing

What the AI adds to the vault — the note summaries and agent tools, asking a question seeded from a note, the Sessions welcome screen with its guided vault setup, keeping the vault loaded so it opens instantly, the standalone window, deep links to a note, and publishing one to a public web address.

On this page

What it is

This page covers the parts of the vault that reach outside it: the AI summaries and tools, asking a question based on a note, the ways to open the vault faster or in its own window, linking straight to a note, and publishing one for someone else to read.

Where to find it

From the Vault panel and from Settings. Publishing produces a public web address you can share; deep links are URLs you can keep or send.

How it behaves

Phase 6 — AI summaries + agent access

Phase 6 wired two independent slices on top of the Phase 1-5 foundation.

Per-note AI summaries. A short AI summary stored in each note — flagged stale when the note changes, refreshed on request or by an opt-in timer, under a daily spend cap — is described on KMS note summaries. Bulk-seed worker for first-time vault-wide generation adds a per-run cap of its own (nothariBulkSeedCostCapUsd, default $5) on top of that daily cap, so at the shipped defaults (daily $2, per-run $5) the daily cap is the one that stops a bulk seed.

Agent access (the MCP tools are retired). The read-only kms_* tools — kms_search, kms_read, kms_list_tags, kms_list_recent, kms_get_backlinks — were retired on 2026-09-19: no Claude Code session Omniscio spawns gets a Vault .mcp.json entry any more, and the Expose Vault to spawned agents switch in Vault settings no longer changes anything. Agents reach your notes by other roads — Omniscio's own /kms/* routes (with the install-wide CLI token), and, for a session started from the Vault, reading and editing the .md files directly. Full mechanics: Vault agent tools — retired; how agents reach your notes now.

The image analyzer (Phase 5f), summary service (6b), bulk-seed (6d), and auto-regen worker (6e P2) all share a common cost-tracking pattern via trackApiCost() (Phase 6c). The caps are not one per path: the image analyzer has a cap of its own (nothariImageAnalysisCostCapUsd, default $2 per run), while per-note summaries, bulk seed and the editor's Ask-AI commands draw on one shared per-account daily cap (nothariSummaryCostCapUsd, default $2) kept in cost-cap-ledger.ts. So heavy use of any one of those three uses up the day's budget the other two draw on. One exception: on an install with no Anthropic API key set, the editor's Ask-AI spend is tracked against your signed-in account while summaries and bulk seed are tracked in a separate bucket, so those two keep separate $2 days. Image analysis is the only path kept apart everywhere.

Ask your vault (one-click note-seeded chat)

From an open note you can hand the whole vault to Claude in one click. The Vault editor header carries an Ask AI button (a ✨ Sparkles trigger) that drops a small menu with three actions — Summarize this note, Find related notes, and Ask a question — and the same three live as command-palette rows (ai.summarize-note, ai.find-related, ai.ask-about-vault). Summarize this note and Find related notes open the shared Start session dialog with the instruction already typed in Message, so you can change it (or the repo and model) before pressing Start; Ask a question starts at once. Either way the result is a Claude session scoped to the vault (the __nothari__ project), and the Vault main pane flips to its Sessions view (kmsViewMode: 'sessions') and streams the answer there. Because that session starts inside the vault folder with the vault primer, it reads your real notes from the .md files directly, so the answer cites them rather than guessing. The read-only kms_* retrieval tools it used to carry were retired on 2026-09-19 — see Vault agent tools.

Your notes are treated as data, not orders. Because a vault chat runs inside your notes folder, a file named CLAUDE.md, CLAUDE.local.md or AGENTS.md anywhere in it — or a .claude folder — would be read by the assistant as standing instructions. So the app keeps those out: no plugin, agent or import can create one, an Obsidian import skips them and reports them as not imported, and a vault chat will not start or restart while one is anywhere in your vault. Instead you get a plain message telling you to move or rename that file, and the chat starts as soon as it is gone. The small .claude folder Omniscio itself keeps in your vault (its own settings and a lock file) does not count, so you never have to move that one.

The chat is not a separate inline panel — it reuses the exact session the Vault "Agent sessions" tab already spawns (the main-pane SessionPanel), so there is no second chat/streaming stack to maintain; the launcher only makes that session launchable from the menu and optionally pre-seeded with a prompt about the active note. The seed is a short instruction that names the note by title + vault-relative path and tells the agent to read it with its tools — the note body is never embedded in the prompt (a 167 KB note would blow the token budget). Summarize this note and Find related notes need an open note (they seed from it) and disable when none is open; Ask a question only needs a vault. Everything is gated on a configured vault root — with no vault set, the header trigger and the note-seeded palette rows render disabled and a click surfaces a humanized toast instead of a spawn. Each chat is a normal user-initiated session tracked by Omniscio's usual session cost path — there is no separate per-feature cost cap (summaries keep their own daily cap; this does not).

How it's wired (repo detail). The launcher seam is useAskVault.ts — useAskVault() returns { askVault, canAskVault }; askVault() resolves the __nothari__ project id at call time, flips setKmsViewMode('sessions'), and calls launchSession(projectId, …, 'kms-session-host', seedPrompt?) — the exact path KmsSessionsList.tsx uses, with the mandatory 'kms-session-host' source, plus the pure seed builders buildSummarizeSeed / buildRelatedSeed. When the call names the active note (Summarize and Find related), askVault() instead opens the shared dialog through openVaultNoteStartSession (vault-start-session.ts), whose start uses the same 'kms-session-host' source and then shows the session in the Sessions view. The header dropdown is AskAiMenu.tsx (a ToolbarMenu, editor view only), rendered from KmsView.tsx, which also threads askVault / canAskVault onto the CommandContext. The ai.* rows in commands/registry.ts are all live, including Continue writing (ai.continue-writing), which opens the continue-from-the-cursor panel; it is disabled only when no note is open or the note is read-only, and it shows its draft for you to accept or discard rather than inserting on its own. Full invariants — seed-never-embeds-body, the reused session seam, the vault gate, never-throws-to-caller, and the summary auto-regen ignition that shipped alongside — live in the KMS Ask-Your-Vault contract.

The Sessions welcome screen

On desktop, switching the Vault's sidebar to Sessions with no chat open shows a welcome screen in the main pane: the Omniscio orb, "Welcome to the Vault, your knowledge management system.", and two tiles side by side.

  • Start a new session — opens a blank AI session in your vault and shows its chat.
  • Help me set up a new vault — opens a guided session. The agent first looks at what is already in the vault, asks what you want to use it for (and whether you keep notes elsewhere, such as Obsidian), proposes a few top-level folders, a "Start Here" home note and one or two templates, and creates them only after you say yes. It is instructed never to delete, move, rename or overwrite an existing note or folder, and it answers in the language you write in. That is an instruction the session is given, not a technical lock: the session works on your vault's plain .md files, so an edit it makes on disk does not go through the Vault's own trash or version history. Read the structure it proposes before you say yes. The chat shows the tile's title, not the full instructions.
  • No vault folder yet? Either tile first creates the default vault folder in your Documents folder (the same one Simple Mode uses) and saves it as your vault, then starts the session. If that fails you get one plain message and nothing starts.
  • The note editor stays loaded behind the welcome, so switching back to Files is instant. On a phone, the Sessions tab is still the session list.

Contract + invariants: kms-sessions-welcome-contract.md.

Keep KMS loaded for instant switching (keep-warm)

By default (desktop), once you open the Vault its editor stays loaded in the background when you switch to a chat session or another project, so switching back into the Vault is an instant display flip instead of a cold rebuild of the TipTap editor. It uses the same "permanent display-toggled layer" technique Omniscio already uses for the AutoHotkey editor and plugin webviews.

  • Setting: Settings → Performance → "Keep KMS loaded for instant switching" (kmsKeepWarmEnabled, default on / opt-out). Turn it off to load KMS fresh each time (the older behavior).
  • Cost: one editor held in memory, and only after you've opened KMS at least once — nothing is held until then.
  • Desktop only. Phones mount a single panel, so there is nothing to keep warm; the setting has no effect there.
  • Env kill switch: AMC_DISABLE_KMS_KEEP_WARM=1 force-disables it regardless of the setting.
  • The Vault editor is mounted in exactly one place at a time — the warm layer when keep-warm is on, or the dashboard overlay when it is off, never both. It hides automatically when the Vault yields to a session chat (Sessions view + a session) or when a file/diff/inbox view takes the main pane.
  • Opening the Vault is counted by the Vault itself. The shared panel shell (RoutedPanel) emits integration_panel/panel_opened for every integration it mounts, but the keep-warm layer mounts KMS outside that shell — so on desktop with keep-warm on (the default) that counter never saw a Vault open, and the Vault read as barely used by every desktop user. KmsView therefore emits its own kms/panel_opened, once per shown flip (a hidden warm layer is not an open, and the startup restore of the last panel is not either), and kms is listed in PANELS_COUNTING_THEIR_OWN_OPENS so the overlay and phone paths — where RoutedPanel does mount it — never count the same open twice. The standalone Vault window is excluded from panel_opened because its open is already counted as kms/window_opened.
  • First-value milestones. The Vault stamps four first-occurrence activation milestones from main-process chokepoints, so a new user's Vault path is measurable step by step: firstVaultOpenedAt (the panel open above), firstVaultFolderSetAt (the KMS service reaching a configured, validated root), firstVaultNoteCreatedAt (a note is created) and firstVaultNoteSavedAt (a note body actually lands on disk). A save that never lands therefore stops looking like a save, which is what makes "typed but it did not save" answerable.

Contract + invariants: kms-keep-warm-contract.md. For an always-open second window instead, see Standalone KMS window below.

Standalone KMS window

A separate OS window that hosts the full KMS experience — file tree + editor and a real session host — so the user can work the Vault (notes and AI sessions) on a second monitor while Omniscio runs in the main window. Both surfaces mount the same KmsView/stores over the same vault and stay in sync in real time. Ctrl+T in the pop-out launches a Vault session and opens its chat right there — see "Session host" below.

Window chrome — the note tabs live in the title strip

The window is frameless (titleBarStyle: 'hidden', shared with the Scratchpad window). Instead of the Scratchpad's label-only StandaloneWindowTitleBar, the KMS window renders its own KmsWindowTitleBar that hosts the note tabs (TabBar) directly in that slim top strip with custom HTML caption buttons (WindowControls) at the trailing edge — so the pop-out reclaims the row the in-pane tabs bar used to spend, putting the editor ~one bar higher. The strip stays the window's drag region (only its tab controls and caption buttons opt out via .no-drag / a scoped .kms-window-titlebar … { -webkit-app-region: no-drag } rule in globals.css, so the window still moves while tabs stay clickable / drag-to-reorder), keeps the shared 40px height, and reserves space so tabs never tuck under the buttons (trailing on Windows, leading inset on macOS). KmsView renders its in-pane TabBar only when not isStandaloneWindow, so the tabs never double up; the in-app dashboard panel is unchanged. Contract: scratchpad-window-contract.md (frameless-chrome-shared-with-the-kms-window) and window-controls-contract.md.

Three open affordances (all call kmsWindow.open())

All three call the same show-or-focus entrypoint — opening the window when closed, or bringing it to the front when already open. The window is never toggled-to-hide.

  1. Pop-out button in the KMS toolbar — an ExternalLink icon in the toolbar's View group, tooltip "Open the Vault in a separate window".
  2. Global hotkey — default Ctrl+Alt+N (CommandOrControl+Alt+N), system-wide OS-level shortcut. Customizable and toggleable under Settings → Keyboard Shortcuts ("KMS window" row).
  3. Tray menu — "Open KMS" item in the Omniscio system-tray menu.

Session host (Ctrl+T + chat)

The pop-out is a full session host, not only a notes surface. It boots the session store (useSessionSync + a KMS-project fetch, mirroring the detached single-session window), so the Sessions tab in its sub-sidebar goes live, and it renders the session chat (the pooled SessionPanel) in place of the editor when you are on the Sessions view with a session active — the shared pickKmsMainPane decides. Closing the chat drops back to the note editor in place (a multi-session host never self-closes on chat-close).

Ctrl+T launches a new KMS session and opens its chat in the window. Chromium swallows Ctrl+T before the DOM sees it, so the main process intercepts it in kms-window.ts via before-input-event and delivers a targeted KMS_WINDOW_NEW_SESSION webContents.send to this window ONLY (never emitPush/broadcast) — so a Ctrl+T in the main window can never spawn in the pop-out and vice-versa. KmsWindowApp handles it by launching into the KMS project with the kms-session-host source (the same path the sidebar "+ New" uses) and activating the new row.

Live sync

The standalone window forwards to the renderer exactly the channels in KMS_WINDOW_ALLOWLIST:

KMS_NOTE_CHANGED, KMS_ACTIVE_VAULT_CHANGED, KMS_BOOKMARKS_CHANGED, KMS_SUMMARY_UPDATED, KMS_IMAGES_CHANGED, SETTINGS_CHANGED, CUSTOM_THEMES_CHANGED, KMS_OPEN_NOTE

(CUSTOM_THEMES_CHANGED was added so the KMS's own custom-theme override picks up an imported / deleted custom theme live in the pop-out window — see Custom theme options. KMS_OPEN_NOTE is the quick-find → pop-out signal: when the Find Note search picks a note and this window is open, the handler foregrounds it and pushes the note here to open via the shared requestOpenNote sink — see Find Note quick-switcher.)

The window is registered under role: 'kms' with its KMS project id. On top of KMS_WINDOW_ALLOWLIST, the fan-out also forwards the global chrome channels (DETACHED_GLOBAL_ALLOWLIST — theme / network / focus / app-update, the same set the detached single-session window gets, since the pop-out now hosts a real SessionPanel) and this project's session-scoped channels — matched by the pre-resolved sessionProjectId, so the live session list + open chat stay current. That last group is project-scoped on purpose: a non-KMS session's high-frequency SESSION_OUTPUT never reaches the pop-out, so a large concurrent-session fleet doesn't tax the second renderer. Everything else is dropped.

Position memory

Window bounds (x/y/width/height) are persisted in the FK-free detached_window_positions table under the sentinel key '__kms_window__' — the same table used by the detached-session window. No migration was needed because session_id is a plain TEXT PRIMARY KEY and the sentinel key '__kms_window__' is a valid value. Defaults: 1100×760, centered on the primary display. Bounds are saved on move/resize (500 ms debounce) and synchronously on close.

Window chrome

Frameless like the main window: titleBarStyle: 'hidden' + a slim draggable title strip with custom HTML caption buttons (WindowControls), with the native "View/Window" menu removed (removeMenu()). The window backgroundColor is the dark-first #09090b (matches kms-window.html). Chrome is shared with the scratchpad window via standaloneWindowChromeOptions() / applyStandaloneWindowChrome() — see scratchpad-window-contract.md frameless-chrome-shared-with-the-kms-window and window-controls-contract.md.

Deep linking to a note

A specific note can be opened from outside Omniscio (an email, another note, a dashboard, a script) via the omniscio:// protocol:

omniscio://note/<vault-relative-path>[?vault=<vaultId>]
  • The path is the note's vault-relative path, percent-encoded. omniscio://note/Architecture.md, omniscio://note/One-on-Ones/Brett.md, and omniscio://note/Column%20Layout%20Demo.md all work; sub-folders may be passed as real / separators OR a single %2F-encoded segment (both rebuild to the same path). new URL collapses any ./.. traversal before the parser runs, so a link can never escape the vault root.
  • ?vault=<vaultId> is optional — it targets a specific vault; omit it to use the active / only vault.
  • The link navigates (activates the KMS panel + dashboard view) and opens the note as a tab. It is non-destructive — no session spawn, no message send — so, unlike new-session / open-superprompt, it is NOT confirmation-gated (it matches the trust level of navigate-session / activate-project).
  • A cold link (KMS panel not yet mounted, no vault loaded) still lands: requestOpenNote stashes the path in the store's pendingOpenNotePath, and the tail of loadTree opens it once activeVaultId + the note list have hydrated (epoch-guarded so a racing vault switch can't open into a stale vault).
  • Vault disabled → the Vault virtual project is absent from the project list and the router surfaces a "The Vault is not enabled" toast. A path that no longer matches an indexed note (renamed / deleted since the link was made) surfaces a "couldn't find note" toast instead of opening a blank tab.

A dev / sandbox instance running alongside production uses the per-instance scheme agentmc-<id>://note/... (see getInstanceDeepLinkPrefix()); production uses bare omniscio://.

Get the link from the UI — right-click → Copy link. A Vault page's deep link is now obtainable without hand-forming it: right-click any page — in the file tree, on its editor tab, or inside the open page (the editor body) — and choose Copy link to copy omniscio://note/<relativePath>?vault=<vaultId> to the clipboard (a Link to "<page>" copied toast confirms; an honest error toast fires if both clipboard paths fail). The tree row is file-only (a folder is not a page); the tab + editor rows (from the shared buildPageShareActions factory, page-share-actions.tsx) act on the open note. The link is built by buildAgentmcNoteUrl(relativePath, vaultId?) (agent-markdown-path-utils.ts) — the build-inverse of the parseDeepLinkUrl reader above, so it round-trips exactly (a page name with sub-folders / spaces / # / & / unicode survives) — and copied through the resilient copyKmsNoteLink chokepoint (copy-kms-note-link.ts), mirroring the session "Copy link". Works in the in-app panel AND the pop-out Vault window. Invariants (one format, the ?vault= param name, file-only, honest toast) are pinned by kms-note-link-contract.md; tests: build-agentmc-note-url.test.ts (build↔parse round-trip), copy-kms-note-link.test.ts, kms-copy-link.spec.ts.

Beyond the app-only deep link above, a KMS page can be published to a public web page anyone can open in a browser — on a phone, with no Omniscio install. Right-click a page — on its editor tab, inside the open page, or in the file tree — and choose Publish page….

  • What it produces. A standalone, mobile-responsive web page hosted on Omniscio Shares (https://shares.omniscio.com/s/<token>). It renders the note's text and formatting, and its local vault images are inlined (base64) so they load anywhere without the desktop app's nothari-asset:// scheme. The public URL is copied to your clipboard (a toast confirms).
  • Confirm + sign-in gated. Publishing always pops a confirmation first (the page becomes PUBLIC — anyone with the link can view it) and requires a signed-in Omniscio cloud account (a toast points you to Settings when signed out). There is no accidental one-click publish.
  • Managed in the Shares panel. A published page is a normal Share artifact — it appears in the Shares panel where you can unpublish / revoke it, exactly like any other share.
  • Re-publishing updates the SAME link in place. Edit a page and publish it again and its existing public link updates in place (same URL, new content) instead of piling up a new share each time. The page is associated to its share via shared_links.vault_page_id; the Shares relay's mint-upload op takes an owner-checked existingToken to re-upload to the same token (serveShare reads fresh, so the same URL serves the new content). Requires the Shares relay Cloud Function to be deployed; until then it degrades gracefully to a fresh link (the client detects the relay didn't honor the token and mints a new one).
  • The page follows the note out. Deleting, purging or hiding a note takes its public page down for good in the same action, and renaming or moving a note carries the page across, so publishing it again keeps the SAME link. This holds however the note goes: from the app, from the CLI, or by deleting or moving the .md on disk in Finder / Obsidian / a terminal — the file watcher and the next vault scan take the page down too (an out-of-band rename reads as a delete, so the old link goes and publishing at the new spot mints a fresh one). Hiding ends the public link too, deliberately: a hidden note must not stay readable at an old URL, so unhide and publish again if you want one (that mints a fresh link).
  • Trashing only HIDES the page, and restoring brings the same link back. Putting a note in the trash swaps its public page for a "Page not available" one at the SAME address — the link stops serving the note, but the share stays live, so restoring the note from the trash republishes it on that same URL and it works again. Permanently deleting it (Delete forever, Empty trash, or the retention sweep) still takes the page down for good. A link whose own expiry passes while the note sits in the trash is not brought back. This is the Vault page sharing → Hide a public page while its note is in the trash setting in Settings → Features → Vault, on by default; switching it off restores the older behaviour where trashing ends the link permanently. If the page cannot be hidden (signed out, or the shares service unreachable) it is taken down instead, so a trashed note's content never stays readable.
  • Publish from desktop OR mobile. The desktop right-click menus AND the phone/web KMS action sheet's Publish page… row both work; the desktop main process always does the render + image-inlining (a paired phone just triggers it over the WS bridge — KMS_PAGE_PUBLISH is baselined, not blocked), so the page renders identically either way.

Security. The publish path reuses the audited Share pipeline end-to-end: images are inlined ONLY through the guarded serveVaultAsset resolver (realpath-under-vault containment — a ../ traversal can never leak an off-vault file into the public page), remote http(s) images are left as URLs and never fetched server-side (no SSRF), and the markdown is rendered through the audited renderMarkdown sanitizer (marked + sanitize-html) so a <script> / onerror payload in the note never reaches the artifact.

Wiring (repo detail). The renderer's usePublishPage hook (src/renderer/src/features/kms/hooks/usePublishPage.ts) gates on useShareSignedIn, confirms via useConfirmDialog, then invokes KMS_PAGE_PUBLISH (publish.ts, over the shared publish-vault-page.ts that the approval-gated CLI POST /kms/pages/publish also runs). Main renders the page via renderVaultPageHtml (publish-page.ts — strip frontmatter → inline local images → renderMarkdown → standalone HTML shell) and publishes it through the shared Share Artifacts service (pastedContent HTML) so one Firebase publisher + dedup cache back both this and the renderer's SHARE_PUBLISH_ARTIFACT. The Copy link + Publish rows on the tab and editor-body menus come from the shared buildPageShareActions factory; the file tree adds Publish alongside its existing Copy link. Tests: publish-page.test.ts (inline security + render/sanitize), page-share-actions.test.tsx.

Handler rules (repo detail). A republish of a page that already has a live share passes that share's token, so the same link updates and no second share is minted (and no "created" push fires). The in-app channel also carries a volume cap of 30 publishes a minute (F157): content dedup already absorbs a double-click, but each distinct publish is an expensive upload plus a public URL, so a burst is refused before anything renders or uploads. Expected refusals — empty page, size cap, signed out (including the two auth refusals the share path tells apart, T-423), offline, quota, Firebase client missing, and a share deleted while it was still publishing — come back as error codes the renderer turns into plain words; a size-cap refusal names this page's size and the limit it broke. Anything else rethrows to the handler wrapper, which logs it and reports it to Sentry, so a real crash is never swallowed as a domain refusal. Tests: kms-publish-handler.test.ts (F272: token reuse, the rethrow, and the cap refusing without rendering).

The vault itself is the KMS page, and the internals — the IPC surface, how it is built, and what it promises about your data — are mobile, sync and internals. The note summaries are covered in more depth on KMS summaries, and the agent tools on KMS agent tools.

Last verified 2026-09-28