docs: add public site

.claude/commands/start.md

@@ -0,0 +1,21 @@
+# /start
+
+Start Tolaria in Tauri dev mode.
+
+## Steps
+
+1. Change to the Tolaria workspace:
+
+```bash
+cd /Users/luca/Workspace/tolaria
+```
+
+2. Start the native development app:
+
+```bash
+pnpm tauri dev
+```
+
+3. Keep the command running. Report the Vite local URL once it appears and leave the dev process alive for the user.
+
+This is a local utility command, not a Laputa task. Do not run `/laputa-next-task`, CodeScene gates, Todoist updates, commits, or pushes for this command unless the user asks separately.

.codescene-thresholds

@@ -1,2 +1,2 @@
 HOTSPOT_THRESHOLD=10.0
-AVERAGE_THRESHOLD=9.91
+AVERAGE_THRESHOLD=9.89

.github/workflows/ci.yml

@@ -65,6 +65,9 @@ jobs:
       - name: Vite build check
         run: pnpm build
 
+      - name: Docs build check
+        run: pnpm docs:build
+
       # ── 1. Coverage-backed tests ──────────────────────────────────────────
       # The coverage commands run the same frontend and Rust test suites, so keep
       # them as the canonical test lane instead of running every suite twice.

.github/workflows/release-stable.yml

@@ -689,10 +689,10 @@ jobs:
             stable-latest.json
 
   # ─────────────────────────────────────────────────────────────
-  # Phase 4: Update GitHub Pages
+  # Phase 4: Update GitHub Pages with docs, release history, and download assets
   # ─────────────────────────────────────────────────────────────
   pages:
-    name: Update release history page
+    name: Update docs and release pages
     needs: [version, release]
     runs-on: ubuntu-latest
     permissions:
@@ -703,23 +703,39 @@ jobs:
     steps:
       - uses: actions/checkout@v4
 
+      - name: Setup pnpm
+        uses: pnpm/action-setup@v4
+        with:
+          version: 10
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '22'
+          cache: 'pnpm'
+
       - name: Setup Bun
         uses: oven-sh/setup-bun@v2
         with:
           bun-version: latest
 
-      - name: Build release history page
+      - name: Install dependencies
+        run: pnpm install --frozen-lockfile
+
+      - name: Build docs and release pages
         env:
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         run: |
+          VITEPRESS_BASE="/${GITHUB_REPOSITORY#*/}/" pnpm docs:build
           mkdir -p _site/alpha _site/stable
+          cp -R site/.vitepress/dist/. _site/
           gh api -H "Accept: application/vnd.github.html+json" repos/${{ github.repository }}/releases --paginate > _site/releases.json
           PAGES_URL="https://refactoringhq.github.io/${GITHUB_REPOSITORY#*/}"
 
           curl -fsSL "${PAGES_URL}/alpha/latest.json" -o _site/alpha/latest.json || echo '{}' > _site/alpha/latest.json
           gh release download --repo ${{ github.repository }} "${{ needs.version.outputs.tag }}" --pattern "stable-latest.json" --output _site/stable/latest.json || echo '{}' > _site/stable/latest.json
           bun scripts/build-release-download-page.ts --latest-json _site/stable/latest.json --releases-json _site/releases.json --output-file _site/stable/download/index.html
-          bun scripts/build-release-history-page.ts --releases-json _site/releases.json --output-file _site/index.html
+          bun scripts/build-release-history-page.ts --releases-json _site/releases.json --output-file _site/releases/index.html
           mkdir -p _site/download
           cp _site/stable/download/index.html _site/download/index.html
 

.github/workflows/release.yml

@@ -740,10 +740,10 @@ jobs:
             alpha-latest.json
 
   # ─────────────────────────────────────────────────────────────
-  # Phase 4: Update GitHub Pages with release history
+  # Phase 4: Update GitHub Pages with docs, release history, and download assets
   # ─────────────────────────────────────────────────────────────
   pages:
-    name: Update release history page
+    name: Update docs and release pages
     needs: [version, release]
     runs-on: ubuntu-latest
     permissions:
@@ -754,23 +754,39 @@ jobs:
     steps:
       - uses: actions/checkout@v4
 
+      - name: Setup pnpm
+        uses: pnpm/action-setup@v4
+        with:
+          version: 10
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '22'
+          cache: 'pnpm'
+
       - name: Setup Bun
         uses: oven-sh/setup-bun@v2
         with:
           bun-version: latest
 
-      - name: Build release history page
+      - name: Install dependencies
+        run: pnpm install --frozen-lockfile
+
+      - name: Build docs and release pages
         env:
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         run: |
+          VITEPRESS_BASE="/${GITHUB_REPOSITORY#*/}/" pnpm docs:build
           mkdir -p _site/alpha _site/stable
+          cp -R site/.vitepress/dist/. _site/
           gh api -H "Accept: application/vnd.github.html+json" repos/${{ github.repository }}/releases --paginate > _site/releases.json
           PAGES_URL="https://refactoringhq.github.io/${GITHUB_REPOSITORY#*/}"
 
           gh release download --repo ${{ github.repository }} "${{ needs.version.outputs.tag }}" --pattern "alpha-latest.json" --output _site/alpha/latest.json || echo '{}' > _site/alpha/latest.json
           curl -fsSL "${PAGES_URL}/stable/latest.json" -o _site/stable/latest.json || echo '{}' > _site/stable/latest.json
           bun scripts/build-release-download-page.ts --latest-json _site/stable/latest.json --releases-json _site/releases.json --output-file _site/stable/download/index.html
-          bun scripts/build-release-history-page.ts --releases-json _site/releases.json --output-file _site/index.html
+          bun scripts/build-release-history-page.ts --releases-json _site/releases.json --output-file _site/releases/index.html
           mkdir -p _site/download
           cp _site/stable/download/index.html _site/download/index.html
 

.gitignore

@@ -10,6 +10,9 @@ lerna-debug.log*
 node_modules
 dist
 dist-ssr
+site/.vitepress/cache/
+site/.vitepress/dist/
+_site/
 *.local
 
 # Editor directories and files

README.md

@@ -27,16 +27,18 @@ You can find some Loom walkthroughs below — they are short and to the point:
 - 🔬 **Open source** — Tolaria is free and open source. I built this for [myself](https://x.com/lucaronin) and for sharing it with others.
 - 📋 **Standards-based** — Notes are markdown files with YAML frontmatter. No proprietary formats, no locked-in data. Everything works with standard tools if you decide to move away from Tolaria.
 - 🔍 **Types as lenses, not schemas** — Types in Tolaria are navigation aids, not enforcement mechanisms. There's no required fields, no validation, just helpful categories for finding notes.
-- 🪄**AI-first but not AI-only** — A vault of files works very well with AI agents, but you are free to use whatever you want. We support Claude Code, Codex CLI, and Gemini CLI setup paths, but you can edit the vault with any AI you want. We provide an AGENTS file for your agents to figure out.
+- 🪄**AI-first but not AI-only** — A vault of files works very well with AI agents, but you are free to use whatever you want. We support Claude Code and Codex CLI (for now), but you can edit the vault with any AI you want. We provide an AGENTS file for your agents to figure out.
 - ⌨️ **Keyboard-first** — Tolaria is designed for power-users who want to use keyboard as much as possible. A lot of how we designed the Editor and the Command Palette is based on this.
 - 💪 **Built from real use** — Tolaria was created for manage my personal vault of 10,000+ notes, and I use it every day. Every feature exists because it solved a real problem.
 
 ## Getting started
 
-Download the [latest release here](https://github.com/refactoringhq/tolaria/releases/latest/download/Tolaria.app.tar.gz).
+Download the [latest release here](https://refactoringhq.github.io/tolaria/download/).
 
 When you open Tolaria for the first time you get the chance of cloning the [getting started vault](https://github.com/refactoringhq/tolaria-getting-started) — which gives you a walkthrough of the whole app.
 
+The public user docs live in [`site/`](site/) and are intended for GitHub Pages. Start with [Install Tolaria](site/start/install.md), then [First Launch](site/start/first-launch.md).
+
 ## Open source and local setup
 
 Tolaria is open source and built with Tauri, React, and TypeScript. If you want to run or contribute to the app locally, here is [how to get started](https://github.com/refactoringhq/tolaria/blob/main/docs/GETTING-STARTED.md). You can also find the gist below 👇
@@ -71,12 +73,6 @@ Tauri 2 on Linux requires WebKit2GTK 4.1 and GTK 3:
 
 The bundled MCP server still spawns the system `node` binary at runtime on Linux, so install Node from your distro package manager if you want the external AI tooling flow.
 
-### Gemini CLI setup
-
-Tolaria can register the active vault's MCP server in `~/.gemini/settings.json` from the status bar or command palette action "Set Up External AI Tools". The generated entry is scoped to the selected vault with `VAULT_PATH` and requires Node.js 18+ plus a separately installed and signed-in Gemini CLI.
-
-Use "Restore Tolaria AI Guidance" if you also want Tolaria to create a non-destructive `GEMINI.md` compatibility shim in the vault root. The shim points Gemini back to the shared `AGENTS.md` instructions and is not written over custom `GEMINI.md` content.
-
 ### Quick start
 
 ```bash

docs/ABSTRACTIONS.md

@@ -175,7 +175,6 @@ Type is determined **purely** from the `type:` frontmatter field — it is never
 ├── some-topic.md          ← type: Topic
 ├── AGENTS.md              ← canonical Tolaria AI guidance
 ├── CLAUDE.md              ← compatibility shim pointing at AGENTS.md
-├── GEMINI.md              ← optional Gemini CLI shim pointing at AGENTS.md
 ├── ...
 └── type/                  ← type definition documents
 ```
@@ -304,12 +303,6 @@ type SidebarSelection =
 - A successful folder rename reloads the folder tree plus vault entries, rewrites any affected folder-scoped tabs, and updates `SidebarSelection` to the new relative path when the renamed folder stays selected.
 - Folder deletion clears pending rename state, confirms destructive intent, drops affected folder-scoped tabs, reloads vault data, and resets folder selection if the deleted subtree owned the current selection.
 
-### Saved Views
-
-Saved Views live as YAML files under `views/`. Their definition includes user-visible fields (`name`, `icon`, `color`), note-list preferences (`sort`, `listPropertiesDisplay`), filters, and an optional top-level `order` number. The `order` value is stored directly in the YAML document, not in Markdown frontmatter, and lower values render earlier in every saved-View list. Views without an explicit order sort after ordered views by filename for stable fallback behavior.
-
-The renderer uses `viewOrdering` helpers to convert drag or move-button intent into dense order updates before saving each affected view file through `save_view_cmd`. The sidebar exposes both a drag handle and explicit move-up/move-down controls, and the command palette mirrors those move actions for the currently selected saved View.
-
 ### Neighborhood Mode
 
 `SidebarSelection.kind === 'entity'` is Tolaria's Neighborhood mode for note-list browsing.
@@ -352,7 +345,7 @@ Command-layer path access is fenced to the active vault before file operations r
 
 UI-only file actions operate on paths that are already selected or indexed in React state. Reveal-in-Finder and external-open calls route through the Tauri opener plugin, while copy-path uses the browser clipboard API; none of those actions mutate vault contents or bypass the backend write boundary.
 
-The local MCP WebSocket bridge follows the same active-vault boundary. `useVaultSwitcher` calls `sync_mcp_bridge_vault` after the persisted selection loads and after each vault switch; the desktop command starts/restarts the bridge with that vault's canonical path, or stops it when there is no selected vault. App exit uses the same child cleanup path and waits for the bridge process after killing it. MCP Node entrypoints require `VAULT_PATH` and fail clearly instead of falling back to `~/Laputa`. Manual MCP config export uses the same generated stdio entry as registration, so the copied snippet remains scoped to the active vault without writing third-party config files. External-client stdio MCP processes also exit when stdin closes; their UI-bridge reconnect timers and WebSocket are canceled during shutdown so disconnected clients do not leave extra Node processes behind.
+The local MCP WebSocket bridge follows the same active-vault boundary. `useVaultSwitcher` calls `sync_mcp_bridge_vault` after the persisted selection loads and after each vault switch; the desktop command starts/restarts the bridge with that vault's canonical path, or stops it when there is no selected vault. MCP Node entrypoints require `VAULT_PATH` and fail clearly instead of falling back to `~/Laputa`.
 
 ### Vault Caching
 
@@ -609,7 +602,6 @@ The app uses internal light and dark themes owned by Tolaria (see [ADR-0081](adr
 1. **Global CSS variables** (`src/index.css`): Semantic app colors, borders, surfaces, and interaction states via `:root` / `[data-theme]`, bridged to Tailwind v4
 2. **Editor theme** (`src/theme.json`): BlockNote typography, flattened to CSS vars by `useEditorTheme`
 3. **Runtime theme bridge**: Applies `data-theme` and `.dark` for shadcn/ui, while CodeMirror and editor-specific consumers derive any non-CSS-variable values from the same semantic contract
-4. **Theme mode commands**: Command-palette actions for light and dark mode call the same `saveSettings` path as the Settings panel and persist only `settings.theme_mode`
 
 ## Localization
 
@@ -677,8 +669,7 @@ No indexing step required — search runs directly against the filesystem.
 
 Per-vault settings stored locally and scoped by vault path:
 - Managed by `useVaultConfig` hook and `vaultConfigStore`
-- Settings: zoom, view mode, editor mode, note layout, tag colors, status colors, property display modes, Inbox/All Notes note-list column overrides, explicit organization workflow toggle, AI agent permission mode (`safe` / `power_user`)
-- Missing, null, and unknown AI agent permission modes normalize to `safe`; the AI panel can switch modes per vault, preserving the transcript and applying the new mode only to the next agent run
+- Settings: zoom, view mode, editor mode, note layout, tag colors, status colors, property display modes, Inbox/All Notes note-list column overrides, explicit organization workflow toggle
 - One-time migration from localStorage (`configMigration.ts`)
 
 ### AI Guidance Files
@@ -686,9 +677,8 @@ Per-vault settings stored locally and scoped by vault path:
 Tolaria tracks managed vault-level AI guidance separately from normal note content:
 - `AGENTS.md` is the canonical managed guidance file for Tolaria-aware coding agents
 - `CLAUDE.md` is a compatibility shim that points Claude Code back to `AGENTS.md`
-- `GEMINI.md` is an optional Gemini CLI compatibility shim that points Gemini back to `AGENTS.md`
 - `useVaultAiGuidanceStatus` reads `get_vault_ai_guidance_status` and normalizes the backend state into four UI cases: `managed`, `missing`, `broken`, and `custom`
-- `restore_vault_ai_guidance` repairs only Tolaria-managed files and creates the optional Gemini shim on explicit request; user-authored custom `AGENTS.md` / `CLAUDE.md` / `GEMINI.md` files are surfaced as custom and left untouched
+- `restore_vault_ai_guidance` repairs only Tolaria-managed files; user-authored custom `AGENTS.md` / `CLAUDE.md` files are surfaced as custom and left untouched
 - The status bar AI badge and command palette consume that abstraction to expose restore actions only when the managed guidance is missing or broken
 
 ### Getting Started / Onboarding
@@ -707,7 +697,7 @@ Tolaria tracks managed vault-level AI guidance separately from normal note conte
 `useAiAgentsOnboarding(enabled)` adds a separate first-launch agent step:
 - Reads a local dismissal flag for the AI agents prompt (with a legacy fallback to the older Claude-only key)
 - Only shows after vault onboarding has already resolved to a ready state
-- Uses `get_ai_agents_status`, whose backend treats the app process path, login-shell path, and supported local/toolchain/app install locations, including nvm-managed Node installs plus Windows `.exe` and npm/pnpm/Scoop shim paths, as valid CLI-agent sources
+- Uses `get_ai_agents_status`, whose backend treats the app process path, login-shell path, and supported local/toolchain/app install locations, including Windows `.exe` and npm/pnpm/Scoop shim paths, as valid CLI-agent sources
 - Persists dismissal locally once the user continues
 
 ### Remote Git Operations
@@ -741,7 +731,7 @@ interface Settings {
 }
 ```
 
-Managed by `useSettings` hook and `SettingsPanel` component. `theme_mode` is installation-local because it controls device comfort rather than vault structure; the Settings panel and command-palette light/dark actions both update that same value. `ui_language` is also installation-local: `null` follows the supported system language with English fallback, while explicit values pin the UI language for this installation. Stored legacy aliases such as `zh-Hans` are normalized to canonical locale codes before the setting reaches React state. `default_ai_agent` is an installation-local preference that selects which supported CLI agent the AI panel, command palette AI mode, and status bar should target by default. `hide_gitignored_files` is also installation-local and defaults to `true`; changing it reloads entries, search, saved views, and folders without restarting. The AutoGit fields are also installation-local: `useAutoGit` consumes them to schedule automatic checkpoints, while `useCommitFlow` and the status bar quick action reuse the same checkpoint runner and deterministic automatic commit message generation.
+Managed by `useSettings` hook and `SettingsPanel` component. `theme_mode` is installation-local because it controls device comfort rather than vault structure. `ui_language` is also installation-local: `null` follows the supported system language with English fallback, while explicit values pin the UI language for this installation. Stored legacy aliases such as `zh-Hans` are normalized to canonical locale codes before the setting reaches React state. `default_ai_agent` is an installation-local preference that selects which supported CLI agent the AI panel, command palette AI mode, and status bar should target by default. `hide_gitignored_files` is also installation-local and defaults to `true`; changing it reloads entries, search, saved views, and folders without restarting. The AutoGit fields are also installation-local: `useAutoGit` consumes them to schedule automatic checkpoints, while `useCommitFlow` and the status bar quick action reuse the same checkpoint runner and deterministic automatic commit message generation.
 
 ## Telemetry
 
@@ -753,9 +743,9 @@ Managed by `useSettings` hook and `SettingsPanel` component. `theme_mode` is ins
 - **`useTelemetry(settings, loaded)`** — Reactively initializes/tears down Sentry and PostHog based on settings. Called once in `App`.
 
 ### Libraries
-- **`src/lib/telemetry.ts`** — `initSentry()`, `teardownSentry()`, `initPostHog()`, `teardownPostHog()`, `trackEvent()`. Path scrubber via `beforeSend` hook. DSN/key from `VITE_SENTRY_DSN` and `VITE_POSTHOG_KEY`; `VITE_SENTRY_RELEASE` is treated as the build version and only becomes Sentry's `release` for stable calendar builds (`YYYY.M.D`). Alpha/prerelease/internal builds tag `tolaria.build_version` and `tolaria.release_kind` without creating normal Sentry Releases entries.
+- **`src/lib/telemetry.ts`** — `initSentry()`, `teardownSentry()`, `initPostHog()`, `teardownPostHog()`, `trackEvent()`. Path scrubber via `beforeSend` hook. DSN/release/key from `VITE_SENTRY_DSN`, `VITE_SENTRY_RELEASE`, and `VITE_POSTHOG_KEY` env vars.
 - **`src/main.tsx`** — React root error callbacks (`onCaughtError`, `onUncaughtError`, `onRecoverableError`) forward component-stack context to `Sentry.reactErrorHandler()` for debuggable production React errors.
-- **`src-tauri/src/telemetry.rs`** — Rust-side Sentry init with `beforeSend` path scrubber. `init_sentry_from_settings()` reads settings and conditionally initializes; stable calendar `CARGO_PKG_VERSION` values become Sentry releases, while alpha/prerelease/internal versions are kept as diagnostic tags only. `reinit_sentry()` for runtime toggle.
+- **`src-tauri/src/telemetry.rs`** — Rust-side Sentry init with `beforeSend` path scrubber. `init_sentry_from_settings()` reads settings and conditionally initializes. `reinit_sentry()` for runtime toggle.
 
 ### Tauri Commands
 - **`reinit_telemetry`** — Re-reads settings and toggles Rust Sentry on/off. Called from frontend when user changes crash reporting setting.
@@ -781,6 +771,6 @@ Managed by `useSettings` hook and `SettingsPanel` component. `theme_mode` is ins
 - **`download_and_install_app_update`** — Channel-aware download/install with streamed progress events.
 
 ### CI/CD
-- **`.github/workflows/release.yml`** — Alpha prereleases from every push to `main` using calendar-semver technical versions (`YYYY.M.D-alpha.N`) and clean `Alpha YYYY.M.D.N` release names. GitHub alpha tags zero-pad the prerelease sequence (`alpha-vYYYY.M.D-alpha.NNNN`) so GitHub release ordering stays chronological while the shipped app version remains `YYYY.M.D-alpha.N`. Publishes `alpha/latest.json` with macOS Apple Silicon/Intel, Linux x64, and Windows x64 updater entries, then refreshes the legacy `latest.json` / `latest-canary.json` aliases to the alpha feed. macOS release assets use `Tolaria_<version>_macOS_Silicon` and `Tolaria_<version>_macOS_Intel` base names. Packaged builds pass the computed version as `VITE_SENTRY_RELEASE`, which is retained as a diagnostic build-version tag but not registered as a normal Sentry release for alpha builds.
-- **`.github/workflows/release-stable.yml`** — Stable releases from `stable-vYYYY.M.D` tags. Publishes `stable/latest.json`, macOS Apple Silicon and Intel DMG/updater artifacts, Windows x64 installers/updater bundles, and Linux x86_64 `.deb` / AppImage artifacts. Stable macOS DMG/updater assets use the same `Tolaria_<version>_macOS_Silicon` and `Tolaria_<version>_macOS_Intel` base names. Packaged builds pass the computed stable version as `VITE_SENTRY_RELEASE`, which is registered as Sentry's release.
+- **`.github/workflows/release.yml`** — Alpha prereleases from every push to `main` using calendar-semver technical versions (`YYYY.M.D-alpha.N`) and clean `Alpha YYYY.M.D.N` release names. GitHub alpha tags zero-pad the prerelease sequence (`alpha-vYYYY.M.D-alpha.NNNN`) so GitHub release ordering stays chronological while the shipped app version remains `YYYY.M.D-alpha.N`. Publishes `alpha/latest.json` with macOS Apple Silicon/Intel, Linux x64, and Windows x64 updater entries, then refreshes the legacy `latest.json` / `latest-canary.json` aliases to the alpha feed. macOS release assets use `Tolaria_<version>_macOS_Silicon` and `Tolaria_<version>_macOS_Intel` base names. Packaged builds pass the computed version as `VITE_SENTRY_RELEASE`.
+- **`.github/workflows/release-stable.yml`** — Stable releases from `stable-vYYYY.M.D` tags. Publishes `stable/latest.json`, macOS Apple Silicon and Intel DMG/updater artifacts, Windows x64 installers/updater bundles, and Linux x86_64 `.deb` / AppImage artifacts. Stable macOS DMG/updater assets use the same `Tolaria_<version>_macOS_Silicon` and `Tolaria_<version>_macOS_Intel` base names. Packaged builds pass the computed version as `VITE_SENTRY_RELEASE`.
 - **Beta cohorts** are handled in PostHog targeting only. There is no beta updater feed.

docs/ARCHITECTURE.md

@@ -186,7 +186,7 @@ flowchart TD
 └──────────────────────────────────────────────────────────────┘
 ```
 
-- **Sidebar** (150-400px, resizable): Top-level filters (All Notes, Changes, Pulse), saved Views, collapsible type-based section groups, and a dedicated folder tree. The folder tree shows user-created folders plus default vault folders such as `attachments/` and `views/`; only the dedicated `type/` directory stays hidden because note types already have their own sidebar section. Saved Views persist a top-level YAML `order` field in each view file and use the same ordered-list mental model as Types: pointer users can drag the handle, while keyboard users can use explicit move buttons or command-palette move actions. The folder tree supports inline folder creation and rename, exposes a right-click menu for rename/delete plus filesystem reveal/copy-path actions, and auto-expands ancestor folders when the current selection or rename target is nested. Type sections and folder rows also act as note drop targets: dropping a note on a type updates its `type:` frontmatter, while dropping it on a folder runs the same crash-safe move path as the command palette flow. Each type can have a custom icon, color, sort, and visibility set via its type document in `type/`.
+- **Sidebar** (150-400px, resizable): Top-level filters (All Notes, Changes, Pulse), collapsible type-based section groups, and a dedicated folder tree. The folder tree shows user-created folders plus default vault folders such as `attachments/` and `views/`; only the dedicated `type/` directory stays hidden because note types already have their own sidebar section. The folder tree supports inline folder creation and rename, exposes a right-click menu for rename/delete plus filesystem reveal/copy-path actions, and auto-expands ancestor folders when the current selection or rename target is nested. Type sections and folder rows also act as note drop targets: dropping a note on a type updates its `type:` frontmatter, while dropping it on a folder runs the same crash-safe move path as the command palette flow. Each type can have a custom icon, color, sort, and visibility set via its type document in `type/`.
 - **Note List / Pulse View** (200-500px, resizable): When a section group, filter, or saved view is selected, shows filtered notes with snippets, modified dates, status indicators, and per-context note-list controls. When `selection.kind === 'entity'`, the same pane enters **Neighborhood** mode: the source note is pinned at the top as a normal active row, outgoing relationship groups render first, inverse/backlink groups follow, empty groups stay visible with `0`, and duplicates across groups are allowed when multiple relationships are true. Plain click / `Enter` open the focused note without replacing the current Neighborhood, while Cmd/Ctrl-click and Cmd/Ctrl-`Enter` pivot the pane into the clicked note's Neighborhood. Folder-backed lists also show non-Markdown files: previewable image binaries get an image indicator and open in the editor pane, while unsupported binaries remain muted instead of auto-launching an external app. Saved views reuse the same sort and visible-column controls as the built-in lists, and those changes persist back into the view `.yml` definition (`sort`, `listPropertiesDisplay`). When Pulse filter is active, shows `PulseView` — a chronological git activity feed grouped by day.
 - **Editor** (flex, fills remaining space): Single note open at a time (no tabs — see ADR-0003). Breadcrumb bar with word count and note-layout toggle, BlockNote rich text editor with wikilink support, Markdown-compatible inline/display math rendering, first-class Mermaid diagram blocks, markdown-safe formatting controls, and schema-backed fenced code block highlighting via `@blocknote/code-block`. Can toggle to diff view (modified files), raw CodeMirror view, or a wide-screen left-aligned note column while preserving the same readable max width. Binary image files render through `FilePreview` as ordinary vault files using Tauri asset URLs, with explicit unsupported/broken fallback states and keyboard focus returning to the note list on `Escape`. Decomposed into `Editor` (orchestrator), `EditorContent`, `FilePreview`, `EditorRightPanel`, `SingleEditorView`, with hooks `useDiffMode`, `useEditorFocus`, and `useEditorSave`, plus the `useRawMode`/`RawEditorView` pair for markdown source editing. Rich BlockNote input and raw CodeMirror input both route typed `->`, `<-`, and `<->` through the shared `src/utils/arrowLigatures.ts` resolver so arrow ligatures stay consistent across mode switches while escaped ASCII sequences remain literal. Navigation history (Cmd+[/]) replaces tabs.
 - **Inspector / AI Agent** (200-500px or 40px collapsed): Toggles between Inspector (frontmatter, relationships, instances, backlinks, git history) and AI Agent panel (the selected CLI agent with tool execution). The Sparkle icon in the breadcrumb bar toggles between them. Per-note `icon` is a suggested Inspector property and the command palette's "Set Note Icon" action opens that field directly. When viewing a Type note, the Inspector shows an **Instances** section listing all notes of that type (sorted by modified_at desc, capped at 50).
@@ -224,13 +224,12 @@ Notes can be opened in separate Tauri windows for focused editing. Secondary win
 
 Full agent mode — spawns the selected local CLI agent as a subprocess with tool access and MCP vault integration.
 
-1. **Frontend** (`AiPanel` + `useCliAiAgent` + `aiAgentSession.ts` + `aiAgents.ts`) — one normalized session lifecycle for message state, reasoning blocks, tool action cards, response display, onboarding, default-agent selection, and the per-vault Safe / Power User permission mode shown in the panel header
-2. **Backend orchestration** (`ai_agents.rs`) — normalizes agent availability, streaming, and the request permission mode before dispatching to per-agent adapters
-3. **Shared runtime scaffold** (`cli_agent_runtime.rs`) — owns the common request shape, prompt wrapping, JSON-line subprocess lifecycle, normalized error/done handling, version probing, and Tolaria MCP server path resolution used by app-managed CLI agents
-4. **Agent adapters** — Claude Code still uses `claude_cli.rs` with `acceptEdits`, strict Tolaria MCP config, and a scoped tool list: Safe enables file/search/edit tools, while Power User adds Bash without using dangerous bypass flags. Codex runtime specifics live in `codex_cli.rs` and run through `codex --sandbox workspace-write --ask-for-approval never exec --json` in both modes. OpenCode runs through `opencode run --format json` with transient permissions: Safe denies bash and external directories, while Power User allows bash but still denies external directories. Pi runs through `pi --mode json --no-session` with `npm:pi-mcp-adapter`; both modes currently share the same transient MCP config. OpenCode and Pi both launch from the active vault cwd with closed stdin and transient MCP config. All app-launched paths use hidden Windows launches and avoid dangerous permission-bypass flags.
-5. **MCP Integration** — Claude receives the generated MCP config file path, Codex receives the same Tolaria MCP server via transient `-c mcp_servers.tolaria.*` config overrides, OpenCode receives it through `OPENCODE_CONFIG_CONTENT`, and Pi receives it through a temporary `PI_CODING_AGENT_DIR/mcp.json` consumed by `pi-mcp-adapter`
+1. **Frontend** (`AiPanel` + `useCliAiAgent` + `aiAgentSession.ts` + `aiAgents.ts`) — one normalized session lifecycle for message state, reasoning blocks, tool action cards, response display, onboarding, and default-agent selection
+2. **Backend** (`ai_agents.rs`) — normalizes agent availability and streaming, dispatching to per-agent adapters
+3. **Agent adapters** — Claude Code still uses `claude_cli.rs` with `acceptEdits`, strict Tolaria MCP config, a file/search-only built-in tool list, hidden Windows subprocess launches, and closed stdin for print-mode subprocesses so Windows launches receive EOF; Codex runs through `codex --sandbox workspace-write --ask-for-approval never exec --json`; OpenCode runs through `opencode run --format json`; Pi runs through `pi --mode json --no-session` with `npm:pi-mcp-adapter`. OpenCode and Pi both launch from the active vault cwd with closed stdin and transient MCP config. All app-launched paths use hidden Windows launches and avoid dangerous permission-bypass flags.
+4. **MCP Integration** — Claude receives the generated MCP config file path, Codex receives the same Tolaria MCP server via transient `-c mcp_servers.tolaria.*` config overrides, OpenCode receives it through `OPENCODE_CONFIG_CONTENT`, and Pi receives it through a temporary `PI_CODING_AGENT_DIR/mcp.json` consumed by `pi-mcp-adapter`
 
-CLI-agent availability intentionally does not depend only on the desktop app's inherited `PATH`. The detectors check the current process path, the user's login shell, and supported local/toolchain install locations such as native `~/.local/bin`, local `~/.claude/local`, Mise/asdf shims, nvm-managed Node installs, npm-global, Homebrew, Windows `%APPDATA%\npm`/pnpm/Scoop shims, Windows `.exe` launchers, and the macOS Codex app resource path so first-run onboarding works on fresh macOS and Windows installs.
+CLI-agent availability intentionally does not depend only on the desktop app's inherited `PATH`. The detectors check the current process path, the user's login shell, and supported local/toolchain install locations such as native `~/.local/bin`, local `~/.claude/local`, Mise/asdf shims, npm-global, Homebrew, Windows `%APPDATA%\npm`/pnpm/Scoop shims, Windows `.exe` launchers, and the macOS Codex app resource path so first-run onboarding works on fresh macOS and Windows installs.
 
 #### Agent Event Flow
 
@@ -244,7 +243,7 @@ sequenceDiagram
 
     U->>FE: sendMessage(text, references)
     FE->>FE: buildContextSnapshot(activeNote, linkedNotes, openTabs)
-    FE->>R: invoke('stream_ai_agent', {agent, message, systemPrompt, vaultPath, permissionMode})
+    FE->>R: invoke('stream_ai_agent', {agent, message, systemPrompt, vaultPath})
     R->>R: pick adapter for claude_code, codex, opencode, or pi
     R->>C: spawn agent with MCP-enabled config
 
@@ -295,7 +294,7 @@ Each CLI agent authenticates itself outside Tolaria. Claude Code uses its existi
 
 ## MCP Server
 
-The MCP server (`mcp-server/`) exposes vault operations as tools for AI assistants (Claude Code, Gemini CLI, Cursor, or any MCP-compatible client).
+The MCP server (`mcp-server/`) exposes vault operations as tools for AI assistants (Claude Code, Cursor, or any MCP-compatible client).
 
 ### Tool Surface (14 tools)
 
@@ -327,11 +326,10 @@ The MCP server (`mcp-server/`) exposes vault operations as tools for AI assistan
 
 Tolaria can register itself as an MCP server in:
 - `~/.claude.json` and `~/.claude/mcp.json` (Claude Code compatibility across current CLI and legacy MCP-file setups)
-- `~/.gemini/settings.json` (Gemini CLI)
 - `~/.cursor/mcp.json` (Cursor)
 - `~/.config/mcp/mcp.json` (generic MCP-compatible clients)
 
-That setup is user-initiated through the status bar / command palette flow, not a startup side effect. Registration is non-destructive (additive, preserves other servers and Gemini settings), uses `upsert` semantics, and can be reversed by removing Tolaria's entry again. Tolaria verifies Node.js is available before writing config, writes an explicit `type: "stdio"` entry, pins `VAULT_PATH` to the active vault, and sets `WS_UI_PORT=9711` so UI actions route back to the desktop app. The same generated entry is exposed as a manual JSON snippet in the MCP setup dialog and through the AI panel copy action, giving users a transparent fallback for MCP-compatible tools Tolaria does not auto-configure. Packaged builds resolve `mcp-server/` from the installed resource directory next to the executable before falling back to macOS `Resources`, Linux bundle paths, and AppImage paths. The `useMcpStatus` hook tracks whether the active vault is explicitly connected (`checking | installed | not_installed`) and owns connect, disconnect, exact-snippet load, and copy-to-clipboard actions. Gemini CLI still owns its own install and sign-in; Tolaria only writes the MCP entry and optional vault guidance shim. The desktop WebSocket bridge is started only when a persisted active vault exists and is resynced from React state on vault changes; no selected vault stops the bridge instead of falling back to `~/Laputa`. Stdio MCP server processes are owned by the external client that launched them: when that client closes stdin, Tolaria cancels UI-bridge reconnect timers, closes any UI WebSocket, and exits the Node process instead of keeping it alive in the background.
+That setup is user-initiated through the status bar / command palette flow, not a startup side effect. Registration is non-destructive (additive, preserves other servers), uses `upsert` semantics, and can be reversed by removing Tolaria's entry again. Tolaria verifies Node.js is available before writing config, writes an explicit `type: "stdio"` entry, pins `VAULT_PATH` to the active vault, and sets `WS_UI_PORT=9711` so UI actions route back to the desktop app. Packaged builds resolve `mcp-server/` from the installed resource directory next to the executable before falling back to macOS `Resources`, Linux bundle paths, and AppImage paths. The `useMcpStatus` hook tracks whether the active vault is explicitly connected (`checking | installed | not_installed`). The desktop WebSocket bridge is started only when a persisted active vault exists and is resynced from React state on vault changes; no selected vault stops the bridge instead of falling back to `~/Laputa`.
 
 ### Architecture
 
@@ -378,12 +376,11 @@ flowchart LR
 |----------|---------|
 | `spawn_ws_bridge(vault_path)` | Spawns `ws-bridge.js` as child process with VAULT_PATH env |
 | `sync_mcp_bridge_vault(vault_path?)` | Starts, restarts, or stops the desktop WebSocket bridge as the selected vault changes |
-| `register_mcp(vault_path)` | Verifies Node.js, resolves the packaged `mcp-server/`, and writes Tolaria's explicit stdio entry to Claude Code, Gemini CLI, Cursor, and generic MCP configs on user request |
-| `mcp_config_snippet(vault_path)` | Builds the exact `mcpServers.tolaria` JSON users can copy into any compatible client without writing third-party config files |
-| `remove_mcp()` | Removes Tolaria's MCP entry from Claude Code, Gemini CLI, Cursor, and generic MCP configs |
+| `register_mcp(vault_path)` | Verifies Node.js, resolves the packaged `mcp-server/`, and writes Tolaria's explicit stdio entry to Claude Code, Cursor, and generic MCP configs on user request |
+| `remove_mcp()` | Removes Tolaria's MCP entry from Claude Code, Cursor, and generic MCP configs |
 | `upsert_mcp_config(path, entry)` | Atomic config file update (create/merge, preserves others) |
 
-The `WsBridgeChild` state wrapper in `lib.rs` ensures the bridge process is replaced on vault switches, stopped when no active vault is selected, and killed plus waited on app exit via the `RunEvent::Exit` handler. The same desktop layer now keeps the Tauri asset protocol scoped to the active vault instead of every filesystem path.
+The `WsBridgeChild` state wrapper in `lib.rs` ensures the bridge process is replaced on vault switches, stopped when no active vault is selected, and killed on app exit via the `RunEvent::Exit` handler. The same desktop layer now keeps the Tauri asset protocol scoped to the active vault instead of every filesystem path.
 
 ## Search
 
@@ -428,7 +425,7 @@ The app uses internal app-owned light and dark themes (see [ADR-0081](adr/0081-i
 
 1. **Global CSS variables** (`src/index.css`): Semantic app colors, borders, surfaces, and interaction states. Bridged to Tailwind v4 via `@theme inline`.
 2. **Editor theme** (`src/theme.json`): BlockNote-specific typography. Flattened to CSS vars by `useEditorTheme`; editor colors resolve through the same semantic app variables.
-3. **Theme runtime**: Applies `data-theme` and the shadcn-compatible `.dark` class before React consumers render, with a localStorage mirror to avoid startup flash when dark mode is selected. Settings and command-palette theme actions both write the same installation-local `settings.theme_mode` value.
+3. **Theme runtime**: Applies `data-theme` and the shadcn-compatible `.dark` class before React consumers render, with a localStorage mirror to avoid startup flash when dark mode is selected.
 
 ## Localization
 
@@ -479,7 +476,7 @@ Once a vault is ready, `useAiAgentsOnboarding` can show a one-time `AiAgentsOnbo
 
 `useGettingStartedClone` reuses the same parent-folder semantics for the status-bar / command-palette clone action, and `Toast` is rendered through the AI-agents onboarding gate so the resolved destination path stays visible right after a successful clone.
 
-The starter content no longer lives in the app repo. `src-tauri/src/vault/getting_started.rs` holds the public starter repo URL (`refactoringhq/tolaria-getting-started`), delegates the clone to the git backend, then normalizes Tolaria-managed root guidance and type scaffolding (`AGENTS.md`, `CLAUDE.md`, `type.md`, `note.md`) so fresh starter vaults pick up the current defaults even when the remote starter repo still carries a legacy copy or an older pre-`type:` `is_a`-era template. `AGENTS.md` stays the canonical vault guidance file; `CLAUDE.md` is a compatibility shim that imports it for Claude Code without duplicating the instructions, and Tolaria seeds it as an organized `Note` so it stays out of the way in a fresh vault. Optional `GEMINI.md` guidance is created only by the explicit AI guidance restore action. The clone helper still accepts the legacy `LAPUTA_GETTING_STARTED_REPO_URL` environment override so older automation can continue to redirect the starter source during the transition.
+The starter content no longer lives in the app repo. `src-tauri/src/vault/getting_started.rs` holds the public starter repo URL (`refactoringhq/tolaria-getting-started`), delegates the clone to the git backend, then normalizes Tolaria-managed root guidance and type scaffolding (`AGENTS.md`, `CLAUDE.md`, `type.md`, `note.md`) so fresh starter vaults pick up the current defaults even when the remote starter repo still carries a legacy copy or an older pre-`type:` `is_a`-era template. `AGENTS.md` stays the canonical vault guidance file; `CLAUDE.md` is a compatibility shim that imports it for Claude Code without duplicating the instructions, and Tolaria seeds it as an organized `Note` so it stays out of the way in a fresh vault. The clone helper still accepts the legacy `LAPUTA_GETTING_STARTED_REPO_URL` environment override so older automation can continue to redirect the starter source during the transition.
 
 After the clone completes, Tolaria removes every configured git remote from the new starter vault. Getting Started vaults therefore open as local-only by default, and users opt into a remote later with the explicit Add Remote flow.
 
@@ -628,7 +625,7 @@ The vault backend (`src-tauri/src/vault/`) is split into focused submodules:
 | `rename.rs` | `rename_note` / `rename_note_filename` / `move_note_to_folder` — stage crash-safe file moves, update `title` frontmatter when needed, recover unfinished rename transactions, and report backlink rewrite failures |
 | `image.rs` | `save_image` / `copy_image_to_vault` — save editor image attachments with sanitized filenames |
 | `migration.rs` | `flatten_vault`, `vault_health_check`, `migrate_is_a_to_type` |
-| `config_seed.rs` | Maintains vault AI guidance (`AGENTS.md`, `CLAUDE.md`, and optional `GEMINI.md` shims), migrates legacy `config/agents.md`, and repairs missing root type scaffolding such as `type.md` and `note.md` |
+| `config_seed.rs` | Maintains vault AI guidance (`AGENTS.md` + `CLAUDE.md` shim), migrates legacy `config/agents.md`, and repairs missing root type scaffolding such as `type.md` and `note.md` |
 | `getting_started.rs` | Clones and normalizes the public Getting Started starter vault |
 
 ## Rust Backend Modules
@@ -639,9 +636,8 @@ The vault backend (`src-tauri/src/vault/`) is split into focused submodules:
 | `frontmatter/` | YAML frontmatter read/write (`mod.rs`, `yaml.rs`, `ops.rs`) |
 | `git/` | Git operations (`commit.rs`, `status.rs`, `history.rs`, `conflict.rs`, `remote.rs`, `pulse.rs`, `clone.rs`, `connect.rs`) |
 | `search.rs` | Keyword search — walkdir-based vault file scan with Gitignored-content visibility filtering |
-| `ai_agents.rs` | CLI-agent request normalization and adapter dispatch |
-| `cli_agent_runtime.rs` | Shared CLI-agent request, prompt, subprocess, version, and MCP path helpers |
-| `claude_cli.rs`, `codex_cli.rs`, `opencode_cli.rs` | Claude Code, Codex, and OpenCode command/config/event adapters |
+| `ai_agents.rs` | Shared CLI-agent detection, stream normalization, and adapter dispatch |
+| `claude_cli.rs` | Claude Code subprocess spawning + NDJSON stream parsing |
 | `pi_cli.rs`, `pi_config.rs`, `pi_discovery.rs`, `pi_events.rs` | Pi subprocess launch, transient MCP adapter config, discovery, and JSON stream parsing |
 | `mcp.rs` | MCP server spawning + explicit config registration/removal |
 | `commands/` | Tauri command handlers (split into submodules) |
@@ -674,7 +670,7 @@ The vault backend (`src-tauri/src/vault/`) is split into focused submodules:
 | `check_vault_exists` | Check if vault path exists |
 | `create_empty_vault` | Create a git-backed vault, then seed root `AGENTS.md`, `CLAUDE.md`, `type.md`, and `note.md` defaults |
 | `create_getting_started_vault` | Clone the public Getting Started vault, refresh Tolaria-managed guidance/config defaults, and keep the cloned repo clean |
-| `get_vault_ai_guidance_status` | Report whether `AGENTS.md`, `CLAUDE.md`, and optional `GEMINI.md` guidance are managed, missing, broken, or custom |
+| `get_vault_ai_guidance_status` | Report whether `AGENTS.md` and the `CLAUDE.md` shim are managed, missing, broken, or custom |
 | `restore_vault_ai_guidance` | Restore any missing/broken Tolaria-managed guidance files without overwriting custom ones |
 
 ### Frontmatter
@@ -728,10 +724,9 @@ The vault backend (`src-tauri/src/vault/`) is split into focused submodules:
 | `check_claude_cli` | Check if Claude CLI is available |
 | `get_ai_agents_status` | Check Claude Code + Codex + OpenCode + Pi availability |
 | `stream_ai_agent` | Stream Claude Code, Codex, OpenCode, or Pi through the normalized agent event layer |
-| `register_mcp_tools` | Register MCP in Claude/Gemini/Cursor/generic config for the active vault |
-| `remove_mcp_tools` | Remove Tolaria's MCP entry from Claude/Gemini/Cursor/generic config |
-| `check_mcp_status` | Check whether the active vault is explicitly registered in Claude/Gemini/Cursor/generic config |
-| `get_mcp_config_snippet` | Return the exact manual MCP JSON snippet for the active vault |
+| `register_mcp_tools` | Register MCP in Claude/Cursor/generic config for the active vault |
+| `remove_mcp_tools` | Remove Tolaria's MCP entry from Claude/Cursor/generic config |
+| `check_mcp_status` | Check whether the active vault is explicitly registered in Claude/Cursor/generic config |
 | `sync_mcp_bridge_vault` | Sync the desktop WebSocket bridge process to the selected vault, or stop it when no vault is selected |
 
 The desktop MCP WebSocket bridge is intentionally local-only. `mcp-server/ws-bridge.js` binds both bridge ports to loopback, rejects non-loopback clients, accepts browser/Tauri origins only on the UI bridge, and rejects browser-origin requests on the tool bridge so remote pages cannot drive vault tools directly.
@@ -790,14 +785,14 @@ No Redux or global context. State lives in the root `App.tsx` and custom hooks:
 | `useTabManagement` | Navigation history, note switching | Note navigation lifecycle |
 | `useVaultSwitcher` | `vaultPath`, `extraVaults` | Vault switching |
 | `useTheme` | Editor theme CSS vars and theme-mode bridge | Editor typography and app theme runtime |
-| `useCliAiAgent` | `messages`, `status`, tool actions | Selected AI agent conversation backed by the shared session pipeline and vault permission mode |
+| `useCliAiAgent` | `messages`, `status`, tool actions | Selected AI agent conversation backed by the shared session pipeline |
 | `useAutoSync` | Sync interval, pull/push state | Git auto-sync |
 | `useAutoGit` | Last activity timestamp, idle/inactive checkpoint triggers | Automatic commit/push checkpoints |
 | `useCommitFlow` | Commit dialog state, shared manual/automatic checkpoint runner | Git commit/push orchestration |
 | `useGitRemoteStatus` | `remoteStatus`, `refreshRemoteStatus()` | On-demand remote detection for commit UI |
 | `useUnifiedSearch` | Query, results, loading state | Keyword search |
 | `useSettings` | App settings (telemetry, release channel, theme mode, UI language, auto-sync interval, AutoGit thresholds, default AI agent, Gitignored-content visibility) | Persistent settings |
-| `useVaultConfig` | Per-vault UI preferences, AI permission mode | Vault-specific config |
+| `useVaultConfig` | Per-vault UI preferences | Vault-specific config |
 | `appCommandDispatcher` | Canonical shortcut/menu command IDs | Shared execution path for renderer and native menu commands |
 
 Data flows unidirectionally: `App` passes data and callbacks as props to child components. No child-to-child communication — everything goes through `App`.
@@ -947,7 +942,7 @@ sequenceDiagram
 **Architecture:**
 - **Rust:** `sentry` crate initialized in `lib.rs::setup()` via `telemetry::init_sentry_from_settings()`
 - **JS:** `@sentry/react` + `posthog-js` initialized lazily by `useTelemetry` hook; the React root also wires `onCaughtError`, `onUncaughtError`, and `onRecoverableError` through `Sentry.reactErrorHandler()` so production React invariants include component stack context when crash reporting is enabled.
-- **Release grouping:** packaged release workflows pass `VITE_SENTRY_RELEASE` from the computed build version, but the app only assigns Sentry's `release` field for stable calendar builds (`YYYY.M.D`). Alpha/prerelease/internal builds omit `release` so they do not create normal Sentry Releases entries, while both frontend and Rust Sentry scopes tag `tolaria.build_version` and `tolaria.release_kind` for diagnostics.
+- **Release grouping:** packaged release workflows pass `VITE_SENTRY_RELEASE` from the computed build version so frontend Sentry events group by the shipped alpha or stable version.
 - **Settings:** `telemetry_consent`, `crash_reporting_enabled`, `analytics_enabled`, `anonymous_id` in `Settings` struct
 - **Consent:** `TelemetryConsentDialog` shown when `telemetry_consent === null`
 

docs/GETTING-STARTED.md

@@ -79,7 +79,7 @@ tolaria/
 │   │   ├── RawEditorView.tsx     # CodeMirror raw editor
 │   │   ├── Inspector.tsx         # Fourth panel: metadata + relationships
 │   │   ├── DynamicPropertiesPanel.tsx  # Editable frontmatter properties
-│   │   ├── AiPanel.tsx           # AI agent panel (selected CLI agent + per-vault permission mode)
+│   │   ├── AiPanel.tsx           # AI agent panel (selected CLI agent)
 │   │   ├── AiMessage.tsx         # Agent message display
 │   │   ├── AiActionCard.tsx      # Agent tool action cards
 │   │   ├── AiAgentsOnboardingPrompt.tsx # First-launch AI agent installer prompt
@@ -114,7 +114,6 @@ tolaria/
 │   │   ├── useNoteCreation.ts    # Note/type creation
 │   │   ├── useNoteRename.ts     # Note renaming + wikilink updates
 │   │   ├── useCliAiAgent.ts      # Selected AI agent state + normalized session pipeline
-│   │   ├── aiAgentPermissionMode.ts # Safe/Power User mode normalization + labels
 │   │   ├── useAiAgentsStatus.ts  # Claude/Codex/OpenCode/Pi availability polling
 │   │   ├── useAiAgentPreferences.ts # Default-agent persistence + cycling
 │   │   ├── useAiActivity.ts      # MCP UI bridge listener
@@ -189,11 +188,9 @@ tolaria/
 │   │   │   ├── conflict.rs, remote.rs, pulse.rs
 │   │   ├── telemetry.rs          # Sentry init + path scrubber
 │   │   ├── search.rs             # Keyword search (walkdir-based)
-│   │   ├── ai_agents.rs          # CLI-agent request normalization + adapter dispatch
-│   │   ├── cli_agent_runtime.rs  # Shared CLI-agent runtime process/prompt/MCP helpers
-│   │   ├── claude_cli.rs         # Claude CLI adapter
-│   │   ├── codex_cli.rs          # Codex CLI adapter
-│   │   ├── pi_cli.rs             # Pi CLI adapter
+│   │   ├── ai_agents.rs          # Shared CLI-agent detection + stream adapters
+│   │   ├── claude_cli.rs         # Claude CLI subprocess management
+│   │   ├── pi_cli.rs             # Pi CLI subprocess management
 │   │   ├── mcp.rs                # MCP server lifecycle + explicit config registration/removal
 │   │   ├── app_updater.rs        # Alpha/stable updater endpoint selection
 │   │   ├── settings.rs           # App settings persistence
@@ -264,9 +261,9 @@ tolaria/
 | `src-tauri/src/frontmatter/ops.rs` | YAML manipulation — how properties are updated/deleted in files. |
 | `src-tauri/src/git/` | All git operations (clone, commit, pull, push, conflicts, pulse, add-remote). |
 | `src-tauri/src/search.rs` | Keyword search — scans vault files with walkdir. |
-| `src-tauri/src/ai_agents.rs` | CLI-agent request normalization, availability aggregation, adapter dispatch, and Claude event mapping. |
-| `src-tauri/src/cli_agent_runtime.rs` | Shared CLI-agent request shape, prompt wrapping, JSON subprocess lifecycle, version probing, and MCP path helpers. |
-| `src-tauri/src/claude_cli.rs`, `src-tauri/src/codex_cli.rs`, `src-tauri/src/opencode_cli.rs`, `src-tauri/src/pi_cli.rs` | Per-agent command, config, discovery, and JSON event adapters. |
+| `src-tauri/src/ai_agents.rs` | Shared CLI-agent availability checks, adapter dispatch, and stream normalization. |
+| `src-tauri/src/claude_cli.rs` | Claude CLI subprocess spawning + NDJSON stream parsing. |
+| `src-tauri/src/pi_cli.rs` | Pi subprocess spawning through JSON mode and transient MCP adapter config. |
 | `src-tauri/src/app_updater.rs` | Desktop updater bridge — selects alpha/stable manifests and streams install progress. |
 
 ### Editor
@@ -285,10 +282,9 @@ tolaria/
 
 | File | Why it matters |
 |------|---------------|
-| `src/components/AiPanel.tsx` | AI agent panel — selected CLI agent with tool execution, reasoning, actions, and per-vault permission mode. |
+| `src/components/AiPanel.tsx` | AI agent panel — selected CLI agent with tool execution, reasoning, and actions. |
 | `src/hooks/useCliAiAgent.ts` | Thin React owner for the selected CLI agent session state. |
 | `src/lib/aiAgentSession.ts` | Single message/session lifecycle for prompt normalization, history, streaming, and reset behavior. |
-| `src/lib/aiAgentPermissionMode.ts` | Safe/Power User mode normalization, display labels, and local transcript marker text. |
 | `src/lib/aiAgentFileOperations.ts` | Detects agent-created or modified vault files from normalized tool inputs. |
 | `src/lib/aiAgents.ts` | Supported agent definitions, status normalization, and default-agent helpers. |
 | `src/utils/ai-context.ts` | Context snapshot builder for AI conversations. |
@@ -308,7 +304,7 @@ tolaria/
 | `src/lib/releaseChannel.ts` | Normalizes persisted updater-channel values (`stable` default, optional `alpha`). |
 | `src/lib/appUpdater.ts` | Frontend wrapper for channel-aware updater commands. |
 | `src/hooks/useMainWindowSizeConstraints.ts` | Derives the main-window minimum width from the visible panes and asks Tauri to grow back to fit wider layouts. |
-| `src/hooks/useVaultConfig.ts` | Per-vault local UI preferences (zoom, view mode, colors, Inbox columns, explicit organization workflow, AI permission mode). |
+| `src/hooks/useVaultConfig.ts` | Per-vault local UI preferences (zoom, view mode, colors, Inbox columns, explicit organization workflow). |
 | `src/components/SettingsPanel.tsx` | Settings UI for telemetry, release channel, sync interval, UI language, default AI agent, and the vault-level explicit organization toggle. |
 | `src/hooks/useUpdater.ts` | In-app updates using the selected alpha/stable feed. |
 
@@ -345,7 +341,7 @@ type SidebarSelection =
 
 ### Command Registry
 
-`useCommandRegistry` + `useAppCommands` build a centralized command registry. Commands are registered with labels, shortcuts, and handlers. The `CommandPalette` (Cmd+K) fuzzy-searches this registry. Settings commands can update installation-local preferences directly when they reuse an existing settings path, such as the light/dark theme-mode actions writing `settings.theme_mode`. Shortcut combos live in `appCommandCatalog.ts`; real keypresses always flow through `useAppKeyboard`, native menu clicks emit the same command IDs through `useMenuEvents`, and `appCommandDispatcher.ts` suppresses the duplicate native/renderer echo from a single shortcut. On macOS, any browser-reserved chord that WKWebView swallows before that path must also be added to the narrow `tauri-plugin-prevent-default` registration in `src-tauri/src/lib.rs`. On Linux, `LinuxTitlebar.tsx` and `LinuxMenuButton.tsx` reuse the same command IDs through `trigger_menu_command` because the native GTK menu bar is intentionally not mounted. The same shortcut manifest also declares the deterministic QA mode for each shortcut-capable command.
+`useCommandRegistry` + `useAppCommands` build a centralized command registry. Commands are registered with labels, shortcuts, and handlers. The `CommandPalette` (Cmd+K) fuzzy-searches this registry. Shortcut combos live in `appCommandCatalog.ts`; real keypresses always flow through `useAppKeyboard`, native menu clicks emit the same command IDs through `useMenuEvents`, and `appCommandDispatcher.ts` suppresses the duplicate native/renderer echo from a single shortcut. On macOS, any browser-reserved chord that WKWebView swallows before that path must also be added to the narrow `tauri-plugin-prevent-default` registration in `src-tauri/src/lib.rs`. On Linux, `LinuxTitlebar.tsx` and `LinuxMenuButton.tsx` reuse the same command IDs through `trigger_menu_command` because the native GTK menu bar is intentionally not mounted. The same shortcut manifest also declares the deterministic QA mode for each shortcut-capable command.
 
 Commands whose availability depends on the current note or Git state must also flow through `update_menu_state` so the native menu stays in sync with the command palette. The deleted-note restore action in Changes view is the reference example: the row opens a deleted diff preview, the command palette exposes "Restore Deleted Note", and the Note menu enables the same action only while that preview is active.
 
@@ -424,14 +420,11 @@ BASE_URL="http://localhost:5173" npx playwright test tests/smoke/<slug>.spec.ts
 1. **Agent system prompt**: Edit `src/utils/ai-agent.ts` (inline system prompt string)
 2. **Context building**: Edit `src/utils/ai-context.ts` for what data is sent to the agent
 3. **Tool action display**: Edit `src/components/AiActionCard.tsx`
-4. **Permission-mode UI and request plumbing**: Edit `src/lib/aiAgentPermissionMode.ts`, `src/components/AiPanel*.tsx`, `src/hooks/useCliAiAgent.ts`, and `src/utils/streamAiAgent.ts`
-5. **Shared CLI runtime behavior**: Edit `src-tauri/src/cli_agent_runtime.rs` for process lifecycle, prompt wrapping, version probing, and common Tolaria MCP path handling.
-6. **Agent-specific arguments/events**: Edit the per-agent adapter modules (`claude_cli.rs`, `codex_cli.rs`, `opencode_*`, `pi_*`). Keep Codex sandboxed with active-vault `workspace-write`, keep Pi on transient MCP config, and do not use dangerous permission bypasses unless an ADR explicitly designs a new mode.
+4. **Claude CLI arguments**: Edit `src-tauri/src/claude_cli.rs` (`run_agent_stream()`; keep app-managed launches on strict Tolaria MCP config, `acceptEdits`, and the scoped file/search tool list)
+5. **Shared agent adapters / Codex/Pi args**: Edit `src-tauri/src/ai_agents.rs` plus the per-agent adapter modules (keep Codex sandboxed with active-vault `workspace-write`, keep Pi on transient MCP config, and do not use dangerous permission bypasses unless an ADR explicitly designs a new mode)
 
 ### Work with external MCP setup
 
-1. **Backend registration/status/snippets**: Edit `src-tauri/src/mcp.rs`; registration and manual config generation must verify Node.js first, resolve the packaged `mcp-server/` for macOS, Windows, Linux, and AppImage installs, and use an explicit stdio entry with `VAULT_PATH` plus `WS_UI_PORT=9711`
-2. **Setup dialog copy/actions**: Edit `src/components/McpSetupDialog.tsx` and `src/hooks/useMcpStatus.ts`; users should see the Node.js prerequisite, the exact generated manual config, and a copy action before Tolaria writes third-party config files
+1. **Backend registration/status**: Edit `src-tauri/src/mcp.rs`; registration must verify Node.js first, resolve the packaged `mcp-server/` for macOS, Windows, Linux, and AppImage installs, and write an explicit stdio entry with `VAULT_PATH` plus `WS_UI_PORT=9711`
+2. **Setup dialog copy/actions**: Edit `src/components/McpSetupDialog.tsx`; users should see the Node.js prerequisite and the manual config shape before Tolaria writes third-party config files
 3. **Status hook/toasts**: Edit `src/hooks/useMcpStatus.ts` when setup, reconnect, disconnect, or failure messaging changes
-4. **Gemini CLI compatibility**: Keep `~/.gemini/settings.json` in the registration path list and keep optional `GEMINI.md` generation behind `restore_vault_ai_guidance`; Gemini itself still needs its own install and sign-in outside Tolaria
-5. **Process lifecycle**: Stdio MCP servers in `mcp-server/index.js` must exit when their external client closes stdin, and the desktop-owned `ws-bridge.js` child must be stopped on vault deselection, vault switch, and app exit

docs/PUBLIC-DOCS-PLAN.md

@@ -0,0 +1,34 @@
+# Public Docs Plan
+
+This document records the phase 1 information architecture for public Tolaria documentation. The public docs source lives in `site/`; the existing `docs/` directory remains contributor, architecture, and agent context.
+
+## Audiences
+
+| Audience | Needs | Primary location |
+|---|---|---|
+| New users | Install, first launch, understand the app layout, clone the starter vault | `site/start/` |
+| Active users | Learn concrete workflows such as organizing, Git sync, custom views, and AI | `site/guides/` |
+| Power users | Understand file layout, frontmatter, filters, shortcuts, and platform support | `site/reference/` |
+| Contributors and agents | Architecture, abstractions, ADRs, development workflow | `docs/`, `AGENTS.md` |
+
+## Hosting Shape
+
+The GitHub Pages output should reserve the root for public docs and mount release assets underneath it:
+
+```text
+/                  public docs home
+/releases/         release history
+/download/         latest stable download redirect
+/stable/latest.json
+/alpha/latest.json
+/latest.json       compatibility alias for alpha latest
+/latest-canary.json compatibility alias for alpha latest
+```
+
+Every user-visible app change should answer:
+
+```text
+Public docs impact:
+- updated: <pages>
+- not needed because: <reason>
+```

docs/adr/0091-gemini-cli-external-ai-setup.md

@@ -1,35 +0,0 @@
----
-type: ADR
-id: "0091"
-title: "Gemini CLI external AI setup"
-status: active
-date: 2026-04-28
----
-
-## Context
-
-Tolaria already supports explicit MCP setup for external desktop AI tools. Users asked for Gemini CLI support so the same active-vault MCP server can be registered where Gemini reads tool configuration, with optional Gemini-specific vault guidance.
-
-Gemini CLI reads MCP server definitions from `~/.gemini/settings.json` and can load project guidance from `GEMINI.md`. Tolaria must support those conventions without silently rewriting global user settings or overwriting user-authored vault instructions.
-
-## Decision
-
-Tolaria adds `~/.gemini/settings.json` to the explicit external AI setup path list. The existing MCP entry shape is reused: `mcpServers.tolaria` runs the packaged stdio server through Node.js, pins `VAULT_PATH` to the selected vault, and sets `WS_UI_PORT=9711`.
-
-Vault guidance keeps `AGENTS.md` as the canonical shared source. `restore_vault_ai_guidance` can create or repair a managed `GEMINI.md` shim that imports `AGENTS.md`, while bootstrap and repair flows continue to seed only required Tolaria guidance (`AGENTS.md` and `CLAUDE.md`) plus type scaffolding. Custom `GEMINI.md` files are classified as custom and are not overwritten.
-
-The setup dialog documents that Gemini CLI still needs its own install and sign-in. Tolaria does not store Gemini credentials or model-provider API keys.
-
-## Options Considered
-
-- **Add Gemini to explicit MCP setup and optional guidance restore** (chosen): matches the existing consent boundary, preserves user settings, and gives Gemini the shared vault context.
-- **Generate `GEMINI.md` automatically for every vault**: simpler discovery, but turns an optional third-party compatibility file into startup side effect and dirties vaults for users who do not use Gemini.
-- **Document manual Gemini setup only**: avoids code changes, but leaves users to transpose paths and loses the active-vault safety already available for other MCP clients.
-- **Create a Gemini-specific MCP entry shape**: unnecessary because Gemini accepts the same `mcpServers` entry structure used by the existing Tolaria MCP server.
-
-## Consequences
-
-- External AI setup now writes/removes Tolaria's MCP entry in Claude, Gemini, Cursor, and generic MCP config files.
-- Gemini users can create a managed `GEMINI.md` shim without duplicating the canonical `AGENTS.md` guidance.
-- Existing vault bootstrap and repair remain non-invasive for users who do not use Gemini.
-- Native QA requires a local Gemini CLI install and authentication for an end-to-end Gemini prompt; otherwise the app can still verify the generated config and documentation paths.

docs/adr/0092-vault-ai-agent-permission-modes.md

@@ -1,39 +0,0 @@
----
-type: ADR
-id: "0092"
-title: "Vault-scoped AI agent permission modes"
-status: active
-date: 2026-04-28
----
-
-## Context
-
-ADR-0074 established explicit setup and least-privilege defaults for desktop AI tools. The in-app AI panel now supports multiple local CLI agents, and users need a clear per-vault way to choose whether an agent should stay in the narrow vault-safe profile or use broader local-work tools for that vault.
-
-The mode must be visible at the point of use, must not mutate global CLI settings, and must not silently restore dangerous bypass flags. Existing transcripts should remain intact when the mode changes because a change applies to the next agent run, not to a process that is already streaming.
-
-## Decision
-
-**Tolaria stores an `ai_agent_permission_mode` per vault with values `safe` and `power_user`, defaulting missing or null values to `safe`, and passes that normalized mode through the AI panel stream request into each CLI adapter.**
-
-The AI panel header displays the current mode and offers a compact Vault Safe / Power User control that is disabled while an agent run is active. Changing the mode preserves the transcript and inserts a local transcript marker.
-
-Adapter mappings remain conservative:
-- Claude Code Safe keeps `acceptEdits`, strict Tolaria MCP config, and file/search/edit tools only; Power User adds Bash to the allowed tool list without using `--dangerously-skip-permissions`.
-- Codex keeps the active-vault `workspace-write` sandbox and `--ask-for-approval never` in both modes.
-- OpenCode uses transient `OPENCODE_CONFIG_CONTENT`; Safe denies bash and external directories, while Power User allows bash but still denies external directories.
-- Pi receives the mode on the adapter request path; both modes currently use the same transient MCP adapter config.
-
-## Options Considered
-
-- **Per-vault Safe / Power User modes** (chosen): makes the permission surface explicit where the agent is used and preserves least-privilege defaults for each vault.
-- **Global app setting**: simpler storage, but a single toggle can over-apply a power-user profile to unrelated vaults.
-- **Dangerous bypass mode**: maximizes CLI freedom, but violates ADR-0074's least-privilege boundary and needs a separate explicit security decision.
-- **Adapter-specific UI switches**: exposes too much implementation detail and makes cross-agent behavior harder to reason about.
-
-## Consequences
-
-- Vault config normalization owns the safe default for old vaults and malformed values.
-- Agent requests now carry a permission mode through frontend and Rust boundaries, so new adapters must choose an explicit mapping.
-- Power User is intentionally not equivalent across agents; where an adapter lacks a safe broader local-work switch, both modes may map to the same conservative behavior and must document that with tests.
-- Any future dangerous mode requires a new ADR and separate UI language.

docs/adr/0093-shared-cli-agent-runtime-adapters.md

@@ -1,35 +0,0 @@
----
-type: ADR
-id: "0093"
-title: "Shared CLI agent runtime adapters"
-status: active
-date: 2026-04-29
----
-
-## Context
-
-Tolaria supports Claude Code, Codex, OpenCode, and Pi as local CLI agents in the AI panel. Each agent has different command-line arguments, configuration shape, and JSON event schema, but the Rust backend had grown repeated runtime plumbing around those differences: request shapes, prompt wrapping, subprocess launch, stdout JSON reading, stderr capture, exit handling, done events, version probing, and Tolaria MCP server path resolution.
-
-That duplication made small runtime fixes expensive because they had to be repeated across several adapter files. It also kept Codex-specific command and event mapping inside `ai_agents.rs`, making the top-level module both an orchestrator and a bespoke adapter.
-
-## Decision
-
-**Tolaria uses `cli_agent_runtime.rs` as the shared runtime scaffold for app-managed CLI agents, while `ai_agents.rs` only normalizes and dispatches requests to per-agent adapter modules.**
-
-The shared scaffold owns the common agent request shape, system/user prompt wrapping, JSON-line process lifecycle, normalized error/done handling for `AiAgentStreamEvent` adapters, version probing, and Tolaria MCP server path resolution. Per-agent modules keep the provider-specific pieces: binary discovery candidates, command arguments, transient config shape, authentication error wording, and JSON event mapping.
-
-Codex now lives in `codex_cli.rs`, matching the Claude, OpenCode, and Pi adapter boundary. `ai_agents.rs` remains the Tauri-facing orchestrator that chooses an adapter and maps Claude's legacy event enum into the normalized event stream.
-
-## Options Considered
-
-- **Shared runtime scaffold with thin adapters** (chosen): reduces repeated process lifecycle code without hiding provider-specific command/config/event behavior.
-- **One trait object per agent**: more uniform on paper, but adds indirection without removing much current complexity.
-- **Leave each adapter self-contained**: keeps local readability for a single file, but new process, prompt, and MCP fixes continue to land in parallel.
-- **Fully generic event mapping**: over-abstracts the JSON schemas and makes provider-specific edge cases harder to test.
-
-## Consequences
-
-- Runtime lifecycle fixes should usually start in `cli_agent_runtime.rs`.
-- New agent adapters should use the shared request/prompt/process helpers and keep only command, config, discovery, and event mapping local.
-- `ai_agents.rs` should not grow provider-specific runtime code again; it should normalize the frontend request, dispatch to an adapter, and map any legacy event shape.
-- The shared scaffold deliberately does not erase provider differences. Authentication messages, permission semantics, and transient config formats remain adapter-owned and must stay covered by adapter tests.

docs/adr/README.md

@@ -142,7 +142,3 @@ proposed → active → superseded
 | [0085](0085-non-git-vault-support.md) | Non-git vaults open with explicit later Git initialization | active |
 | [0088](0088-markdown-durable-mermaid-diagrams.md) | Markdown-durable Mermaid diagrams in notes | active |
 | [0089](0089-active-vault-filesystem-watcher.md) | Active vault filesystem watcher | active |
-| [0090](0090-pi-cli-agent-adapter.md) | Pi CLI agent adapter | active |
-| [0091](0091-gemini-cli-external-ai-setup.md) | Gemini CLI external AI setup | active |
-| [0092](0092-vault-ai-agent-permission-modes.md) | Vault-scoped AI agent permission modes | active |
-| [0093](0093-shared-cli-agent-runtime-adapters.md) | Shared CLI agent runtime adapters | active |

mcp-server/index.js

@@ -30,69 +30,27 @@ const WS_UI_URL = `ws://localhost:${WS_UI_PORT}`
 // Connect as a WebSocket CLIENT to the UI bridge (run by ws-bridge.js).
 // The bridge relays messages to all other clients (the React frontend).
 let uiSocket = null
-let reconnectTimer = null
-let shutdownStarted = false
 const RECONNECT_INTERVAL_MS = 3000
 
 function connectUiBridge() {
-  if (shutdownStarted) return
-
   try {
     const ws = new WebSocket(WS_UI_URL)
-    uiSocket = ws
     ws.on('open', () => {
-      if (shutdownStarted) {
-        closeUiSocket()
-        return
-      }
+      uiSocket = ws
       console.error(`[mcp] Connected to UI bridge at ${WS_UI_URL}`)
     })
     ws.on('close', () => {
-      if (uiSocket === ws) uiSocket = null
-      scheduleUiReconnect()
+      uiSocket = null
+      setTimeout(connectUiBridge, RECONNECT_INTERVAL_MS)
     })
     ws.on('error', () => {
       // Silent — bridge may not be running yet, will retry
     })
   } catch {
-    scheduleUiReconnect()
+    setTimeout(connectUiBridge, RECONNECT_INTERVAL_MS)
   }
 }
-
-function scheduleUiReconnect() {
-  if (shutdownStarted) return
-
-  clearUiReconnectTimer()
-  reconnectTimer = setTimeout(connectUiBridge, RECONNECT_INTERVAL_MS)
-  reconnectTimer.unref?.()
-}
-
-function clearUiReconnectTimer() {
-  if (!reconnectTimer) return
-
-  clearTimeout(reconnectTimer)
-  reconnectTimer = null
-}
-
-function closeUiSocket() {
-  const socket = uiSocket
-  uiSocket = null
-  if (!socket) return
-
-  socket.removeAllListeners()
-  socket.on('error', () => {})
-  if (socket.readyState === WebSocket.CONNECTING) {
-    socket.terminate?.()
-    return
-  }
-
-  try {
-    socket.close()
-  } catch {
-    // Ignore close races during process teardown.
-  }
-  socket.terminate?.()
-}
+connectUiBridge()
 
 function broadcastUiAction(action, payload) {
   if (!uiSocket || uiSocket.readyState !== WebSocket.OPEN) return
@@ -235,47 +193,10 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
   }
 })
 
-async function shutdown(exitCode = 0) {
-  if (shutdownStarted) return
-
-  shutdownStarted = true
-  clearUiReconnectTimer()
-  closeUiSocket()
-
-  try {
-    await server.close()
-  } catch (error) {
-    console.error(`[mcp] Error while closing server: ${error.message}`)
-  }
-
-  process.exitCode = exitCode
-  setImmediate(() => process.exit(exitCode))
-}
-
 async function main() {
   const transport = new StdioServerTransport()
-  server.onclose = () => {
-    void shutdown(0)
-  }
-  process.stdin.once('end', () => {
-    void shutdown(0)
-  })
-  process.stdin.once('close', () => {
-    void shutdown(0)
-  })
-  process.once('SIGINT', () => {
-    void shutdown(0)
-  })
-  process.once('SIGTERM', () => {
-    void shutdown(0)
-  })
-
-  connectUiBridge()
   await server.connect(transport)
   console.error(`Tolaria MCP server running (vault: ${VAULT_PATH})`)
 }
 
-main().catch((error) => {
-  console.error(error)
-  void shutdown(1)
-})
+main().catch(console.error)

mcp-server/test.js

@@ -1,10 +1,8 @@
 import { describe, it, before, after } from 'node:test'
 import assert from 'node:assert/strict'
-import { spawn } from 'node:child_process'
 import fs from 'node:fs/promises'
 import path from 'node:path'
 import os from 'node:os'
-import { fileURLToPath } from 'node:url'
 import {
   findMarkdownFiles, getNote, searchNotes, vaultContext,
 } from './vault.js'
@@ -13,7 +11,6 @@ import { evaluateBridgeRequest } from './ws-bridge.js'
 
 let tmpDir
 const ACTIVE_VAULT_ERROR = 'Note path must stay inside the active vault'
-const MCP_SERVER_DIR = path.dirname(fileURLToPath(import.meta.url))
 
 before(async () => {
   tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'laputa-mcp-test-'))
@@ -211,34 +208,6 @@ describe('requireVaultPath', () => {
   })
 })
 
-describe('stdio process lifecycle', () => {
-  it('exits when the MCP client closes stdin', async () => {
-    const child = spawn(process.execPath, ['index.js'], {
-      cwd: MCP_SERVER_DIR,
-      env: { ...process.env, VAULT_PATH: tmpDir, WS_UI_PORT: '65534' },
-      stdio: ['pipe', 'ignore', 'pipe'],
-    })
-    let stderr = ''
-    child.stderr.setEncoding('utf8')
-    child.stderr.on('data', chunk => {
-      stderr += chunk
-    })
-
-    await sleep(200)
-    child.stdin.end()
-
-    const exit = await waitForExit(child, 1_500)
-    if (!exit) {
-      child.kill()
-      await waitForExit(child, 1_000)
-      assert.fail(`MCP server stayed alive after stdin closed.\n${stderr}`)
-    }
-
-    assert.equal(exit.signal, null)
-    assert.equal(exit.code, 0, stderr)
-  })
-})
-
 async function assertRejectsOutsideVault(prefix, resolveNotePath) {
   const outsideDir = await fs.mkdtemp(path.join(os.tmpdir(), prefix))
   const outsideNote = path.join(outsideDir, 'outside.md')
@@ -253,28 +222,3 @@ async function assertRejectsOutsideVault(prefix, resolveNotePath) {
     await fs.rm(outsideDir, { recursive: true, force: true })
   }
 }
-
-function sleep(ms) {
-  return new Promise(resolve => setTimeout(resolve, ms))
-}
-
-function waitForExit(child, timeoutMs) {
-  return new Promise((resolve) => {
-    const timer = setTimeout(() => {
-      cleanup()
-      resolve(null)
-    }, timeoutMs)
-
-    child.once('exit', onExit)
-
-    function onExit(code, signal) {
-      cleanup()
-      resolve({ code, signal })
-    }
-
-    function cleanup() {
-      clearTimeout(timer)
-      child.off('exit', onExit)
-    }
-  })
-}

package.json

@@ -8,6 +8,9 @@
     "dev": "vite",
     "build": "tsc -b && vite build",
     "bundle-mcp": "node scripts/bundle-mcp-server.mjs",
+    "docs:dev": "vitepress dev site --host 127.0.0.1",
+    "docs:build": "vitepress build site",
+    "docs:preview": "vitepress preview site --host 127.0.0.1",
     "lint": "eslint .",
     "l10n:translate": "lara-cli translate",
     "l10n:translate:force": "lara-cli translate --force",
@@ -17,7 +20,7 @@
     "test": "vitest run",
     "test:watch": "vitest",
     "test:e2e": "playwright test",
-    "playwright:smoke": "playwright test --config playwright.smoke.config.ts tests/smoke/create-note-backing-file.spec.ts tests/smoke/delete-note-nonblocking.spec.ts tests/smoke/example.spec.ts tests/smoke/fix-ai-chat-empty-body-v3.spec.ts tests/smoke/fix-crash-create-note.spec.ts tests/smoke/fresh-start-telemetry-onboarding.spec.ts tests/smoke/frontmatter-date-picker.spec.ts tests/smoke/getting-started-template.spec.ts tests/smoke/h1-title-decoupled.spec.ts tests/smoke/h1-untitled-auto-rename.spec.ts tests/smoke/keyboard-command-routing.spec.ts tests/smoke/linkify-init-warnings.spec.ts tests/smoke/missing-string-metadata-open-note.spec.ts tests/smoke/multi-selection-shortcuts.spec.ts tests/smoke/wikilink-path-fix.spec.ts",
+    "playwright:smoke": "playwright test --config playwright.smoke.config.ts tests/smoke/delete-note-nonblocking.spec.ts tests/smoke/example.spec.ts tests/smoke/fix-ai-chat-empty-body-v3.spec.ts tests/smoke/fix-crash-create-note.spec.ts tests/smoke/fresh-start-telemetry-onboarding.spec.ts tests/smoke/getting-started-template.spec.ts tests/smoke/h1-title-decoupled.spec.ts tests/smoke/h1-untitled-auto-rename.spec.ts tests/smoke/keyboard-command-routing.spec.ts tests/smoke/linkify-init-warnings.spec.ts tests/smoke/multi-selection-shortcuts.spec.ts tests/smoke/wikilink-path-fix.spec.ts",
     "playwright:regression": "playwright test tests/smoke/",
     "playwright:integration": "playwright test --config playwright.integration.config.ts",
     "test:coverage": "node scripts/run-vitest-coverage.mjs",
@@ -99,6 +102,7 @@
     "typescript": "~5.9.3",
     "typescript-eslint": "^8.48.0",
     "vite": "^7.3.1",
+    "vitepress": "^1.6.4",
     "vitest": "^4.0.18",
     "ws": "^8.19.0"
   }

site/.vitepress/config.ts

@@ -0,0 +1,101 @@
+import { defineConfig } from "vitepress";
+
+const base = process.env.VITEPRESS_BASE ?? "/";
+
+export default defineConfig({
+  title: "Tolaria",
+  description:
+    "Tolaria is a local-first Markdown knowledge base with native relationships, Git history, and AI workflows.",
+  base,
+  cleanUrls: true,
+  head: [
+    ["link", { rel: "icon", type: "image/png", href: `${base}landing/favicon.png` }],
+    ["meta", { property: "og:title", content: "Tolaria" }],
+    [
+      "meta",
+      {
+        property: "og:description",
+        content:
+          "A second brain for the AI era. Free forever, local-first, Markdown-based, Git-ready, and AI-friendly.",
+      },
+    ],
+  ],
+  themeConfig: {
+    logo: { src: "/landing/tolaria-icon.png", alt: "Tolaria" },
+    nav: [
+      { text: "Features", link: "/#features" },
+      { text: "Start", link: "/start/install" },
+      { text: "Concepts", link: "/concepts/vaults" },
+      { text: "Guides", link: "/guides/capture-a-note" },
+      { text: "Reference", link: "/reference/supported-platforms" },
+      { text: "Releases", link: "/releases/" },
+    ],
+    search: {
+      provider: "local",
+    },
+    socialLinks: [{ icon: "github", link: "https://github.com/refactoringhq/tolaria" }],
+    sidebar: [
+      {
+        text: "Start Here",
+        items: [
+          { text: "Install Tolaria", link: "/start/install" },
+          { text: "First Launch", link: "/start/first-launch" },
+          { text: "Getting Started Vault", link: "/start/getting-started-vault" },
+          { text: "Open Or Create A Vault", link: "/start/open-or-create-vault" },
+        ],
+      },
+      {
+        text: "Concepts",
+        items: [
+          { text: "Vaults", link: "/concepts/vaults" },
+          { text: "Notes", link: "/concepts/notes" },
+          { text: "Properties", link: "/concepts/properties" },
+          { text: "Types", link: "/concepts/types" },
+          { text: "Relationships", link: "/concepts/relationships" },
+          { text: "Inbox", link: "/concepts/inbox" },
+          { text: "Git", link: "/concepts/git" },
+          { text: "AI", link: "/concepts/ai" },
+        ],
+      },
+      {
+        text: "Guides",
+        items: [
+          { text: "Capture A Note", link: "/guides/capture-a-note" },
+          { text: "Organize The Inbox", link: "/guides/organize-inbox" },
+          { text: "Use Wikilinks", link: "/guides/use-wikilinks" },
+          { text: "Create Types", link: "/guides/create-types" },
+          { text: "Build Custom Views", link: "/guides/build-custom-views" },
+          { text: "Connect A Git Remote", link: "/guides/connect-a-git-remote" },
+          { text: "Commit And Push", link: "/guides/commit-and-push" },
+          { text: "Use The AI Panel", link: "/guides/use-ai-panel" },
+          { text: "Use The Command Palette", link: "/guides/use-command-palette" },
+        ],
+      },
+      {
+        text: "Reference",
+        items: [
+          { text: "Supported Platforms", link: "/reference/supported-platforms" },
+          { text: "File Layout", link: "/reference/file-layout" },
+          { text: "Frontmatter Fields", link: "/reference/frontmatter-fields" },
+          { text: "View Filters", link: "/reference/view-filters" },
+          { text: "Keyboard Shortcuts", link: "/reference/keyboard-shortcuts" },
+          { text: "Docs Maintenance", link: "/reference/docs-maintenance" },
+        ],
+      },
+      {
+        text: "Troubleshooting",
+        items: [
+          { text: "Vault Not Loading", link: "/troubleshooting/vault-not-loading" },
+          { text: "Git Authentication", link: "/troubleshooting/git-auth" },
+          { text: "AI Agent Not Found", link: "/troubleshooting/ai-agent-not-found" },
+          { text: "Sync Conflicts", link: "/troubleshooting/sync-conflicts" },
+        ],
+      },
+    ],
+    footer: {
+      message: "Free and open source. Local-first, Git-first, and Markdown-based.",
+      copyright:
+        "Tolaria is AGPL-3.0-or-later. The Tolaria name and logo remain covered by the project trademark policy.",
+    },
+  },
+});

site/.vitepress/theme/Layout.vue

@@ -0,0 +1,28 @@
+<script setup lang="ts">
+import DefaultTheme from "vitepress/theme";
+import { onBeforeUnmount, onMounted } from "vue";
+import { useData } from "vitepress";
+
+const { frontmatter } = useData();
+
+const scrollClass = "tolaria-scrolled";
+const updateScrollClass = () => {
+  document.documentElement.classList.toggle(scrollClass, window.scrollY > 8);
+};
+
+onMounted(() => {
+  updateScrollClass();
+  window.addEventListener("scroll", updateScrollClass, { passive: true });
+});
+
+onBeforeUnmount(() => {
+  window.removeEventListener("scroll", updateScrollClass);
+  document.documentElement.classList.remove(scrollClass);
+});
+</script>
+
+<template>
+  <div :class="{ 'tolaria-landing-shell': frontmatter.landing }">
+    <DefaultTheme.Layout />
+  </div>
+</template>

site/.vitepress/theme/index.ts

@@ -0,0 +1,12 @@
+import DefaultTheme from "vitepress/theme";
+import LandingHome from "./LandingHome.vue";
+import Layout from "./Layout.vue";
+import "./styles.css";
+
+export default {
+  extends: DefaultTheme,
+  Layout,
+  enhanceApp({ app }) {
+    app.component("LandingHome", LandingHome);
+  },
+};

site/.vitepress/theme/styles.css

@@ -0,0 +1,171 @@
+@font-face {
+  font-family: "RefactoringSans";
+  src: url("./assets/RefactoringSans.otf") format("opentype");
+  font-display: swap;
+  font-style: normal;
+  font-weight: 400 900;
+}
+
+:root {
+  --vp-font-family-base:
+    "Inter", -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+  --vp-font-family-mono: "SF Mono", "Fira Code", ui-monospace, monospace;
+  --tolaria-font-brand:
+    "RefactoringSans", "Inter", -apple-system, BlinkMacSystemFont, sans-serif;
+  --tolaria-bg: #faf9f5;
+  --tolaria-surface: #ffffff;
+  --tolaria-surface-muted: #f7f6f3;
+  --tolaria-text: #1a1a18;
+  --tolaria-text-secondary: #6b6b60;
+  --tolaria-text-muted: #9b9b90;
+  --tolaria-border: #e5e5e0;
+  --tolaria-blue: #155dff;
+  --tolaria-blue-hover: #4a5ad6;
+  --tolaria-blue-soft: #e8eeff;
+  --vp-c-bg: var(--tolaria-surface);
+  --vp-c-bg-alt: var(--tolaria-surface-muted);
+  --vp-c-bg-elv: var(--tolaria-surface);
+  --vp-c-bg-soft: var(--tolaria-surface-muted);
+  --vp-c-text-1: var(--tolaria-text);
+  --vp-c-text-2: var(--tolaria-text-secondary);
+  --vp-c-text-3: var(--tolaria-text-muted);
+  --vp-c-border: var(--tolaria-border);
+  --vp-c-divider: var(--tolaria-border);
+  --vp-c-brand-1: var(--tolaria-blue);
+  --vp-c-brand-2: var(--tolaria-blue-hover);
+  --vp-c-brand-3: var(--tolaria-blue);
+  --vp-c-brand-soft: var(--tolaria-blue-soft);
+  --vp-button-brand-bg: var(--tolaria-blue);
+  --vp-button-brand-hover-bg: var(--tolaria-blue-hover);
+  --vp-button-brand-border: var(--tolaria-blue);
+  --vp-code-bg: #eeeeea;
+  --vp-code-color: var(--tolaria-text-secondary);
+}
+
+.dark {
+  --vp-c-bg: #1f1e1b;
+  --vp-c-bg-alt: #191814;
+  --vp-c-bg-elv: #23221f;
+  --vp-c-bg-soft: #23221f;
+  --vp-c-text-1: #e6e1d8;
+  --vp-c-text-2: #b8b1a6;
+  --vp-c-text-3: #7f776d;
+  --vp-c-border: #34322d;
+  --vp-c-divider: #34322d;
+  --vp-c-brand-1: #78a4ff;
+  --vp-c-brand-2: #9bbeff;
+  --vp-c-brand-3: #78a4ff;
+  --vp-c-brand-soft: rgba(120, 164, 255, 0.16);
+  --vp-code-bg: #2d2b27;
+  --vp-code-color: #d8d1c6;
+}
+
+.VPNavBarTitle .logo {
+  width: auto;
+  height: 28px;
+}
+
+.VPNavBarTitle .title {
+  color: var(--vp-c-text-1);
+  font-family: var(--tolaria-font-brand);
+  font-size: 22px;
+  font-weight: 800;
+  letter-spacing: 0;
+}
+
+.tolaria-landing-shell {
+  --vp-c-bg: var(--tolaria-bg);
+}
+
+.tolaria-landing-shell .VPNav,
+.tolaria-landing-shell .VPNavBar,
+.tolaria-landing-shell .VPNavBar .content-body {
+  background: color-mix(in srgb, var(--tolaria-bg) 94%, transparent);
+  backdrop-filter: blur(14px);
+}
+
+.tolaria-landing-shell .VPNavBar .divider,
+.tolaria-landing-shell .VPNavBar .divider-line {
+  background-color: transparent;
+}
+
+.tolaria-landing-shell .VPNavBar .divider-line {
+  opacity: 0;
+  transition: opacity 160ms ease;
+}
+
+.tolaria-landing-shell .VPLocalNav {
+  display: none;
+}
+
+.tolaria-scrolled .tolaria-landing-shell .VPNav {
+  box-shadow: 0 10px 24px rgba(26, 26, 24, 0.06);
+}
+
+.tolaria-scrolled .tolaria-landing-shell .VPNavBar .divider-line {
+  opacity: 1;
+}
+
+.DocSearch-Button {
+  border-radius: 999px;
+}
+
+.vp-doc h1,
+.vp-doc h2,
+.vp-doc h3 {
+  letter-spacing: 0;
+}
+
+.vp-doc a,
+.VPNavBarMenuLink.active,
+.VPLink.active {
+  color: var(--vp-c-brand-1);
+}
+
+.vp-doc table {
+  display: table;
+  width: 100%;
+}
+
+.vp-doc th {
+  color: var(--vp-c-text-1);
+  background: var(--vp-c-bg-soft);
+}
+
+.vp-doc td,
+.vp-doc th {
+  border-color: var(--vp-c-divider);
+}
+
+.tolaria-landing-shell .VPContent,
+.tolaria-landing-shell .VPPage,
+.tolaria-landing-shell .VPDoc,
+.tolaria-landing-shell .VPDoc .container,
+.tolaria-landing-shell .VPDoc .content,
+.tolaria-landing-shell .VPDoc .content-container,
+.tolaria-landing-shell .VPDoc .main,
+.tolaria-landing-shell .vp-doc {
+  max-width: none;
+  padding: 0;
+  margin: 0;
+}
+
+.tolaria-landing-shell .VPPage {
+  padding-top: var(--vp-nav-height);
+}
+
+.tolaria-landing-shell .VPDoc {
+  padding-top: var(--vp-nav-height);
+}
+
+.tolaria-landing-shell .vp-doc > div {
+  width: 100%;
+}
+
+.tolaria-landing-shell .vp-doc a {
+  text-decoration: none;
+}
+
+.tolaria-landing-shell .VPFooter {
+  display: none;
+}

site/concepts/ai.md

@@ -0,0 +1,20 @@
+# AI
+
+Tolaria is designed for local AI agents that can work with files and tools rather than a hidden cloud-only notes API.
+
+## Agent Panel
+
+The AI panel streams messages from supported local CLI agents. It shows reasoning, tool activity, and file changes in the app.
+
+## MCP Server
+
+Tolaria exposes an MCP server so tools such as Claude Code and Codex can search, read, and edit vault notes through explicit tools.
+
+## Why Git Matters For AI
+
+AI-generated changes should be inspectable. Git gives you diffs, history, rollback, and a clear boundary between suggestions and committed work.
+
+## Current Direction
+
+Claude Code is the primary integration. Codex and other CLI agents are supported through the shared agent architecture as the app evolves.
+

site/concepts/git.md

@@ -0,0 +1,21 @@
+# Git
+
+Git is Tolaria's history and sync layer. It keeps the model local-first while still supporting remote backup and multi-device workflows.
+
+## What Tolaria Uses Git For
+
+- Local commit history.
+- Diff views.
+- Per-note history.
+- Pull and push.
+- Conflict detection and resolution.
+- Remote connection for local-only vaults.
+
+## Local Commits
+
+You can commit changes inside Tolaria without leaving the app. This gives you useful restore points even before a remote is configured.
+
+## Remotes
+
+Connect a compatible Git remote when you want sync or backup. Tolaria relies on your system Git authentication, so GitHub CLI, SSH keys, credential helpers, and existing Git configuration can continue to work.
+

site/concepts/inbox.md

@@ -0,0 +1,22 @@
+# Inbox
+
+The Inbox is for notes that have been captured but not yet organized.
+
+## Why It Exists
+
+Fast capture should not require perfect structure. The Inbox gives you a place to put incomplete notes, then process them later.
+
+## Organizing Inbox Notes
+
+When reviewing the Inbox:
+
+1. Give the note a clear H1.
+2. Set its `type`.
+3. Add status, dates, or URL if useful.
+4. Add relationships with wikilinks or frontmatter fields.
+5. Move it into a folder only if the folder adds value.
+
+## Healthy Inbox Habit
+
+Keep the Inbox small enough that it can be reviewed in one focused pass. Tolaria works best when capture is fast and organization is deliberate.
+

site/concepts/notes.md

@@ -0,0 +1,31 @@
+# Notes
+
+A note is a Markdown file with optional YAML frontmatter. Tolaria reads the first H1 as the primary title and keeps the file on disk as the durable representation.
+
+## Anatomy
+
+```md
+---
+type: Project
+status: Active
+belongs_to:
+  - "[[workspace]]"
+---
+
+# Launch Documentation
+
+Draft the public Tolaria docs and keep them close to code changes.
+```
+
+## Titles
+
+The first H1 is the main title. Older notes can still use a `title:` frontmatter fallback, but new notes should rely on the H1.
+
+## Body Links
+
+Use `[[wikilinks]]` to connect notes from the body. Tolaria can resolve links by filename, title, and aliases.
+
+## Frontmatter
+
+Use frontmatter for structured fields such as type, status, date, URL, and relationships. Keep free-form thinking in the body.
+

site/concepts/properties.md

@@ -0,0 +1,25 @@
+# Properties
+
+Properties are frontmatter fields that Tolaria can display, filter, and edit.
+
+## Common Properties
+
+| Field | Purpose |
+| --- | --- |
+| `type` | Groups the note into a type such as Project, Person, or Topic. |
+| `status` | Tracks lifecycle state such as Active, Done, or Blocked. |
+| `url` | Stores a canonical external link. |
+| `date` | Represents a single date. |
+| `start_date`, `end_date` | Represents a date range. |
+| `aliases` | Gives a note alternative names for wikilink resolution. |
+
+## System Properties
+
+Fields that start with `_` are system properties. They remain in plain text but are hidden from normal property editing.
+
+Examples include `_icon`, `_color`, `_order`, and `_pinned_properties` on type documents.
+
+## Property Editing
+
+The Inspector is the safest place to edit structured properties. Use raw Markdown mode when you need direct control over YAML.
+

site/concepts/relationships.md

@@ -0,0 +1,27 @@
+# Relationships
+
+Relationships make a vault feel like a graph instead of a pile of documents.
+
+## Relationship Fields
+
+Any frontmatter field containing wikilinks can become a relationship.
+
+```yaml
+belongs_to:
+  - "[[product-work]]"
+related_to:
+  - "[[documentation]]"
+blocked_by:
+  - "[[release-process]]"
+```
+
+Tolaria does not need a hardcoded list of relationship names. It detects relationship fields dynamically.
+
+## Body Links Versus Relationship Fields
+
+Use body links when the relationship appears naturally in writing. Use frontmatter relationships when the connection is important enough to show in navigation, filters, or the Inspector.
+
+## Backlinks
+
+Tolaria can show incoming links and inverse relationships, making it easier to navigate from a note to the rest of its context.
+

site/concepts/types.md

@@ -0,0 +1,38 @@
+# Types
+
+Types describe what kind of thing a note represents: Project, Person, Topic, Procedure, Event, or any category you create.
+
+## Type Field
+
+The `type:` field assigns a note to a type.
+
+```yaml
+type: Project
+```
+
+Tolaria does not infer type from folder location. Moving a file into another folder does not change its type.
+
+## Type Documents
+
+Type documents live in the `type/` folder and describe how a type should appear.
+
+```yaml
+---
+type: Type
+icon: folder
+color: blue
+sidebar_label: Projects
+sort: modified:desc
+---
+
+# Project
+```
+
+## What Types Control
+
+- Sidebar grouping.
+- Type icon and color.
+- Default sort.
+- Pinned properties.
+- New-note templates.
+

site/concepts/vaults.md

@@ -0,0 +1,29 @@
+# Vaults
+
+A vault is the folder Tolaria reads and writes. The filesystem is the source of truth; the app state and cache are derived from files.
+
+## Core Rules
+
+- Notes are Markdown files.
+- YAML frontmatter provides structure.
+- Attachments are normal files inside the vault.
+- Type definitions and saved views are also files.
+- Git tracks history and supports remote sync.
+
+## Why Local Files Matter
+
+Local files keep your notes inspectable. You can open them in another editor, search with command-line tools, back them up with your own system, and version them with Git.
+
+Tolaria should never become the only way to read your data.
+
+## App State Versus Vault State
+
+Vault-level information should travel with the vault. Machine-specific preferences stay with the app installation.
+
+| Vault state | App state |
+| --- | --- |
+| Type icons and colors | Editor zoom |
+| Saved views | Window size |
+| Pinned properties | Recent vault list |
+| Relationship conventions | Local cache |
+

site/download/index.md

@@ -0,0 +1,17 @@
+# Download
+
+Download Tolaria from the latest stable release.
+
+## macOS
+
+[Download the latest stable build](https://refactoringhq.github.io/tolaria/download/)
+
+macOS is the primary supported platform.
+
+## Linux And Windows
+
+Linux and Windows builds are best effort for now. Check the [latest GitHub release](https://github.com/refactoringhq/tolaria/releases/latest) for available artifacts.
+
+## Verify The Version
+
+After launching the app, check the version shown in Tolaria's status bar or release surface.

site/guides/build-custom-views.md

@@ -0,0 +1,20 @@
+# Build Custom Views
+
+Custom views are saved filters for recurring questions.
+
+## Good View Candidates
+
+- Active projects.
+- People without a recent follow-up.
+- Drafts ready for review.
+- Notes changed this week.
+- Events in a date range.
+
+## View Definition
+
+Saved views live as files in the vault. They describe filters, sorting, and visible columns using structured data.
+
+## Design The Question First
+
+Before creating a view, write the question it answers. A good view is not "all fields with all filters"; it is a focused lens.
+

site/guides/capture-a-note.md

@@ -0,0 +1,20 @@
+# Capture A Note
+
+Use capture when you need to get an idea into the vault before you know where it belongs.
+
+## Steps
+
+1. Open the command palette with `Cmd+K` or `Ctrl+K`.
+2. Run `New Note`.
+3. Write a clear H1.
+4. Add the rough content.
+5. Leave structure for later if you are still thinking.
+
+## Capture Well
+
+Prefer a useful title over a perfect taxonomy. You can add type, status, and relationships during inbox review.
+
+## When To Add Structure Immediately
+
+Add structure while capturing if the note is obviously a Project, Person, Event, or Procedure and the context is already known.
+

site/guides/commit-and-push.md

@@ -0,0 +1,19 @@
+# Commit And Push
+
+Tolaria lets you commit and push vault changes from inside the app.
+
+## Commit
+
+1. Open the Git or changes surface.
+2. Review changed files.
+3. Write a short commit message.
+4. Commit locally.
+
+## Push
+
+Push after committing when a remote is configured. If the remote has changed, pull first and resolve any conflicts.
+
+## Use Small Commits
+
+Small commits make it easier to understand what changed, roll back safely, and review AI-generated edits.
+

site/guides/connect-a-git-remote.md

@@ -0,0 +1,23 @@
+# Connect A Git Remote
+
+Connect a remote when you want backup or sync beyond the current machine.
+
+## Before You Start
+
+Make sure the remote repository exists and your system Git can authenticate to it. Tolaria uses system Git rather than storing provider-specific credentials.
+
+## Steps
+
+1. Open the bottom status bar remote chip, or run `Add Remote` from the command palette.
+2. Paste the remote URL.
+3. Confirm the remote name.
+4. Fetch or push according to the app prompt.
+
+## Recommended Auth
+
+- SSH keys.
+- GitHub CLI authentication.
+- Existing Git credential helpers.
+
+If authentication fails, see [Git Authentication](/troubleshooting/git-auth).
+

site/guides/create-types.md

@@ -0,0 +1,27 @@
+# Create Types
+
+Create a type when several notes share the same role in your system.
+
+## Steps
+
+1. Create a note in the `type/` folder.
+2. Set `type: Type` in frontmatter.
+3. Give the document a clear H1.
+4. Add optional icon, color, sort, and sidebar label.
+
+```yaml
+---
+type: Type
+icon: briefcase
+color: blue
+sidebar_label: Projects
+sort: modified:desc
+---
+
+# Project
+```
+
+## Use Types Sparingly
+
+A type should represent a recurring category, not a one-off label. If you only need a temporary grouping, use a saved view or property instead.
+

site/guides/organize-inbox.md

@@ -0,0 +1,26 @@
+# Organize The Inbox
+
+Inbox review turns quick captures into usable knowledge.
+
+## Review Checklist
+
+- Rename unclear notes.
+- Add or correct the first H1.
+- Set `type`.
+- Add `status` for actionable notes.
+- Add `belongs_to`, `related_to`, or other relationship fields when useful.
+- Archive or delete notes that no longer matter.
+
+## Make Notes Navigable
+
+A note is organized when you can answer:
+
+- What kind of thing is this?
+- What is it connected to?
+- What should happen next?
+- Where would I expect to find it later?
+
+## Avoid Over-Structuring
+
+Do not add fields just because they exist. Add the structure that will help future navigation, review, or automation.
+

site/guides/use-ai-panel.md

@@ -0,0 +1,19 @@
+# Use The AI Panel
+
+The AI panel connects Tolaria to local CLI agents.
+
+## Before Using It
+
+Install a supported agent such as Claude Code and make sure it is available from your shell. Tolaria detects common install locations, but explicit shell availability is still the simplest setup.
+
+## Good Requests
+
+- "Find notes related to this project."
+- "Summarize what changed in this note."
+- "Draft a weekly review from these linked notes."
+- "Update this checklist based on the current project status."
+
+## Review Changes
+
+AI edits are file edits. Review them with Tolaria's diff and Git history before committing.
+

site/guides/use-command-palette.md

@@ -0,0 +1,24 @@
+# Use The Command Palette
+
+The command palette is the fastest way to move around Tolaria.
+
+Open it with:
+
+- `Cmd+K` on macOS.
+- `Ctrl+K` on Linux and Windows.
+
+## Common Commands
+
+- New Note.
+- Search.
+- Open Settings.
+- Reload Vault.
+- Add Remote.
+- Open Getting Started Vault.
+- Toggle Raw Mode.
+- Open in New Window.
+
+## Keyboard-First Workflow
+
+Use the palette when you know what you want to do but do not want to hunt through panels. It is also the best place to discover commands as the app grows.
+

site/guides/use-wikilinks.md

@@ -0,0 +1,25 @@
+# Use Wikilinks
+
+Wikilinks connect notes by name.
+
+```md
+This project belongs to [[content-systems]] and is related to [[git-workflows]].
+```
+
+## Link From The Body
+
+Use body links when the connection is part of the sentence you are writing.
+
+## Link From Frontmatter
+
+Use frontmatter links when the relationship should become structured metadata.
+
+```yaml
+related_to:
+  - "[[git-workflows]]"
+```
+
+## Keep Links Stable
+
+Prefer clear note titles and filenames. Use aliases when people or projects are known by multiple names.
+

site/index.md

@@ -0,0 +1,10 @@
+---
+layout: page
+sidebar: false
+aside: false
+landing: true
+title: Tolaria
+description: A second brain for the AI era. Free forever.
+---
+
+<LandingHome />

site/public/tolaria-icon.svg

@@ -0,0 +1,10 @@
+<svg width="266" height="363" viewBox="0 0 266 363" fill="none" xmlns="http://www.w3.org/2000/svg">
+<g clip-path="url(#clip0_111_151)">
+<path fill-rule="evenodd" clip-rule="evenodd" d="M119.524 5.31219C126.607 -1.77073 138.117 -1.77073 145.2 5.31219C178.844 40.7268 265.61 147.856 265.61 230.195C265.61 303.68 206.29 363 132.805 363C59.3195 363 0 303.68 0 230.195C0 147.856 86.7659 40.7268 119.524 5.31219ZM59.5947 242.88C58.1619 234.744 50.3952 229.074 42.2195 230.195C34.0438 231.316 28.5932 238.799 30.0259 246.935C37.6847 290.425 72.2734 325.622 116.094 334.485C117.821 334.836 119.552 334.864 121.178 334.641C127.269 333.806 132.289 329.26 133.371 322.934C134.756 314.893 129.25 307.054 121.086 305.401C89.7767 299.057 65.0615 273.923 59.5947 242.88Z" fill="#155DFF"/>
+</g>
+<defs>
+<clipPath id="clip0_111_151">
+<rect width="266" height="363" fill="white"/>
+</clipPath>
+</defs>
+</svg>

site/reference/docs-maintenance.md

@@ -0,0 +1,38 @@
+# Docs Maintenance
+
+The public docs live in the app repo so documentation changes can ship with behavior changes.
+
+## Update Docs When You Change
+
+- A Tauri command.
+- A new component or hook that changes user behavior.
+- A data model or frontmatter convention.
+- Git, AI, onboarding, or release behavior.
+- Platform support.
+- Keyboard shortcuts.
+
+## Suggested Workflow
+
+1. Make the code change.
+2. Update the matching concept, guide, or reference page.
+3. Add a troubleshooting page if the change creates a new failure mode.
+4. Run `pnpm docs:build`.
+5. Check the home page, search, and changed docs pages in a browser.
+
+## Page Types
+
+| Type | Purpose |
+| --- | --- |
+| Start | Helps a new user get into the app. |
+| Concepts | Explains mental models. |
+| Guides | Teaches workflows. |
+| Reference | Gives stable facts and tables. |
+| Troubleshooting | Starts from a symptom and ends with recovery. |
+
+## Review Checklist
+
+- Does the page describe current behavior?
+- Does it mention macOS primary and Linux/Windows best effort when platform support matters?
+- Are links relative and VitePress-compatible?
+- Can a user discover the page with local search?
+

site/reference/file-layout.md

@@ -0,0 +1,35 @@
+# File Layout
+
+A typical vault stays simple.
+
+```txt
+my-vault/
+  project-alpha.md
+  weekly-review.md
+  people/
+    ada-lovelace.md
+  attachments/
+    diagram.png
+  type/
+    project.md
+    person.md
+  views/
+    active-projects.yml
+```
+
+## Root Notes
+
+Tolaria can work with flat vaults and nested folders. Type is not inferred from folder location; it comes from frontmatter.
+
+## Special Folders
+
+| Folder | Purpose |
+| --- | --- |
+| `type/` | Type definition documents. |
+| `views/` | Saved custom views. |
+| `attachments/` | Images and other attached files. |
+
+## Git Files
+
+If the vault is a Git repository, `.git/` belongs to Git. Tolaria reads Git state but does not treat `.git/` as notes.
+

site/reference/frontmatter-fields.md

@@ -0,0 +1,26 @@
+# Frontmatter Fields
+
+Tolaria uses conventions instead of a required schema.
+
+| Field | Meaning |
+| --- | --- |
+| `type` | The note's entity type. |
+| `status` | Lifecycle state. |
+| `icon` | Per-note icon. |
+| `url` | External URL. |
+| `date` | Single date. |
+| `start_date` | Start of a date range. |
+| `end_date` | End of a date range. |
+| `aliases` | Alternative names for link resolution. |
+| `belongs_to` | Parent relationship. |
+| `related_to` | Lateral relationship. |
+| `has` | Contained relationship. |
+
+## Custom Fields
+
+You can add your own fields. If a field contains wikilinks, Tolaria can treat it as a relationship.
+
+## System Fields
+
+Fields starting with `_` are reserved for system behavior and hidden from standard property editing.
+

site/reference/keyboard-shortcuts.md

@@ -0,0 +1,15 @@
+# Keyboard Shortcuts
+
+| Shortcut | Action |
+| --- | --- |
+| `Cmd+K` / `Ctrl+K` | Open command palette. |
+| `Cmd+N` / `Ctrl+N` | Create a new note. |
+| `Cmd+S` / `Ctrl+S` | Save current note. |
+| `Cmd+[` / `Alt+Left` | Navigate back when available. |
+| `Cmd+]` / `Alt+Right` | Navigate forward when available. |
+| `Cmd+Shift+O` / `Ctrl+Shift+O` | Open current note in a new window. |
+
+Some shortcuts vary by platform because macOS, Linux, and Windows reserve different key combinations.
+
+Use the command palette to discover the current command set.
+

site/reference/supported-platforms.md

@@ -0,0 +1,24 @@
+# Supported Platforms
+
+Tolaria is a desktop app built with Tauri.
+
+| Platform | Current support | Notes |
+| --- | --- | --- |
+| macOS | Primary | Main development and QA target. Apple Silicon is first-class. |
+| Linux | Best effort | Depends on distribution WebKitGTK packaging and desktop integration behavior. |
+| Windows | Best effort | Builds exist, but platform-specific behavior may lag macOS. |
+
+## Support Policy
+
+Primary support means the platform is part of normal development and release validation. Best-effort support means builds may be available, but bugs can take longer to diagnose and fix.
+
+## Reporting Platform Bugs
+
+Include:
+
+- Tolaria version.
+- Operating system and version.
+- CPU architecture.
+- Whether the vault is local-only or connected to a remote.
+- Steps to reproduce.
+

site/reference/view-filters.md

@@ -0,0 +1,26 @@
+# View Filters
+
+View filters define saved lists of notes.
+
+## Common Filter Ideas
+
+| Goal | Filter direction |
+| --- | --- |
+| Active projects | `type` is Project and `status` is Active |
+| Drafts | `type` is Article and `status` is Draft |
+| People follow-up | `type` is Person and date is before today |
+| Recent work | modified date is within a recent range |
+
+## Sorting
+
+Useful sorts include:
+
+- Recently modified first.
+- Title ascending.
+- Status ascending.
+- A custom property ascending or descending.
+
+## Keep Views Focused
+
+A view should answer one recurring question. If it becomes too broad, split it into two views.
+

site/releases/index.md

@@ -0,0 +1,16 @@
+# Releases
+
+Tolaria releases are published on GitHub.
+
+- [Latest release](https://github.com/refactoringhq/tolaria/releases/latest)
+- [All releases](https://github.com/refactoringhq/tolaria/releases)
+- [Download page](/download/)
+
+## Release Channels
+
+Stable builds are intended for normal use. Pre-release builds may contain newer features and rougher edges.
+
+## Before Updating
+
+Commit or push important vault changes before updating the app. Your notes are local files, but having a clean Git state makes recovery easier.
+

site/start/first-launch.md

@@ -0,0 +1,32 @@
+# First Launch
+
+The first launch flow is designed to get you into a real vault quickly without hiding the local-first model.
+
+## What You Choose
+
+Tolaria asks whether you want to:
+
+- Create or clone the Getting Started vault.
+- Open an existing local vault.
+- Create a new empty vault.
+
+The Getting Started vault is cloned locally and then disconnected from its remote. That keeps the sample safe to edit without accidentally pushing tutorial changes.
+
+## What Tolaria Creates
+
+Tolaria stores app-level settings on the local machine. Your notes stay in the vault folder you choose.
+
+| Data | Stored in |
+| --- | --- |
+| Notes and attachments | Your vault folder |
+| Type definitions and saved views | Your vault folder |
+| Window size, zoom, recent vaults | Local app settings |
+| Cache data | Rebuildable local cache |
+
+## First Commands To Try
+
+- `Cmd+K` / `Ctrl+K`: open the command palette.
+- `New Note`: create a note in the current vault.
+- `Open Getting Started Vault`: clone the public sample vault.
+- `Reload Vault`: rescan files after external edits.
+

site/start/getting-started-vault.md

@@ -0,0 +1,24 @@
+# Getting Started Vault
+
+The Getting Started vault is a small public sample vault hosted at [refactoringhq/tolaria-getting-started](https://github.com/refactoringhq/tolaria-getting-started).
+
+It exists to show Tolaria's conventions without requiring you to restructure your own notes first.
+
+## What It Demonstrates
+
+- Markdown notes with YAML frontmatter.
+- Types such as Project, Person, Topic, and Procedure.
+- Wikilinks in note bodies.
+- Relationship fields in frontmatter.
+- A local Git repository that can be connected to a remote later.
+
+## Local-Only By Default
+
+When Tolaria clones the sample, it removes the remote from the local copy. This makes the sample vault disposable. You can edit it freely, commit locally, and delete it later.
+
+To connect a vault to your own remote, use the bottom status bar remote chip or run `Add Remote` from the command palette.
+
+## When To Move On
+
+After you understand the sample, open your own vault. Tolaria does not require a special folder structure: a folder of Markdown files is enough to start.
+

site/start/install.md

@@ -0,0 +1,28 @@
+# Install Tolaria
+
+Tolaria is developed and tested primarily on macOS. Linux and Windows builds are published on a best-effort basis while the app matures.
+
+## Download
+
+Use the latest stable release unless you are intentionally testing pre-release builds:
+
+- [Download the latest stable build](https://refactoringhq.github.io/tolaria/download/)
+- [Browse all GitHub releases](https://github.com/refactoringhq/tolaria/releases)
+- [Read the release notes](/releases/)
+
+## Platform Status
+
+| Platform | Status | Notes |
+| --- | --- | --- |
+| macOS | Primary | Apple Silicon is the first-class desktop target. |
+| Linux | Best effort | Builds exist, but desktop integration varies by distribution and WebKitGTK packaging. |
+| Windows | Best effort | Builds exist, but behavior may lag macOS while the app is still early. |
+
+See [Supported Platforms](/reference/supported-platforms) for the current support policy.
+
+## After Installing
+
+1. Open Tolaria.
+2. Choose the Getting Started vault if you want a guided sample.
+3. Or open an existing folder of Markdown files as a vault.
+4. Use the command palette with `Cmd+K` on macOS or `Ctrl+K` on Linux and Windows.

site/start/open-or-create-vault.md

@@ -0,0 +1,25 @@
+# Open Or Create A Vault
+
+A Tolaria vault is a folder on disk. The folder can contain Markdown notes, attachments, type definitions, saved views, and Git metadata.
+
+## Open An Existing Folder
+
+Choose an existing folder if you already have Markdown notes. Tolaria scans `.md` files and uses frontmatter when it exists.
+
+Good starting points:
+
+- A folder of plain Markdown files.
+- An Obsidian-style vault.
+- A Git repository containing notes.
+- A copy of the Getting Started vault.
+
+## Create A New Vault
+
+Choose a new empty folder if you want Tolaria conventions from the start. New notes are created as Markdown files, and optional type definitions live in the `type/` folder.
+
+## Git Repository Requirement
+
+Tolaria's history and sync features expect the vault to be a Git repository. If a vault is not already a repository, Tolaria can initialize one for you.
+
+Use Git because it gives Tolaria reliable local history, diff views, recovery, and remote sync without a proprietary backend.
+

site/troubleshooting/ai-agent-not-found.md

@@ -0,0 +1,23 @@
+# AI Agent Not Found
+
+Tolaria can only launch local CLI agents that are installed and discoverable.
+
+## Symptoms
+
+- The AI panel says no supported agent is available.
+- Claude Code or another agent works in one shell but not in Tolaria.
+
+## Checks
+
+Open a terminal and run the agent command directly. For Claude Code:
+
+```bash
+claude --version
+```
+
+If the command fails, install or repair the agent first.
+
+## Path Issues
+
+Desktop apps can inherit a different `PATH` from your interactive shell. Tolaria checks common install locations, but shell setup can still vary. Prefer installing CLI tools in standard locations or making them available from your login shell.
+

site/troubleshooting/git-auth.md

@@ -0,0 +1,26 @@
+# Git Authentication
+
+Tolaria uses system Git authentication. It does not manage provider passwords directly.
+
+## Symptoms
+
+- Push fails.
+- Pull asks for credentials repeatedly.
+- Remote fetch works in one terminal but not in Tolaria.
+
+## Checks
+
+1. Open a terminal.
+2. `cd` into the vault.
+3. Run `git remote -v`.
+4. Run `git fetch`.
+
+If `git fetch` fails in the terminal, fix system Git auth first.
+
+## Common Fixes
+
+- Sign in with GitHub CLI.
+- Configure SSH keys.
+- Update the remote URL.
+- Check your credential helper.
+

site/troubleshooting/sync-conflicts.md

@@ -0,0 +1,20 @@
+# Sync Conflicts
+
+Sync conflicts happen when local and remote changes touch the same content.
+
+## What To Do
+
+1. Stop editing the conflicted note.
+2. Open the conflict resolver if Tolaria presents it.
+3. Review both sides.
+4. Choose the correct content or merge manually.
+5. Commit the resolved file.
+6. Push again.
+
+## Prevent Conflicts
+
+- Pull before starting work on another device.
+- Push after meaningful sessions.
+- Keep AI-generated edits in small commits.
+- Avoid editing the same note on multiple devices at the same time.
+

site/troubleshooting/vault-not-loading.md

@@ -0,0 +1,25 @@
+# Vault Not Loading
+
+Use this checklist when Tolaria cannot open or refresh a vault.
+
+## Check The Folder
+
+- Confirm the folder exists.
+- Confirm the folder contains readable files.
+- Confirm Tolaria has permission to access the folder.
+- Try opening a smaller test vault to isolate the issue.
+
+## Check Git
+
+If the vault is a Git repository, verify it is not in a broken state:
+
+```bash
+git status
+```
+
+Resolve interrupted merges or corrupted repository state before retrying.
+
+## Reload
+
+Run `Reload Vault` from the command palette. This clears derived cache and rescans the filesystem.
+

src-tauri/capabilities/default.json

@@ -17,7 +17,6 @@
     "dialog:default",
     "updater:default",
     "process:default",
-    "opener:default",
-    "opener:allow-open-path"
+    "opener:default"
   ]
 }

src-tauri/src/ai_agents.rs

@@ -1,4 +1,7 @@
 use serde::{Deserialize, Serialize};
+use std::io::BufRead;
+use std::path::{Path, PathBuf};
+use std::process::Stdio;
 
 #[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
 #[serde(rename_all = "snake_case")]
@@ -9,14 +12,6 @@ pub enum AiAgentId {
     Pi,
 }
 
-#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Default)]
-#[serde(rename_all = "snake_case")]
-pub enum AiAgentPermissionMode {
-    #[default]
-    Safe,
-    PowerUser,
-}
-
 #[derive(Debug, Clone, Serialize)]
 pub struct AiAgentAvailability {
     pub installed: bool,
@@ -66,21 +61,14 @@ pub struct AiAgentStreamRequest {
     pub message: String,
     pub system_prompt: Option<String>,
     pub vault_path: String,
-    pub permission_mode: Option<AiAgentPermissionMode>,
-}
-
-impl AiAgentStreamRequest {
-    fn permission_mode(&self) -> AiAgentPermissionMode {
-        self.permission_mode.unwrap_or_default()
-    }
 }
 
 pub fn get_ai_agents_status() -> AiAgentsStatus {
     AiAgentsStatus {
         claude_code: availability_from_claude(),
-        codex: crate::codex_cli::check_cli(),
-        opencode: crate::opencode_cli::check_cli(),
-        pi: crate::pi_cli::check_cli(),
+        codex: availability_from_codex(),
+        opencode: availability_from_opencode(),
+        pi: availability_from_pi(),
     }
 }
 
@@ -88,14 +76,12 @@ pub fn run_ai_agent_stream<F>(request: AiAgentStreamRequest, mut emit: F) -> Res
 where
     F: FnMut(AiAgentStreamEvent),
 {
-    let permission_mode = request.permission_mode();
     match request.agent {
         AiAgentId::ClaudeCode => {
             let mapped = crate::claude_cli::AgentStreamRequest {
                 message: request.message,
                 system_prompt: request.system_prompt,
                 vault_path: request.vault_path,
-                permission_mode,
             };
             crate::claude_cli::run_agent_stream(mapped, |event| {
                 if let Some(mapped_event) = map_claude_event(event) {
@@ -103,21 +89,12 @@ where
                 }
             })
         }
-        AiAgentId::Codex => {
-            let mapped = crate::codex_cli::AgentStreamRequest {
-                message: request.message,
-                system_prompt: request.system_prompt,
-                vault_path: request.vault_path,
-                permission_mode,
-            };
-            crate::codex_cli::run_agent_stream(mapped, emit)
-        }
+        AiAgentId::Codex => run_codex_agent_stream(request, emit),
         AiAgentId::Opencode => {
             let mapped = crate::opencode_cli::AgentStreamRequest {
                 message: request.message,
                 system_prompt: request.system_prompt,
                 vault_path: request.vault_path,
-                permission_mode,
             };
             crate::opencode_cli::run_agent_stream(mapped, emit)
         }
@@ -126,7 +103,6 @@ where
                 message: request.message,
                 system_prompt: request.system_prompt,
                 vault_path: request.vault_path,
-                permission_mode,
             };
             crate::pi_cli::run_agent_stream(mapped, emit)
         }
@@ -141,6 +117,351 @@ fn availability_from_claude() -> AiAgentAvailability {
     }
 }
 
+fn availability_from_codex() -> AiAgentAvailability {
+    let binary = match find_codex_binary() {
+        Ok(binary) => binary,
+        Err(_) => {
+            return AiAgentAvailability {
+                installed: false,
+                version: None,
+            }
+        }
+    };
+
+    AiAgentAvailability {
+        installed: true,
+        version: version_for_binary(&binary),
+    }
+}
+
+fn availability_from_opencode() -> AiAgentAvailability {
+    crate::opencode_cli::check_cli()
+}
+
+fn availability_from_pi() -> AiAgentAvailability {
+    crate::pi_cli::check_cli()
+}
+
+fn version_for_binary(binary: &PathBuf) -> Option<String> {
+    crate::hidden_command(binary)
+        .arg("--version")
+        .output()
+        .ok()
+        .filter(|output| output.status.success())
+        .map(|output| String::from_utf8_lossy(&output.stdout).trim().to_string())
+}
+
+fn find_codex_binary() -> Result<PathBuf, String> {
+    if let Some(binary) = find_codex_binary_on_path() {
+        return Ok(binary);
+    }
+
+    if let Some(binary) = find_codex_binary_in_user_shell() {
+        return Ok(binary);
+    }
+
+    if let Some(binary) = find_existing_binary(codex_binary_candidates()) {
+        return Ok(binary);
+    }
+
+    Err("Codex CLI not found. Install it: https://developers.openai.com/codex/cli".into())
+}
+
+fn find_codex_binary_on_path() -> Option<PathBuf> {
+    crate::hidden_command("which")
+        .arg("codex")
+        .output()
+        .ok()
+        .and_then(|output| path_from_successful_output(&output))
+}
+
+fn find_codex_binary_in_user_shell() -> Option<PathBuf> {
+    user_shell_candidates()
+        .into_iter()
+        .filter(|shell| shell.exists())
+        .find_map(|shell| command_path_from_shell(&shell, "codex"))
+}
+
+fn user_shell_candidates() -> Vec<PathBuf> {
+    let mut shells = Vec::new();
+    if let Some(shell) = std::env::var_os("SHELL") {
+        if !shell.is_empty() {
+            shells.push(PathBuf::from(shell));
+        }
+    }
+    shells.push(PathBuf::from("/bin/zsh"));
+    shells.push(PathBuf::from("/bin/bash"));
+    shells
+}
+
+fn command_path_from_shell(shell: &Path, command: &str) -> Option<PathBuf> {
+    crate::hidden_command(shell)
+        .arg("-lc")
+        .arg(format!("command -v {command}"))
+        .output()
+        .ok()
+        .and_then(|output| path_from_successful_output(&output))
+}
+
+fn path_from_successful_output(output: &std::process::Output) -> Option<PathBuf> {
+    if output.status.success() {
+        first_existing_path(&String::from_utf8_lossy(&output.stdout))
+    } else {
+        None
+    }
+}
+
+fn first_existing_path(stdout: &str) -> Option<PathBuf> {
+    stdout.lines().find_map(|line| {
+        let trimmed = line.trim();
+        if trimmed.is_empty() {
+            return None;
+        }
+        let candidate = PathBuf::from(trimmed);
+        candidate.exists().then_some(candidate)
+    })
+}
+
+fn codex_binary_candidates() -> Vec<PathBuf> {
+    dirs::home_dir()
+        .map(|home| codex_binary_candidates_for_home(&home))
+        .unwrap_or_default()
+}
+
+fn codex_binary_candidates_for_home(home: &Path) -> Vec<PathBuf> {
+    vec![
+        home.join(".local/bin/codex"),
+        home.join(".codex/bin/codex"),
+        home.join(".local/share/mise/shims/codex"),
+        home.join(".asdf/shims/codex"),
+        home.join(".npm-global/bin/codex"),
+        home.join(".npm/bin/codex"),
+        home.join(".bun/bin/codex"),
+        PathBuf::from("/usr/local/bin/codex"),
+        PathBuf::from("/opt/homebrew/bin/codex"),
+        PathBuf::from("/Applications/Codex.app/Contents/Resources/codex"),
+    ]
+}
+
+fn find_existing_binary(candidates: Vec<PathBuf>) -> Option<PathBuf> {
+    candidates.into_iter().find(|candidate| candidate.exists())
+}
+
+fn run_codex_agent_stream<F>(request: AiAgentStreamRequest, mut emit: F) -> Result<String, String>
+where
+    F: FnMut(AiAgentStreamEvent),
+{
+    let binary = find_codex_binary()?;
+    let args = build_codex_args(&request)?;
+    let prompt = build_codex_prompt(&request);
+
+    let mut command = build_codex_command(&binary, args, prompt, &request.vault_path);
+
+    let mut child = command
+        .spawn()
+        .map_err(|error| format!("Failed to spawn codex: {error}"))?;
+
+    let stdout = child.stdout.take().ok_or("No stdout handle")?;
+    let reader = std::io::BufReader::new(stdout);
+
+    let mut thread_id = String::new();
+
+    for line in reader.lines() {
+        let line = match line {
+            Ok(line) => line,
+            Err(error) => {
+                emit(AiAgentStreamEvent::Error {
+                    message: format!("Read error: {error}"),
+                });
+                break;
+            }
+        };
+
+        if line.trim().is_empty() {
+            continue;
+        }
+
+        let json = match serde_json::from_str::<serde_json::Value>(&line) {
+            Ok(json) => json,
+            Err(_) => continue,
+        };
+
+        if let Some(id) = json["thread_id"].as_str() {
+            thread_id = id.to_string();
+        }
+
+        dispatch_codex_event(&json, &mut emit);
+    }
+
+    let stderr_output = child
+        .stderr
+        .take()
+        .and_then(|stderr| std::io::read_to_string(stderr).ok())
+        .unwrap_or_default();
+
+    let status = child
+        .wait()
+        .map_err(|error| format!("Wait failed: {error}"))?;
+    if !status.success() {
+        emit(AiAgentStreamEvent::Error {
+            message: format_codex_error(stderr_output, status.to_string()),
+        });
+    }
+
+    emit(AiAgentStreamEvent::Done);
+
+    Ok(thread_id)
+}
+
+fn build_codex_command(
+    binary: &Path,
+    args: Vec<String>,
+    prompt: String,
+    vault_path: &str,
+) -> std::process::Command {
+    let mut command = crate::hidden_command(binary);
+    command
+        .args(args)
+        .arg(prompt)
+        .current_dir(vault_path)
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped());
+    command
+}
+
+fn build_codex_args(request: &AiAgentStreamRequest) -> Result<Vec<String>, String> {
+    let mcp_server = crate::mcp::mcp_server_dir()?.join("index.js");
+    let mcp_server_path = mcp_server
+        .to_str()
+        .ok_or("Invalid MCP server path")?
+        .to_string();
+
+    Ok(vec![
+        "--sandbox".into(),
+        "workspace-write".into(),
+        "--ask-for-approval".into(),
+        "never".into(),
+        "exec".into(),
+        "--json".into(),
+        "-C".into(),
+        request.vault_path.clone(),
+        "-c".into(),
+        r#"mcp_servers.tolaria.command="node""#.into(),
+        "-c".into(),
+        format!(r#"mcp_servers.tolaria.args=["{}"]"#, mcp_server_path),
+        "-c".into(),
+        format!(
+            r#"mcp_servers.tolaria.env={{VAULT_PATH="{}"}}"#,
+            request.vault_path
+        ),
+    ])
+}
+
+fn build_codex_prompt(request: &AiAgentStreamRequest) -> String {
+    match request
+        .system_prompt
+        .as_ref()
+        .map(|prompt| prompt.trim())
+        .filter(|prompt| !prompt.is_empty())
+    {
+        Some(system_prompt) => format!(
+            "System instructions:\n{system_prompt}\n\nUser request:\n{}",
+            request.message
+        ),
+        None => request.message.clone(),
+    }
+}
+
+fn dispatch_codex_event<F>(json: &serde_json::Value, emit: &mut F)
+where
+    F: FnMut(AiAgentStreamEvent),
+{
+    match json["type"].as_str().unwrap_or_default() {
+        "thread.started" => {
+            if let Some(thread_id) = json["thread_id"].as_str() {
+                emit(AiAgentStreamEvent::Init {
+                    session_id: thread_id.to_string(),
+                });
+            }
+        }
+        "item.started" => emit_codex_item_event(json, false, emit),
+        "item.completed" => emit_codex_item_event(json, true, emit),
+        _ => {}
+    }
+}
+
+fn emit_codex_item_event<F>(json: &serde_json::Value, completed: bool, emit: &mut F)
+where
+    F: FnMut(AiAgentStreamEvent),
+{
+    let item = &json["item"];
+    let item_type = item["type"].as_str().unwrap_or_default();
+    let item_id = item["id"].as_str().unwrap_or_default();
+
+    match item_type {
+        "command_execution" => {
+            if completed {
+                emit(AiAgentStreamEvent::ToolDone {
+                    tool_id: item_id.to_string(),
+                    output: item["aggregated_output"]
+                        .as_str()
+                        .map(|output| output.to_string()),
+                });
+            } else {
+                emit(AiAgentStreamEvent::ToolStart {
+                    tool_name: "Bash".into(),
+                    tool_id: item_id.to_string(),
+                    input: item["command"]
+                        .as_str()
+                        .map(|command| serde_json::json!({ "command": command }).to_string()),
+                });
+            }
+        }
+        "agent_message" if completed => {
+            if let Some(text) = item["text"].as_str() {
+                emit(AiAgentStreamEvent::TextDelta {
+                    text: text.to_string(),
+                });
+            }
+        }
+        _ => {}
+    }
+}
+
+fn format_codex_error(stderr_output: String, status: String) -> String {
+    let lower = stderr_output.to_ascii_lowercase();
+    if is_codex_auth_error(&lower) {
+        return "Codex CLI is not authenticated. Run `codex login` or launch `codex` in your terminal.".into();
+    }
+
+    if is_codex_write_permission_error(&lower) {
+        return "Codex could not write to the active vault. Tolaria starts Codex with a workspace-write sandbox, so verify the selected vault folder is writable and retry; writes outside the active vault remain blocked.".into();
+    }
+
+    if stderr_output.trim().is_empty() {
+        format!("codex exited with status {status}")
+    } else {
+        stderr_output.lines().take(3).collect::<Vec<_>>().join("\n")
+    }
+}
+
+fn is_codex_auth_error(lower: &str) -> bool {
+    ["auth", "login", "sign in"]
+        .iter()
+        .any(|pattern| lower.contains(pattern))
+}
+
+fn is_codex_write_permission_error(lower: &str) -> bool {
+    [
+        "read-only sandbox",
+        "writing is blocked",
+        "rejected by user approval",
+        "rejected by the environment",
+    ]
+    .iter()
+    .any(|pattern| lower.contains(pattern))
+}
+
 fn map_claude_event(event: crate::claude_cli::ClaudeStreamEvent) -> Option<AiAgentStreamEvent> {
     match event {
         crate::claude_cli::ClaudeStreamEvent::Init { session_id } => {
@@ -178,20 +499,193 @@ fn map_claude_event(event: crate::claude_cli::ClaudeStreamEvent) -> Option<AiAge
 #[cfg(test)]
 mod tests {
     use super::*;
+    use std::ffi::OsStr;
 
     #[test]
     fn normalize_status_contains_all_agents() {
         let status = get_ai_agents_status();
-        let install_flags = [
-            status.claude_code.installed,
-            status.codex.installed,
-            status.opencode.installed,
-            status.pi.installed,
+        assert!(matches!(status.claude_code.installed, true | false));
+        assert!(matches!(status.codex.installed, true | false));
+        assert!(matches!(status.opencode.installed, true | false));
+        assert!(matches!(status.pi.installed, true | false));
+    }
+
+    #[test]
+    fn build_codex_prompt_keeps_system_prompt_first() {
+        let prompt = build_codex_prompt(&AiAgentStreamRequest {
+            agent: AiAgentId::Codex,
+            message: "Rename the note".into(),
+            system_prompt: Some("Be concise".into()),
+            vault_path: "/tmp/vault".into(),
+        });
+
+        assert!(prompt.starts_with("System instructions:\nBe concise"));
+        assert!(prompt.contains("User request:\nRename the note"));
+    }
+
+    #[test]
+    fn build_codex_args_uses_safe_default_permissions() {
+        if let Ok(args) = build_codex_args(&AiAgentStreamRequest {
+            agent: AiAgentId::Codex,
+            message: "Rename the note".into(),
+            system_prompt: None,
+            vault_path: "/tmp/vault".into(),
+        }) {
+            assert_eq!(args[0], "--sandbox");
+            assert_eq!(args[1], "workspace-write");
+            assert_eq!(args[2], "--ask-for-approval");
+            assert_eq!(args[3], "never");
+            assert_eq!(args[4], "exec");
+            assert!(!args.contains(&"--dangerously-bypass-approvals-and-sandbox".to_string()));
+            assert!(!args.contains(&"danger-full-access".to_string()));
+            assert!(args.contains(&"--json".to_string()));
+            assert!(args.contains(&"-C".to_string()));
+        }
+    }
+
+    #[test]
+    fn build_codex_command_keeps_agent_process_contract() {
+        let binary = PathBuf::from("codex");
+        let args = vec!["exec".to_string(), "--json".to_string()];
+        let command = build_codex_command(&binary, args, "Summarize".into(), "/tmp/vault");
+        let actual_args: Vec<&OsStr> = command.get_args().collect();
+
+        assert_eq!(command.get_program(), OsStr::new("codex"));
+        assert_eq!(
+            actual_args,
+            vec![
+                OsStr::new("exec"),
+                OsStr::new("--json"),
+                OsStr::new("Summarize")
+            ]
+        );
+        assert_eq!(command.get_current_dir(), Some(Path::new("/tmp/vault")));
+    }
+
+    #[test]
+    fn codex_binary_candidates_include_supported_macos_installs() {
+        let home = PathBuf::from("/Users/alex");
+        let candidates = codex_binary_candidates_for_home(&home);
+        let expected = [
+            home.join(".local/bin/codex"),
+            home.join(".codex/bin/codex"),
+            home.join(".local/share/mise/shims/codex"),
+            home.join(".asdf/shims/codex"),
+            home.join(".npm-global/bin/codex"),
+            home.join(".bun/bin/codex"),
+            PathBuf::from("/Applications/Codex.app/Contents/Resources/codex"),
         ];
 
-        assert!(install_flags
-            .iter()
-            .all(|installed| matches!(installed, true | false)));
+        for candidate in expected {
+            assert!(
+                candidates.contains(&candidate),
+                "missing {}",
+                candidate.display()
+            );
+        }
+    }
+
+    #[test]
+    fn first_existing_path_skips_empty_and_missing_lines() {
+        let dir = tempfile::tempdir().unwrap();
+        let missing = dir.path().join("missing-codex");
+        let codex = dir.path().join("codex");
+        std::fs::write(&codex, "#!/bin/sh\n").unwrap();
+
+        let stdout = format!("\n{}\n{}\n", missing.display(), codex.display());
+
+        assert_eq!(first_existing_path(&stdout), Some(codex));
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn command_path_from_shell_finds_codex_from_login_shell() {
+        use std::os::unix::fs::PermissionsExt;
+
+        let dir = tempfile::tempdir().unwrap();
+        let codex = dir.path().join("codex");
+        std::fs::write(&codex, "#!/bin/sh\n").unwrap();
+        std::fs::set_permissions(&codex, std::fs::Permissions::from_mode(0o755)).unwrap();
+
+        let shell = dir.path().join("shell");
+        std::fs::write(
+            &shell,
+            format!(
+                "#!/bin/sh\nif [ \"$1\" = \"-lc\" ]; then echo '{}'; fi\n",
+                codex.display()
+            ),
+        )
+        .unwrap();
+        std::fs::set_permissions(&shell, std::fs::Permissions::from_mode(0o755)).unwrap();
+
+        assert_eq!(command_path_from_shell(&shell, "codex"), Some(codex));
+    }
+
+    #[test]
+    fn dispatch_codex_command_events_maps_to_bash_events() {
+        let mut events = Vec::new();
+        let started = serde_json::json!({
+            "type": "item.started",
+            "item": {
+                "id": "item_1",
+                "type": "command_execution",
+                "command": "/bin/zsh -lc pwd"
+            }
+        });
+        let completed = serde_json::json!({
+            "type": "item.completed",
+            "item": {
+                "id": "item_1",
+                "type": "command_execution",
+                "aggregated_output": "/private/tmp\n"
+            }
+        });
+
+        dispatch_codex_event(&started, &mut |event| events.push(event));
+        dispatch_codex_event(&completed, &mut |event| events.push(event));
+
+        assert!(matches!(
+            &events[0],
+            AiAgentStreamEvent::ToolStart { tool_name, tool_id, .. }
+                if tool_name == "Bash" && tool_id == "item_1"
+        ));
+        assert!(matches!(
+            &events[1],
+            AiAgentStreamEvent::ToolDone { tool_id, output }
+                if tool_id == "item_1" && output.as_deref() == Some("/private/tmp\n")
+        ));
+    }
+
+    #[test]
+    fn dispatch_codex_agent_message_maps_to_text_delta() {
+        let mut events = Vec::new();
+        let completed = serde_json::json!({
+            "type": "item.completed",
+            "item": {
+                "id": "item_2",
+                "type": "agent_message",
+                "text": "All set"
+            }
+        });
+
+        dispatch_codex_event(&completed, &mut |event| events.push(event));
+
+        assert!(matches!(
+            &events[0],
+            AiAgentStreamEvent::TextDelta { text } if text == "All set"
+        ));
+    }
+
+    #[test]
+    fn format_codex_error_explains_vault_write_permission_failures() {
+        let message = format_codex_error(
+            "The patch was rejected by the environment: writing is blocked by read-only sandbox; rejected by user approval settings".into(),
+            "exit status: 1".into(),
+        );
+
+        assert!(message.contains("active vault"));
+        assert!(message.contains("writable"));
+        assert!(message.contains("outside"));
     }
 
     #[test]

src-tauri/src/claude_cli.rs

@@ -1,7 +1,6 @@
-use crate::ai_agents::AiAgentPermissionMode;
-pub use crate::cli_agent_runtime::AgentStreamRequest;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
+use std::io::BufRead;
 use std::path::{Path, PathBuf};
 use std::process::{ExitStatus, Stdio};
 
@@ -51,6 +50,14 @@ pub struct ChatStreamRequest {
     pub session_id: Option<String>,
 }
 
+/// Parameters accepted by Claude Code agent streams.
+#[derive(Debug, Deserialize)]
+pub struct AgentStreamRequest {
+    pub message: String,
+    pub system_prompt: Option<String>,
+    pub vault_path: String,
+}
+
 // ---------------------------------------------------------------------------
 // Finding the `claude` binary
 // ---------------------------------------------------------------------------
@@ -141,7 +148,7 @@ fn claude_binary_candidates() -> Vec<PathBuf> {
 }
 
 fn claude_binary_candidates_for_home(home: &Path) -> Vec<PathBuf> {
-    let mut candidates = vec![
+    vec![
         home.join(".local/bin/claude"),
         home.join(".local/bin/claude.exe"),
         home.join(".claude/local/claude"),
@@ -163,24 +170,7 @@ fn claude_binary_candidates_for_home(home: &Path) -> Vec<PathBuf> {
         home.join("scoop/shims/claude.exe"),
         PathBuf::from("/opt/homebrew/bin/claude"),
         PathBuf::from("/usr/local/bin/claude"),
-    ];
-    candidates.extend(nvm_node_binary_candidates_for_home(home, "claude"));
-    candidates
-}
-
-fn nvm_node_binary_candidates_for_home(home: &Path, binary_name: &str) -> Vec<PathBuf> {
-    let Ok(entries) = std::fs::read_dir(home.join(".nvm/versions/node")) else {
-        return Vec::new();
-    };
-
-    let mut candidates = entries
-        .filter_map(Result::ok)
-        .map(|entry| entry.path())
-        .filter(|path| path.is_dir())
-        .map(|path| path.join("bin").join(binary_name))
-        .collect::<Vec<_>>();
-    candidates.sort();
-    candidates
+    ]
 }
 
 fn find_existing_binary(candidates: Vec<PathBuf>) -> Option<PathBuf> {
@@ -203,9 +193,16 @@ pub fn check_cli() -> ClaudeCliStatus {
         }
     };
 
+    let version = crate::hidden_command(&bin)
+        .arg("--version")
+        .output()
+        .ok()
+        .filter(|o| o.status.success())
+        .map(|o| String::from_utf8_lossy(&o.stdout).trim().to_string());
+
     ClaudeCliStatus {
         installed: true,
-        version: crate::cli_agent_runtime::version_for_binary(&bin),
+        version,
     }
 }
 
@@ -276,7 +273,7 @@ fn build_agent_args(req: &AgentStreamRequest) -> Result<Vec<String>, String> {
         "--permission-mode".into(),
         "acceptEdits".into(),
         "--tools".into(),
-        agent_tools(req.permission_mode).into(),
+        "Read,Edit,MultiEdit,Write,Glob,Grep,LS".into(),
         "--no-session-persistence".into(),
     ];
 
@@ -290,25 +287,19 @@ fn build_agent_args(req: &AgentStreamRequest) -> Result<Vec<String>, String> {
     Ok(args)
 }
 
-fn agent_tools(permission_mode: AiAgentPermissionMode) -> &'static str {
-    match permission_mode {
-        AiAgentPermissionMode::Safe => "Read,Edit,MultiEdit,Write,Glob,Grep,LS",
-        AiAgentPermissionMode::PowerUser => "Read,Edit,MultiEdit,Write,Glob,Grep,LS,Bash",
-    }
-}
-
 // ---------------------------------------------------------------------------
 // Internal helpers
 // ---------------------------------------------------------------------------
 
 /// Build a temporary MCP config JSON string pointing to the vault MCP server.
 fn build_mcp_config(vault_path: &str) -> Result<String, String> {
-    let mcp_server_path = crate::cli_agent_runtime::mcp_server_path_string()?;
+    let server_dir = crate::mcp::mcp_server_dir()?;
+    let index_js = server_dir.join("index.js");
     let config = serde_json::json!({
         "mcpServers": {
             "tolaria": {
                 "command": "node",
-                "args": [mcp_server_path],
+                "args": [index_js.to_string_lossy()],
                 "env": { "VAULT_PATH": vault_path }
             }
         }
@@ -323,8 +314,6 @@ struct StreamState {
     tool_inputs: HashMap<String, String>,
     /// The tool_use id of the block currently being streamed.
     current_tool_id: Option<String>,
-    /// Tracks whether response text has already been emitted for this run.
-    emitted_text: bool,
 }
 
 /// Core subprocess runner shared by chat and agent modes.
@@ -338,28 +327,55 @@ fn run_claude_subprocess<F>(
 where
     F: FnMut(ClaudeStreamEvent),
 {
+    let mut cmd = build_claude_command(bin, args, cwd);
+    let mut child = cmd
+        .spawn()
+        .map_err(|e| format!("Failed to spawn claude: {e}"))?;
+
+    let stdout = child.stdout.take().ok_or("No stdout handle")?;
+    let reader = std::io::BufReader::new(stdout);
+
     let mut state = StreamState {
         session_id: String::new(),
         tool_inputs: HashMap::new(),
         current_tool_id: None,
-        emitted_text: false,
     };
 
-    let cmd = build_claude_command(bin, args, cwd);
-    let run = crate::cli_agent_runtime::run_json_line_process(
-        cmd,
-        "claude",
-        emit,
-        |message| ClaudeStreamEvent::Error { message },
-        |json, emit, session_id| {
-            dispatch_event(json, &mut state, emit);
-            *session_id = state.session_id.clone();
-        },
-    )?;
+    for line in reader.lines() {
+        let line = match line {
+            Ok(l) => l,
+            Err(e) => {
+                emit(ClaudeStreamEvent::Error {
+                    message: format!("Read error: {e}"),
+                });
+                break;
+            }
+        };
 
-    if !run.status.success() && state.session_id.is_empty() {
+        if line.trim().is_empty() {
+            continue;
+        }
+
+        let json: serde_json::Value = match serde_json::from_str(&line) {
+            Ok(v) => v,
+            Err(_) => continue, // skip non-JSON lines
+        };
+
+        dispatch_event(&json, &mut state, emit);
+    }
+
+    // Read stderr for potential error messages.
+    let stderr_output = child
+        .stderr
+        .take()
+        .and_then(|s| std::io::read_to_string(s).ok())
+        .unwrap_or_default();
+
+    let status = child.wait().map_err(|e| format!("Wait failed: {e}"))?;
+
+    if !status.success() && state.session_id.is_empty() {
         emit(ClaudeStreamEvent::Error {
-            message: format_failed_claude_exit(&run.stderr_output, run.status),
+            message: format_failed_claude_exit(&stderr_output, status),
         });
     }
 
@@ -457,15 +473,7 @@ where
             if !sid.is_empty() {
                 state.session_id = sid.clone();
             }
-            let text = if state.emitted_text {
-                String::new()
-            } else {
-                let text = json["result"].as_str().unwrap_or("").to_string();
-                if !text.is_empty() {
-                    state.emitted_text = true;
-                }
-                text
-            };
+            let text = json["result"].as_str().unwrap_or("").to_string();
             emit(ClaudeStreamEvent::Result {
                 text,
                 session_id: sid,
@@ -475,9 +483,19 @@ where
         // --- Complete assistant message (fallback for text when no partials) ---
         "assistant" => {
             if let Some(content) = json["message"]["content"].as_array() {
-                let emit_text = !state.emitted_text;
                 for block in content {
-                    dispatch_assistant_content_block(block, emit_text, state, emit);
+                    if block["type"].as_str() == Some("tool_use") {
+                        if let (Some(id), Some(name)) =
+                            (block["id"].as_str(), block["name"].as_str())
+                        {
+                            let input = format_tool_input(&block["input"], state, id);
+                            emit(ClaudeStreamEvent::ToolStart {
+                                tool_name: name.to_string(),
+                                tool_id: id.to_string(),
+                                input,
+                            });
+                        }
+                    }
                 }
             }
         }
@@ -500,7 +518,9 @@ where
             match delta["type"].as_str() {
                 Some("text_delta") => {
                     if let Some(text) = delta["text"].as_str() {
-                        emit_text_delta(text, state, emit);
+                        emit(ClaudeStreamEvent::TextDelta {
+                            text: text.to_string(),
+                        });
                     }
                 }
                 Some("thinking_delta") => {
@@ -545,46 +565,6 @@ where
     }
 }
 
-fn dispatch_assistant_content_block<F>(
-    block: &serde_json::Value,
-    emit_text: bool,
-    state: &mut StreamState,
-    emit: &mut F,
-) where
-    F: FnMut(ClaudeStreamEvent),
-{
-    match block["type"].as_str() {
-        Some("text") if emit_text => {
-            if let Some(text) = block["text"].as_str() {
-                emit_text_delta(text, state, emit);
-            }
-        }
-        Some("tool_use") => {
-            if let (Some(id), Some(name)) = (block["id"].as_str(), block["name"].as_str()) {
-                let input = format_tool_input(&block["input"], state, id);
-                emit(ClaudeStreamEvent::ToolStart {
-                    tool_name: name.to_string(),
-                    tool_id: id.to_string(),
-                    input,
-                });
-            }
-        }
-        _ => {}
-    }
-}
-
-fn emit_text_delta<F>(text: &str, state: &mut StreamState, emit: &mut F)
-where
-    F: FnMut(ClaudeStreamEvent),
-{
-    if !text.is_empty() {
-        state.emitted_text = true;
-    }
-    emit(ClaudeStreamEvent::TextDelta {
-        text: text.to_string(),
-    });
-}
-
 /// Build the tool input string, preferring accumulated delta chunks over the
 /// block's `input` field (which may be empty at stream start).
 fn format_tool_input(
@@ -627,82 +607,6 @@ mod tests {
     use std::ffi::OsString;
     use std::process::Command;
 
-    macro_rules! chat_request {
-        ($message:expr, None, None $(,)?) => {
-            ChatStreamRequest {
-                message: $message.into(),
-                system_prompt: None,
-                session_id: None,
-            }
-        };
-        ($message:expr, Some($system_prompt:expr), None $(,)?) => {
-            ChatStreamRequest {
-                message: $message.into(),
-                system_prompt: Some($system_prompt.to_string()),
-                session_id: None,
-            }
-        };
-        ($message:expr, None, Some($session_id:expr) $(,)?) => {
-            ChatStreamRequest {
-                message: $message.into(),
-                system_prompt: None,
-                session_id: Some($session_id.to_string()),
-            }
-        };
-    }
-
-    macro_rules! agent_request {
-        ($message:expr, None, $permission_mode:expr $(,)?) => {
-            AgentStreamRequest {
-                message: $message.into(),
-                system_prompt: None,
-                vault_path: "/tmp/vault".into(),
-                permission_mode: $permission_mode,
-            }
-        };
-        ($message:expr, Some($system_prompt:expr), $permission_mode:expr $(,)?) => {
-            AgentStreamRequest {
-                message: $message.into(),
-                system_prompt: Some($system_prompt.to_string()),
-                vault_path: "/tmp/vault".into(),
-                permission_mode: $permission_mode,
-            }
-        };
-    }
-
-    macro_rules! assert_args_contain {
-        ($args:expr, [$($value:expr),+ $(,)?] $(,)?) => {
-            $(
-                assert!($args.contains(&$value.to_string()), "missing {}", $value);
-            )+
-        };
-    }
-
-    macro_rules! assert_args_lack {
-        ($args:expr, [$($value:expr),+ $(,)?] $(,)?) => {
-            $(
-                assert!(!$args.contains(&$value.to_string()), "unexpected {}", $value);
-            )+
-        };
-    }
-
-    macro_rules! assert_no_arg_contains {
-        ($args:expr, $fragment:expr $(,)?) => {
-            assert!(!$args.iter().any(|arg| arg.contains($fragment)));
-        };
-    }
-
-    fn assert_binary_candidates_include(home: &Path, expected: &[PathBuf]) {
-        let candidates = claude_binary_candidates_for_home(home);
-        for candidate in expected {
-            assert!(
-                candidates.contains(candidate),
-                "missing {}",
-                candidate.display()
-            );
-        }
-    }
-
     #[test]
     fn check_cli_returns_status() {
         let status = check_cli();
@@ -713,50 +617,6 @@ mod tests {
         }
     }
 
-    #[test]
-    fn claude_binary_candidates_include_nvm_managed_node_installs() {
-        let home = tempfile::tempdir().unwrap();
-        let claude = home.path().join(".nvm/versions/node/v22.12.0/bin/claude");
-        std::fs::create_dir_all(claude.parent().unwrap()).unwrap();
-        std::fs::write(&claude, "#!/bin/sh\n").unwrap();
-
-        let candidates = claude_binary_candidates_for_home(home.path());
-
-        assert!(candidates.contains(&claude), "missing {}", claude.display());
-    }
-
-    #[test]
-    fn agent_args_use_safe_mode_without_bash_by_default() {
-        let args = build_agent_args(&agent_request!(
-            "Rename the note",
-            None,
-            AiAgentPermissionMode::Safe,
-        ))
-        .unwrap();
-
-        assert_args_contain!(
-            args,
-            ["--strict-mcp-config", "--permission-mode", "acceptEdits"]
-        );
-        assert_args_contain!(args, ["Read,Edit,MultiEdit,Write,Glob,Grep,LS"]);
-        assert_no_arg_contains!(args, "Bash");
-        assert_args_lack!(args, ["--dangerously-skip-permissions"]);
-    }
-
-    #[test]
-    fn agent_args_allow_bash_in_power_user_mode_without_dangerous_bypass() {
-        let args = build_agent_args(&agent_request!(
-            "Rename the note",
-            None,
-            AiAgentPermissionMode::PowerUser,
-        ))
-        .unwrap();
-
-        assert_args_contain!(args, ["--strict-mcp-config"]);
-        assert_args_contain!(args, ["Read,Edit,MultiEdit,Write,Glob,Grep,LS,Bash"]);
-        assert_args_lack!(args, ["--dangerously-skip-permissions"]);
-    }
-
     #[test]
     fn build_mcp_config_is_valid_json() {
         if let Ok(config_str) = build_mcp_config("/tmp/test-vault") {
@@ -776,7 +636,6 @@ mod tests {
             session_id: String::new(),
             tool_inputs: HashMap::new(),
             current_tool_id: None,
-            emitted_text: false,
         }
     }
 
@@ -906,35 +765,10 @@ mod tests {
                 { "type": "tool_use", "id": "tu_1", "name": "search_notes", "input": {} }
             ] }
         }));
-        assert_eq!(events.len(), 2);
+        assert_eq!(events.len(), 1);
         assert!(
-            matches!(&events[0], ClaudeStreamEvent::TextDelta { text } if text == "Let me search.")
+            matches!(&events[0], ClaudeStreamEvent::ToolStart { tool_name, tool_id, .. } if tool_name == "search_notes" && tool_id == "tu_1")
         );
-        assert!(
-            matches!(&events[1], ClaudeStreamEvent::ToolStart { tool_name, tool_id, .. } if tool_name == "search_notes" && tool_id == "tu_1")
-        );
-    }
-
-    #[test]
-    fn dispatch_event_result_after_text_delta_does_not_duplicate_response_text() {
-        let (state, events) = run_dispatch_sequence(vec![
-            serde_json::json!({
-                "type": "stream_event",
-                "event": { "type": "content_block_delta", "delta": { "type": "text_delta", "text": "Visible reply" } }
-            }),
-            serde_json::json!({
-                "type": "result",
-                "session_id": "session-1",
-                "result": "Visible reply"
-            }),
-        ]);
-
-        assert_eq!(state.session_id, "session-1");
-        assert!(matches!(&events[..],
-                [
-                    ClaudeStreamEvent::TextDelta { text },
-                    ClaudeStreamEvent::Result { text: result_text, session_id },
-                ] if text == "Visible reply" && result_text.is_empty() && session_id == "session-1"));
     }
 
     #[test]
@@ -1308,31 +1142,52 @@ mod tests {
 
     #[test]
     fn build_chat_args_basic() {
-        let args = build_chat_args(&chat_request!("hello", None, None));
-
-        assert_args_contain!(args, ["-p", "hello", "stream-json"]);
-        assert_args_lack!(args, ["--system-prompt", "--resume"]);
+        let req = ChatStreamRequest {
+            message: "hello".into(),
+            system_prompt: None,
+            session_id: None,
+        };
+        let args = build_chat_args(&req);
+        assert!(args.contains(&"-p".to_string()));
+        assert!(args.contains(&"hello".to_string()));
+        assert!(args.contains(&"stream-json".to_string()));
+        assert!(!args.contains(&"--system-prompt".to_string()));
+        assert!(!args.contains(&"--resume".to_string()));
     }
 
     #[test]
     fn build_chat_args_with_system_prompt() {
-        let args = build_chat_args(&chat_request!("hi", Some("You are helpful."), None));
-
-        assert_args_contain!(args, ["--system-prompt", "You are helpful."]);
+        let req = ChatStreamRequest {
+            message: "hi".into(),
+            system_prompt: Some("You are helpful.".into()),
+            session_id: None,
+        };
+        let args = build_chat_args(&req);
+        assert!(args.contains(&"--system-prompt".to_string()));
+        assert!(args.contains(&"You are helpful.".to_string()));
     }
 
     #[test]
     fn build_chat_args_empty_system_prompt_is_skipped() {
-        let args = build_chat_args(&chat_request!("hi", Some(""), None));
-
+        let req = ChatStreamRequest {
+            message: "hi".into(),
+            system_prompt: Some(String::new()),
+            session_id: None,
+        };
+        let args = build_chat_args(&req);
         assert!(!args.contains(&"--system-prompt".to_string()));
     }
 
     #[test]
     fn build_chat_args_with_session_id() {
-        let args = build_chat_args(&chat_request!("continue", None, Some("sess-abc")));
-
-        assert_args_contain!(args, ["--resume", "sess-abc"]);
+        let req = ChatStreamRequest {
+            message: "continue".into(),
+            system_prompt: None,
+            session_id: Some("sess-abc".into()),
+        };
+        let args = build_chat_args(&req);
+        assert!(args.contains(&"--resume".to_string()));
+        assert!(args.contains(&"sess-abc".to_string()));
     }
 
     // --- build_agent_args ---
@@ -1340,44 +1195,46 @@ mod tests {
     #[test]
     fn build_agent_args_basic() {
         // build_agent_args calls build_mcp_config which needs mcp_server_dir
-        if let Ok(args) = build_agent_args(&agent_request!(
-            "create note",
-            None,
-            AiAgentPermissionMode::Safe,
-        )) {
-            assert_args_contain!(args, ["-p", "create note", "--mcp-config"]);
-            assert_args_contain!(args, ["--strict-mcp-config", "--permission-mode"]);
-            assert_args_contain!(args, ["acceptEdits", "--tools"]);
-            assert_args_contain!(args, ["Read,Edit,MultiEdit,Write,Glob,Grep,LS"]);
-            assert_args_contain!(args, ["--no-session-persistence"]);
-            assert_args_lack!(
-                args,
-                [
-                    "--dangerously-skip-permissions",
-                    "bypassPermissions",
-                    "--append-system-prompt",
-                ],
-            );
-            assert_no_arg_contains!(args, "Bash");
+        if let Ok(args) = build_agent_args(&AgentStreamRequest {
+            message: "create note".into(),
+            system_prompt: None,
+            vault_path: "/tmp/vault".into(),
+        }) {
+            assert!(args.contains(&"-p".to_string()));
+            assert!(args.contains(&"create note".to_string()));
+            assert!(args.contains(&"--mcp-config".to_string()));
+            assert!(args.contains(&"--strict-mcp-config".to_string()));
+            assert!(args.contains(&"--permission-mode".to_string()));
+            assert!(args.contains(&"acceptEdits".to_string()));
+            assert!(args.contains(&"--tools".to_string()));
+            assert!(args.contains(&"Read,Edit,MultiEdit,Write,Glob,Grep,LS".to_string()));
+            assert!(!args.contains(&"--dangerously-skip-permissions".to_string()));
+            assert!(!args.contains(&"bypassPermissions".to_string()));
+            assert!(!args.contains(&"Bash".to_string()));
+            assert!(args.contains(&"--no-session-persistence".to_string()));
+            assert!(!args.contains(&"--append-system-prompt".to_string()));
         }
     }
 
     #[test]
     fn build_agent_args_with_system_prompt() {
-        if let Ok(args) = build_agent_args(&agent_request!(
-            "do it",
-            Some("Act as expert."),
-            AiAgentPermissionMode::Safe,
-        )) {
-            assert_args_contain!(args, ["--append-system-prompt", "Act as expert."]);
+        if let Ok(args) = build_agent_args(&AgentStreamRequest {
+            message: "do it".into(),
+            system_prompt: Some("Act as expert.".into()),
+            vault_path: "/tmp/v".into(),
+        }) {
+            assert!(args.contains(&"--append-system-prompt".to_string()));
+            assert!(args.contains(&"Act as expert.".to_string()));
         }
     }
 
     #[test]
     fn build_agent_args_empty_system_prompt_is_skipped() {
-        if let Ok(args) =
-            build_agent_args(&agent_request!("x", Some(""), AiAgentPermissionMode::Safe))
-        {
+        if let Ok(args) = build_agent_args(&AgentStreamRequest {
+            message: "x".into(),
+            system_prompt: Some(String::new()),
+            vault_path: "/tmp/v".into(),
+        }) {
             assert!(!args.contains(&"--append-system-prompt".to_string()));
         }
     }
@@ -1387,6 +1244,7 @@ mod tests {
     #[test]
     fn claude_binary_candidates_include_supported_local_and_toolchain_installs() {
         let home = PathBuf::from("/Users/alex");
+        let candidates = claude_binary_candidates_for_home(&home);
         let expected = [
             home.join(".local/bin/claude"),
             home.join(".claude/local/claude"),
@@ -1394,19 +1252,32 @@ mod tests {
             home.join(".npm-global/bin/claude"),
         ];
 
-        assert_binary_candidates_include(&home, &expected);
+        for candidate in expected {
+            assert!(
+                candidates.contains(&candidate),
+                "missing {}",
+                candidate.display()
+            );
+        }
     }
 
     #[test]
     fn claude_binary_candidates_include_windows_exe_installs() {
         let home = PathBuf::from(r"C:\Users\alex");
+        let candidates = claude_binary_candidates_for_home(&home);
         let expected = [
             home.join(".local/bin/claude.exe"),
             home.join(".claude/local/claude.exe"),
             home.join("AppData/Roaming/npm/claude.cmd"),
         ];
 
-        assert_binary_candidates_include(&home, &expected);
+        for candidate in expected {
+            assert!(
+                candidates.contains(&candidate),
+                "missing {}",
+                candidate.display()
+            );
+        }
     }
 
     #[test]
@@ -1462,7 +1333,6 @@ mod tests {
             message: "test".into(),
             system_prompt: Some("sys".into()),
             vault_path: "/tmp/nonexistent".into(),
-            permission_mode: AiAgentPermissionMode::Safe,
         };
         let mut events = vec![];
         let result = run_agent_stream(req, |e| events.push(e));

src-tauri/src/cli_agent_runtime.rs

@@ -1,186 +0,0 @@
-use crate::ai_agents::{AiAgentPermissionMode, AiAgentStreamEvent};
-use serde::Deserialize;
-use std::io::BufRead;
-use std::path::PathBuf;
-use std::process::{Command, ExitStatus};
-
-#[derive(Debug, Clone, Deserialize)]
-pub struct AgentStreamRequest {
-    pub message: String,
-    pub system_prompt: Option<String>,
-    pub vault_path: String,
-    pub permission_mode: AiAgentPermissionMode,
-}
-
-pub(crate) struct JsonLineRun {
-    pub session_id: String,
-    pub stderr_output: String,
-    pub status: ExitStatus,
-}
-
-pub(crate) fn build_prompt(message: &str, system_prompt: Option<&str>) -> String {
-    match system_prompt
-        .map(str::trim)
-        .filter(|prompt| !prompt.is_empty())
-    {
-        Some(system_prompt) => {
-            format!("System instructions:\n{system_prompt}\n\nUser request:\n{message}")
-        }
-        None => message.to_string(),
-    }
-}
-
-pub(crate) fn mcp_server_path_string() -> Result<String, String> {
-    Ok(crate::mcp::mcp_server_dir()?
-        .join("index.js")
-        .to_str()
-        .ok_or("Invalid MCP server path")?
-        .to_string())
-}
-
-pub(crate) fn version_for_binary(binary: &PathBuf) -> Option<String> {
-    crate::hidden_command(binary)
-        .arg("--version")
-        .output()
-        .ok()
-        .filter(|output| output.status.success())
-        .map(|output| String::from_utf8_lossy(&output.stdout).trim().to_string())
-}
-
-pub(crate) fn parse_json_line(
-    line: Result<String, std::io::Error>,
-) -> Result<Option<serde_json::Value>, String> {
-    let line = line.map_err(|error| format!("Read error: {error}"))?;
-    let trimmed = line.trim();
-    if trimmed.is_empty() {
-        return Ok(None);
-    }
-
-    Ok(serde_json::from_str::<serde_json::Value>(trimmed).ok())
-}
-
-#[cfg(test)]
-pub(crate) fn parse_ai_agent_json_line<F>(
-    line: Result<String, std::io::Error>,
-    emit: &mut F,
-) -> Option<serde_json::Value>
-where
-    F: FnMut(AiAgentStreamEvent),
-{
-    match parse_json_line(line) {
-        Ok(json) => json,
-        Err(message) => {
-            emit(AiAgentStreamEvent::Error { message });
-            None
-        }
-    }
-}
-
-pub(crate) fn run_json_line_process<Event, F, H>(
-    mut command: Command,
-    process_name: &'static str,
-    emit: &mut F,
-    error_event: impl Fn(String) -> Event,
-    mut handle_json: H,
-) -> Result<JsonLineRun, String>
-where
-    F: FnMut(Event),
-    H: FnMut(&serde_json::Value, &mut F, &mut String),
-{
-    let mut child = command
-        .spawn()
-        .map_err(|error| format!("Failed to spawn {process_name}: {error}"))?;
-    let stdout = child.stdout.take().ok_or("No stdout handle")?;
-    let reader = std::io::BufReader::new(stdout);
-    let mut session_id = String::new();
-
-    for line in reader.lines() {
-        match parse_json_line(line) {
-            Ok(Some(json)) => handle_json(&json, emit, &mut session_id),
-            Ok(None) => {}
-            Err(message) => {
-                emit(error_event(message));
-                break;
-            }
-        }
-    }
-
-    let stderr_output = child
-        .stderr
-        .take()
-        .and_then(|stderr| std::io::read_to_string(stderr).ok())
-        .unwrap_or_default();
-    let status = child
-        .wait()
-        .map_err(|error| format!("Wait failed: {error}"))?;
-
-    Ok(JsonLineRun {
-        session_id,
-        stderr_output,
-        status,
-    })
-}
-
-pub(crate) fn run_ai_agent_json_stream<F>(
-    command: Command,
-    process_name: &'static str,
-    mut emit: F,
-    session_id: impl Fn(&serde_json::Value) -> Option<&str>,
-    dispatch_event: impl Fn(&serde_json::Value, &mut F),
-    format_error: impl Fn(String, String) -> String,
-) -> Result<String, String>
-where
-    F: FnMut(AiAgentStreamEvent),
-{
-    let run = run_json_line_process(
-        command,
-        process_name,
-        &mut emit,
-        |message| AiAgentStreamEvent::Error { message },
-        |json, emit, active_session_id| {
-            if let Some(id) = session_id(json) {
-                *active_session_id = id.to_string();
-            }
-            dispatch_event(json, emit);
-        },
-    )?;
-
-    if !run.status.success() {
-        emit(AiAgentStreamEvent::Error {
-            message: format_error(run.stderr_output, run.status.to_string()),
-        });
-    }
-
-    emit(AiAgentStreamEvent::Done);
-    Ok(run.session_id)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn build_prompt_keeps_system_prompt_first() {
-        let prompt = build_prompt("Rename the note", Some("Be concise"));
-
-        assert!(prompt.starts_with("System instructions:\nBe concise"));
-        assert!(prompt.contains("User request:\nRename the note"));
-    }
-
-    #[test]
-    fn build_prompt_skips_blank_system_prompt() {
-        assert_eq!(
-            build_prompt("Rename the note", Some("  ")),
-            "Rename the note"
-        );
-    }
-
-    #[test]
-    fn parse_json_line_reports_read_errors_and_skips_blank_or_invalid_lines() {
-        assert!(parse_json_line(Ok("   ".into())).unwrap().is_none());
-        assert!(parse_json_line(Ok("not json".into())).unwrap().is_none());
-
-        let error = parse_json_line(Err(std::io::Error::other("broken pipe"))).unwrap_err();
-        assert!(error.contains("broken pipe"));
-    }
-}

src-tauri/src/codex_cli.rs

@@ -1,607 +0,0 @@
-use crate::ai_agents::{AiAgentAvailability, AiAgentStreamEvent};
-pub use crate::cli_agent_runtime::AgentStreamRequest;
-use std::path::{Path, PathBuf};
-use std::process::Stdio;
-
-pub fn check_cli() -> AiAgentAvailability {
-    let binary = match find_codex_binary() {
-        Ok(binary) => binary,
-        Err(_) => {
-            return AiAgentAvailability {
-                installed: false,
-                version: None,
-            }
-        }
-    };
-
-    AiAgentAvailability {
-        installed: true,
-        version: crate::cli_agent_runtime::version_for_binary(&binary),
-    }
-}
-
-pub fn run_agent_stream<F>(request: AgentStreamRequest, emit: F) -> Result<String, String>
-where
-    F: FnMut(AiAgentStreamEvent),
-{
-    let binary = find_codex_binary()?;
-    run_agent_stream_with_binary(&binary, request, emit)
-}
-
-fn find_codex_binary() -> Result<PathBuf, String> {
-    if let Some(binary) = find_codex_binary_on_path() {
-        return Ok(binary);
-    }
-
-    if let Some(binary) = find_codex_binary_in_user_shell() {
-        return Ok(binary);
-    }
-
-    if let Some(binary) = find_existing_binary(codex_binary_candidates()) {
-        return Ok(binary);
-    }
-
-    Err("Codex CLI not found. Install it: https://developers.openai.com/codex/cli".into())
-}
-
-fn find_codex_binary_on_path() -> Option<PathBuf> {
-    crate::hidden_command("which")
-        .arg("codex")
-        .output()
-        .ok()
-        .and_then(|output| path_from_successful_output(&output))
-}
-
-fn find_codex_binary_in_user_shell() -> Option<PathBuf> {
-    user_shell_candidates()
-        .into_iter()
-        .filter(|shell| shell.exists())
-        .find_map(|shell| command_path_from_shell(&shell, "codex"))
-}
-
-fn user_shell_candidates() -> Vec<PathBuf> {
-    let mut shells = Vec::new();
-    if let Some(shell) = std::env::var_os("SHELL") {
-        if !shell.is_empty() {
-            shells.push(PathBuf::from(shell));
-        }
-    }
-    shells.push(PathBuf::from("/bin/zsh"));
-    shells.push(PathBuf::from("/bin/bash"));
-    shells
-}
-
-fn command_path_from_shell(shell: &Path, command: &str) -> Option<PathBuf> {
-    crate::hidden_command(shell)
-        .arg("-lc")
-        .arg(format!("command -v {command}"))
-        .output()
-        .ok()
-        .and_then(|output| path_from_successful_output(&output))
-}
-
-fn path_from_successful_output(output: &std::process::Output) -> Option<PathBuf> {
-    if output.status.success() {
-        first_existing_path(&String::from_utf8_lossy(&output.stdout))
-    } else {
-        None
-    }
-}
-
-fn first_existing_path(stdout: &str) -> Option<PathBuf> {
-    stdout.lines().find_map(|line| {
-        let trimmed = line.trim();
-        if trimmed.is_empty() {
-            return None;
-        }
-        let candidate = PathBuf::from(trimmed);
-        candidate.exists().then_some(candidate)
-    })
-}
-
-fn codex_binary_candidates() -> Vec<PathBuf> {
-    dirs::home_dir()
-        .map(|home| codex_binary_candidates_for_home(&home))
-        .unwrap_or_default()
-}
-
-fn codex_binary_candidates_for_home(home: &Path) -> Vec<PathBuf> {
-    let mut candidates = vec![
-        home.join(".local/bin/codex"),
-        home.join(".codex/bin/codex"),
-        home.join(".local/share/mise/shims/codex"),
-        home.join(".asdf/shims/codex"),
-        home.join(".npm-global/bin/codex"),
-        home.join(".npm/bin/codex"),
-        home.join(".bun/bin/codex"),
-        PathBuf::from("/usr/local/bin/codex"),
-        PathBuf::from("/opt/homebrew/bin/codex"),
-        PathBuf::from("/Applications/Codex.app/Contents/Resources/codex"),
-    ];
-    candidates.extend(nvm_node_binary_candidates_for_home(home, "codex"));
-    candidates
-}
-
-fn nvm_node_binary_candidates_for_home(home: &Path, binary_name: &str) -> Vec<PathBuf> {
-    let Ok(entries) = std::fs::read_dir(home.join(".nvm/versions/node")) else {
-        return Vec::new();
-    };
-
-    let mut candidates = entries
-        .filter_map(Result::ok)
-        .map(|entry| entry.path())
-        .filter(|path| path.is_dir())
-        .map(|path| path.join("bin").join(binary_name))
-        .collect::<Vec<_>>();
-    candidates.sort();
-    candidates
-}
-
-fn find_existing_binary(candidates: Vec<PathBuf>) -> Option<PathBuf> {
-    candidates.into_iter().find(|candidate| candidate.exists())
-}
-
-fn run_agent_stream_with_binary<F>(
-    binary: &Path,
-    request: AgentStreamRequest,
-    emit: F,
-) -> Result<String, String>
-where
-    F: FnMut(AiAgentStreamEvent),
-{
-    let args = build_codex_args(&request)?;
-    let prompt = build_codex_prompt(&request);
-    let command = build_codex_command(binary, args, prompt, &request.vault_path);
-
-    crate::cli_agent_runtime::run_ai_agent_json_stream(
-        command,
-        "codex",
-        emit,
-        codex_session_id,
-        dispatch_codex_event,
-        format_codex_error,
-    )
-}
-
-fn build_codex_command(
-    binary: &Path,
-    args: Vec<String>,
-    prompt: String,
-    vault_path: &str,
-) -> std::process::Command {
-    let mut command = crate::hidden_command(binary);
-    command
-        .args(args)
-        .arg(prompt)
-        .current_dir(vault_path)
-        .stdout(Stdio::piped())
-        .stderr(Stdio::piped());
-    command
-}
-
-fn build_codex_args(request: &AgentStreamRequest) -> Result<Vec<String>, String> {
-    let mcp_server_path = crate::cli_agent_runtime::mcp_server_path_string()?;
-
-    Ok(vec![
-        "--sandbox".into(),
-        "workspace-write".into(),
-        "--ask-for-approval".into(),
-        "never".into(),
-        "exec".into(),
-        "--json".into(),
-        "-C".into(),
-        request.vault_path.clone(),
-        "-c".into(),
-        r#"mcp_servers.tolaria.command="node""#.into(),
-        "-c".into(),
-        format!(r#"mcp_servers.tolaria.args=["{}"]"#, mcp_server_path),
-        "-c".into(),
-        format!(
-            r#"mcp_servers.tolaria.env={{VAULT_PATH="{}"}}"#,
-            request.vault_path
-        ),
-    ])
-}
-
-fn build_codex_prompt(request: &AgentStreamRequest) -> String {
-    crate::cli_agent_runtime::build_prompt(&request.message, request.system_prompt.as_deref())
-}
-
-fn codex_session_id(json: &serde_json::Value) -> Option<&str> {
-    json["thread_id"].as_str()
-}
-
-fn dispatch_codex_event<F>(json: &serde_json::Value, emit: &mut F)
-where
-    F: FnMut(AiAgentStreamEvent),
-{
-    match json["type"].as_str().unwrap_or_default() {
-        "thread.started" => {
-            if let Some(thread_id) = json["thread_id"].as_str() {
-                emit(AiAgentStreamEvent::Init {
-                    session_id: thread_id.to_string(),
-                });
-            }
-        }
-        "item.started" => emit_codex_item_event(json, false, emit),
-        "item.completed" => emit_codex_item_event(json, true, emit),
-        _ => {}
-    }
-}
-
-fn emit_codex_item_event<F>(json: &serde_json::Value, completed: bool, emit: &mut F)
-where
-    F: FnMut(AiAgentStreamEvent),
-{
-    let item = &json["item"];
-    let item_type = item["type"].as_str().unwrap_or_default();
-    let item_id = item["id"].as_str().unwrap_or_default();
-
-    match item_type {
-        "command_execution" => {
-            if completed {
-                emit(AiAgentStreamEvent::ToolDone {
-                    tool_id: item_id.to_string(),
-                    output: item["aggregated_output"]
-                        .as_str()
-                        .map(|output| output.to_string()),
-                });
-            } else {
-                emit(AiAgentStreamEvent::ToolStart {
-                    tool_name: "Bash".into(),
-                    tool_id: item_id.to_string(),
-                    input: item["command"]
-                        .as_str()
-                        .map(|command| serde_json::json!({ "command": command }).to_string()),
-                });
-            }
-        }
-        "agent_message" if completed => {
-            if let Some(text) = item["text"].as_str() {
-                emit(AiAgentStreamEvent::TextDelta {
-                    text: text.to_string(),
-                });
-            }
-        }
-        _ => {}
-    }
-}
-
-fn format_codex_error(stderr_output: String, status: String) -> String {
-    let lower = stderr_output.to_ascii_lowercase();
-    if is_codex_auth_error(&lower) {
-        return "Codex CLI is not authenticated. Run `codex login` or launch `codex` in your terminal.".into();
-    }
-
-    if is_codex_write_permission_error(&lower) {
-        return "Codex could not write to the active vault. Tolaria starts Codex with a workspace-write sandbox, so verify the selected vault folder is writable and retry; writes outside the active vault remain blocked.".into();
-    }
-
-    if stderr_output.trim().is_empty() {
-        format!("codex exited with status {status}")
-    } else {
-        stderr_output.lines().take(3).collect::<Vec<_>>().join("\n")
-    }
-}
-
-fn is_codex_auth_error(lower: &str) -> bool {
-    ["auth", "login", "sign in"]
-        .iter()
-        .any(|pattern| lower.contains(pattern))
-}
-
-fn is_codex_write_permission_error(lower: &str) -> bool {
-    [
-        "read-only sandbox",
-        "writing is blocked",
-        "rejected by user approval",
-        "rejected by the environment",
-    ]
-    .iter()
-    .any(|pattern| lower.contains(pattern))
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::ai_agents::AiAgentPermissionMode;
-    use std::ffi::OsStr;
-
-    #[cfg(unix)]
-    fn executable_script(dir: &Path, name: &str, body: &str) -> PathBuf {
-        use std::os::unix::fs::PermissionsExt;
-
-        let script = dir.join(name);
-        std::fs::write(&script, format!("#!/bin/sh\n{body}")).unwrap();
-        std::fs::set_permissions(&script, std::fs::Permissions::from_mode(0o755)).unwrap();
-        script
-    }
-
-    fn codex_request(
-        vault_path: &Path,
-        permission_mode: AiAgentPermissionMode,
-    ) -> AgentStreamRequest {
-        AgentStreamRequest {
-            message: "Summarize".into(),
-            system_prompt: None,
-            vault_path: vault_path.to_string_lossy().into_owned(),
-            permission_mode,
-        }
-    }
-
-    fn assert_codex_workspace_write_contract(args: &[String]) {
-        let prefix = [
-            "--sandbox",
-            "workspace-write",
-            "--ask-for-approval",
-            "never",
-        ];
-
-        assert_eq!(&args[..prefix.len()], prefix);
-        assert!(!args.iter().any(|arg| arg == "danger-full-access"));
-        assert!(!args
-            .iter()
-            .any(|arg| arg == "--dangerously-bypass-approvals-and-sandbox"));
-    }
-
-    #[cfg(unix)]
-    fn run_codex_script(body: &str) -> (String, Vec<AiAgentStreamEvent>) {
-        let dir = tempfile::tempdir().unwrap();
-        let vault = tempfile::tempdir().unwrap();
-        let binary = executable_script(dir.path(), "codex", body);
-        let mut events = Vec::new();
-        let thread_id = run_agent_stream_with_binary(
-            &binary,
-            codex_request(vault.path(), AiAgentPermissionMode::Safe),
-            |event| events.push(event),
-        )
-        .unwrap();
-
-        (thread_id, events)
-    }
-
-    fn assert_codex_text_flow(events: &[AiAgentStreamEvent], session: &str, text_delta: &str) {
-        assert!(matches!(
-            &events[0],
-            AiAgentStreamEvent::Init { session_id } if session_id == session
-        ));
-        assert!(matches!(
-            &events[1],
-            AiAgentStreamEvent::TextDelta { text } if text == text_delta
-        ));
-        assert!(matches!(events.last(), Some(AiAgentStreamEvent::Done)));
-    }
-
-    #[test]
-    fn build_codex_prompt_keeps_system_prompt_first() {
-        let prompt = build_codex_prompt(&AgentStreamRequest {
-            message: "Rename the note".into(),
-            system_prompt: Some("Be concise".into()),
-            vault_path: "/tmp/vault".into(),
-            permission_mode: AiAgentPermissionMode::Safe,
-        });
-
-        assert!(prompt.starts_with("System instructions:\nBe concise"));
-        assert!(prompt.contains("User request:\nRename the note"));
-    }
-
-    #[test]
-    fn build_codex_args_uses_safe_default_permissions() {
-        if let Ok(args) = build_codex_args(&AgentStreamRequest {
-            message: "Rename the note".into(),
-            system_prompt: None,
-            vault_path: "/tmp/vault".into(),
-            permission_mode: AiAgentPermissionMode::Safe,
-        }) {
-            assert_eq!(args[4], "exec");
-            assert_codex_workspace_write_contract(&args);
-            assert!(args.contains(&"--json".to_string()));
-            assert!(args.contains(&"-C".to_string()));
-        }
-    }
-
-    #[test]
-    fn codex_permission_modes_keep_workspace_write_without_dangerous_bypass() {
-        for permission_mode in [
-            AiAgentPermissionMode::Safe,
-            AiAgentPermissionMode::PowerUser,
-        ] {
-            if let Ok(args) = build_codex_args(&AgentStreamRequest {
-                message: "Rename the note".into(),
-                system_prompt: None,
-                vault_path: "/tmp/vault".into(),
-                permission_mode,
-            }) {
-                assert_codex_workspace_write_contract(&args);
-            }
-        }
-    }
-
-    #[test]
-    fn build_codex_command_keeps_agent_process_contract() {
-        let binary = PathBuf::from("codex");
-        let args = vec!["exec".to_string(), "--json".to_string()];
-        let command = build_codex_command(&binary, args, "Summarize".into(), "/tmp/vault");
-        let actual_args: Vec<&OsStr> = command.get_args().collect();
-
-        assert_eq!(command.get_program(), OsStr::new("codex"));
-        assert_eq!(
-            actual_args,
-            vec![
-                OsStr::new("exec"),
-                OsStr::new("--json"),
-                OsStr::new("Summarize")
-            ]
-        );
-        assert_eq!(command.get_current_dir(), Some(Path::new("/tmp/vault")));
-    }
-
-    #[cfg(unix)]
-    #[test]
-    fn run_codex_agent_stream_reads_ndjson_and_returns_thread_id() {
-        let (thread_id, events) = run_codex_script(
-            r#"printf '%s\n' '{"type":"thread.started","thread_id":"thread_1"}'
-printf '%s\n' '{"type":"item.completed","item":{"id":"msg_1","type":"agent_message","text":"Done"}}'
-"#,
-        );
-
-        assert_eq!(thread_id, "thread_1");
-        assert_codex_text_flow(&events, "thread_1", "Done");
-    }
-
-    #[cfg(unix)]
-    #[test]
-    fn run_codex_agent_stream_reports_nonzero_exit_errors() {
-        let (thread_id, events) = run_codex_script(
-            r#"printf '%s\n' '{"type":"thread.started","thread_id":"thread_1"}'
-printf '%s\n' 'login required' >&2
-exit 2
-"#,
-        );
-
-        assert_eq!(thread_id, "thread_1");
-        assert!(events.iter().any(|event| matches!(
-            event,
-            AiAgentStreamEvent::Error { message } if message.contains("not authenticated")
-        )));
-        assert!(matches!(events.last(), Some(AiAgentStreamEvent::Done)));
-    }
-
-    #[test]
-    fn codex_binary_candidates_include_supported_macos_installs() {
-        let home = PathBuf::from("/Users/alex");
-        let candidates = codex_binary_candidates_for_home(&home);
-        let expected = [
-            home.join(".local/bin/codex"),
-            home.join(".codex/bin/codex"),
-            home.join(".local/share/mise/shims/codex"),
-            home.join(".asdf/shims/codex"),
-            home.join(".npm-global/bin/codex"),
-            home.join(".bun/bin/codex"),
-            PathBuf::from("/Applications/Codex.app/Contents/Resources/codex"),
-        ];
-
-        for candidate in expected {
-            assert!(
-                candidates.contains(&candidate),
-                "missing {}",
-                candidate.display()
-            );
-        }
-    }
-
-    #[test]
-    fn codex_binary_candidates_include_nvm_managed_node_installs() {
-        let home = tempfile::tempdir().unwrap();
-        let codex = home.path().join(".nvm/versions/node/v22.12.0/bin/codex");
-        std::fs::create_dir_all(codex.parent().unwrap()).unwrap();
-        std::fs::write(&codex, "#!/bin/sh\n").unwrap();
-
-        let candidates = codex_binary_candidates_for_home(home.path());
-
-        assert!(candidates.contains(&codex), "missing {}", codex.display());
-    }
-
-    #[test]
-    fn first_existing_path_skips_empty_and_missing_lines() {
-        let dir = tempfile::tempdir().unwrap();
-        let missing = dir.path().join("missing-codex");
-        let codex = dir.path().join("codex");
-        std::fs::write(&codex, "#!/bin/sh\n").unwrap();
-
-        let stdout = format!("\n{}\n{}\n", missing.display(), codex.display());
-
-        assert_eq!(first_existing_path(&stdout), Some(codex));
-    }
-
-    #[cfg(unix)]
-    #[test]
-    fn command_path_from_shell_finds_codex_from_login_shell() {
-        use std::os::unix::fs::PermissionsExt;
-
-        let dir = tempfile::tempdir().unwrap();
-        let codex = dir.path().join("codex");
-        std::fs::write(&codex, "#!/bin/sh\n").unwrap();
-        std::fs::set_permissions(&codex, std::fs::Permissions::from_mode(0o755)).unwrap();
-
-        let shell = dir.path().join("shell");
-        std::fs::write(
-            &shell,
-            format!(
-                "#!/bin/sh\nif [ \"$1\" = \"-lc\" ]; then echo '{}'; fi\n",
-                codex.display()
-            ),
-        )
-        .unwrap();
-        std::fs::set_permissions(&shell, std::fs::Permissions::from_mode(0o755)).unwrap();
-
-        assert_eq!(command_path_from_shell(&shell, "codex"), Some(codex));
-    }
-
-    #[test]
-    fn dispatch_codex_command_events_maps_to_bash_events() {
-        let mut events = Vec::new();
-        let started = serde_json::json!({
-            "type": "item.started",
-            "item": {
-                "id": "item_1",
-                "type": "command_execution",
-                "command": "/bin/zsh -lc pwd"
-            }
-        });
-        let completed = serde_json::json!({
-            "type": "item.completed",
-            "item": {
-                "id": "item_1",
-                "type": "command_execution",
-                "aggregated_output": "/private/tmp\n"
-            }
-        });
-
-        dispatch_codex_event(&started, &mut |event| events.push(event));
-        dispatch_codex_event(&completed, &mut |event| events.push(event));
-
-        assert!(matches!(
-            &events[0],
-            AiAgentStreamEvent::ToolStart { tool_name, tool_id, .. }
-                if tool_name == "Bash" && tool_id == "item_1"
-        ));
-        assert!(matches!(
-            &events[1],
-            AiAgentStreamEvent::ToolDone { tool_id, output }
-                if tool_id == "item_1" && output.as_deref() == Some("/private/tmp\n")
-        ));
-    }
-
-    #[test]
-    fn dispatch_codex_agent_message_maps_to_text_delta() {
-        let mut events = Vec::new();
-        let completed = serde_json::json!({
-            "type": "item.completed",
-            "item": {
-                "id": "item_2",
-                "type": "agent_message",
-                "text": "All set"
-            }
-        });
-
-        dispatch_codex_event(&completed, &mut |event| events.push(event));
-
-        assert!(matches!(
-            &events[0],
-            AiAgentStreamEvent::TextDelta { text } if text == "All set"
-        ));
-    }
-
-    #[test]
-    fn format_codex_error_explains_vault_write_permission_failures() {
-        let message = format_codex_error(
-            "The patch was rejected by the environment: writing is blocked by read-only sandbox; rejected by user approval settings".into(),
-            "exit status: 1".into(),
-        );
-
-        assert!(message.contains("active vault"));
-        assert!(message.contains("writable"));
-        assert!(message.contains("outside"));
-    }
-}

src-tauri/src/commands/ai.rs

@@ -145,8 +145,6 @@ pub async fn stream_ai_agent(
 mod tests {
     use super::*;
     use crate::vault::AiGuidanceFileState;
-    use serde_json::Value;
-    use std::{fs, path::Path};
 
     #[test]
     fn guidance_commands_report_and_restore_vault_guidance_files() {
@@ -156,37 +154,14 @@ mod tests {
         let initial = get_vault_ai_guidance_status(vault_path.clone()).unwrap();
         assert_eq!(initial.agents_state, AiGuidanceFileState::Missing);
         assert_eq!(initial.claude_state, AiGuidanceFileState::Missing);
-        assert_eq!(initial.gemini_state, AiGuidanceFileState::Missing);
         assert!(initial.can_restore);
 
         let restored = restore_vault_ai_guidance(vault_path.clone()).unwrap();
         assert_eq!(restored.agents_state, AiGuidanceFileState::Managed);
         assert_eq!(restored.claude_state, AiGuidanceFileState::Managed);
-        assert_eq!(restored.gemini_state, AiGuidanceFileState::Managed);
         assert!(!restored.can_restore);
 
         assert!(dir.path().join("AGENTS.md").exists());
         assert!(dir.path().join("CLAUDE.md").exists());
-        assert!(dir.path().join("GEMINI.md").exists());
-    }
-
-    #[test]
-    fn desktop_capability_allows_opening_restored_guidance_files() {
-        let capability_path = Path::new(env!("CARGO_MANIFEST_DIR"))
-            .join("capabilities")
-            .join("default.json");
-        let capability_json = fs::read_to_string(capability_path).unwrap();
-        let capability: Value = serde_json::from_str(&capability_json).unwrap();
-        let permissions = capability
-            .get("permissions")
-            .and_then(Value::as_array)
-            .unwrap();
-
-        assert!(
-            permissions
-                .iter()
-                .any(|permission| permission.as_str() == Some("opener:allow-open-path")),
-            "desktop capabilities must allow opener open_path so restored guidance files can be opened"
-        );
     }
 }

src-tauri/src/commands/system.rs

@@ -131,15 +131,6 @@ pub async fn check_mcp_status(vault_path: String) -> Result<crate::mcp::McpStatu
         .map_err(|e| format!("MCP status check failed: {e}"))
 }
 
-#[cfg(desktop)]
-#[tauri::command]
-pub async fn get_mcp_config_snippet(vault_path: String) -> Result<String, String> {
-    let vault_path = super::expand_tilde(&vault_path).into_owned();
-    tokio::task::spawn_blocking(move || crate::mcp::mcp_config_snippet(&vault_path))
-        .await
-        .map_err(|e| format!("MCP config task failed: {e}"))?
-}
-
 #[cfg(desktop)]
 #[tauri::command]
 pub async fn sync_mcp_bridge_vault(
@@ -176,12 +167,6 @@ pub async fn check_mcp_status(_vault_path: String) -> Result<crate::mcp::McpStat
     Ok(crate::mcp::McpStatus::NotInstalled)
 }
 
-#[cfg(mobile)]
-#[tauri::command]
-pub async fn get_mcp_config_snippet(_vault_path: String) -> Result<String, String> {
-    Err("MCP is not available on mobile".into())
-}
-
 #[cfg(mobile)]
 #[tauri::command]
 pub async fn sync_mcp_bridge_vault(_vault_path: Option<String>) -> Result<String, String> {

src-tauri/src/commands/vault.rs

@@ -53,7 +53,6 @@ mod tests {
             name: "Inbox".to_string(),
             icon: None,
             color: None,
-            order: None,
             sort: None,
             list_properties_display: vec![],
             filters: crate::vault::FilterGroup::All(vec![]),

src-tauri/src/lib.rs

@@ -1,8 +1,6 @@
 pub mod ai_agents;
 pub mod app_updater;
 pub mod claude_cli;
-mod cli_agent_runtime;
-pub mod codex_cli;
 mod commands;
 pub mod frontmatter;
 pub mod git;
@@ -437,7 +435,6 @@ macro_rules! app_invoke_handler {
             commands::register_mcp_tools,
             commands::remove_mcp_tools,
             commands::check_mcp_status,
-            commands::get_mcp_config_snippet,
             commands::sync_mcp_bridge_vault,
             commands::repair_vault,
             commands::reinit_telemetry,
@@ -463,7 +460,10 @@ fn handle_run_event(app_handle: &tauri::AppHandle, event: &tauri::RunEvent) {
     if let tauri::RunEvent::Exit = event {
         let state: tauri::State<'_, WsBridgeChild> = app_handle.state();
         let mut guard = state.0.lock().unwrap();
-        stop_ws_bridge_child(&mut guard);
+        if let Some(ref mut child) = *guard {
+            let _ = child.kill();
+            log::info!("ws-bridge child process killed on exit");
+        }
     }
 }
 

src-tauri/src/mcp.rs

@@ -17,88 +17,30 @@ pub enum McpStatus {
 
 /// Find the `node` binary path at runtime.
 pub(crate) fn find_node() -> Result<PathBuf, String> {
-    let mut last_error = None;
-    for path in node_binary_candidates() {
-        match verify_node_version(&path) {
-            Ok(()) => return Ok(path),
-            Err(error) => last_error = Some(error),
+    let output = node_lookup_command()
+        .output()
+        .map_err(|e| format!("Failed to locate node on PATH: {e}"))?;
+    if output.status.success() {
+        if let Some(path) = first_node_lookup_path(&output.stdout) {
+            verify_node_version(&path)?;
+            return Ok(path);
         }
     }
 
-    Err(last_error.unwrap_or_else(|| "node not found in PATH or common install locations".into()))
+    if let Some(path) = fallback_node_path() {
+        verify_node_version(&path)?;
+        return Ok(path);
+    }
+
+    Err("node not found in PATH or common install locations".into())
 }
 
-fn node_binary_candidates() -> Vec<PathBuf> {
-    let mut candidates = find_node_on_path();
-    candidates.extend(find_node_in_user_shell());
-    candidates.extend(fallback_node_paths());
-    candidates
-}
-
-fn find_node_on_path() -> Vec<PathBuf> {
-    node_lookup_command()
-        .output()
-        .ok()
-        .filter(|output| output.status.success())
-        .map(|output| node_lookup_paths(&output.stdout))
-        .unwrap_or_default()
-}
-
-fn find_node_in_user_shell() -> Vec<PathBuf> {
-    user_shell_candidates()
-        .into_iter()
-        .filter(|shell| shell.exists())
-        .filter_map(|shell| command_path_from_shell(&shell, "node"))
-        .collect()
-}
-
-fn node_lookup_paths(stdout: &[u8]) -> Vec<PathBuf> {
+fn first_node_lookup_path(stdout: &[u8]) -> Option<PathBuf> {
     String::from_utf8_lossy(stdout)
         .lines()
         .map(str::trim)
-        .filter(|line| !line.is_empty())
+        .find(|line| !line.is_empty())
         .map(PathBuf::from)
-        .collect()
-}
-
-fn user_shell_candidates() -> Vec<PathBuf> {
-    let mut shells = Vec::new();
-    if let Some(shell) = std::env::var_os("SHELL") {
-        if !shell.is_empty() {
-            shells.push(PathBuf::from(shell));
-        }
-    }
-    shells.push(PathBuf::from("/bin/zsh"));
-    shells.push(PathBuf::from("/bin/bash"));
-    shells
-}
-
-fn command_path_from_shell(shell: &Path, command: &str) -> Option<PathBuf> {
-    crate::hidden_command(shell)
-        .arg("-lc")
-        .arg(format!("command -v {command}"))
-        .output()
-        .ok()
-        .and_then(|output| path_from_successful_output(&output))
-}
-
-fn path_from_successful_output(output: &std::process::Output) -> Option<PathBuf> {
-    if output.status.success() {
-        first_existing_path(&String::from_utf8_lossy(&output.stdout))
-    } else {
-        None
-    }
-}
-
-fn first_existing_path(stdout: &str) -> Option<PathBuf> {
-    stdout.lines().find_map(|line| {
-        let trimmed = line.trim();
-        if trimmed.is_empty() {
-            return None;
-        }
-        let candidate = PathBuf::from(trimmed);
-        candidate.exists().then_some(candidate)
-    })
 }
 
 fn verify_node_version(node: &Path) -> Result<(), String> {
@@ -149,7 +91,7 @@ fn node_lookup_command() -> Command {
     command
 }
 
-fn fallback_node_paths() -> Vec<PathBuf> {
+fn fallback_node_path() -> Option<PathBuf> {
     let mut candidates = vec![
         PathBuf::from("/opt/homebrew/bin/node"),
         PathBuf::from("/usr/local/bin/node"),
@@ -178,39 +120,24 @@ fn fallback_node_paths() -> Vec<PathBuf> {
     }
 
     if let Some(home) = dirs::home_dir() {
-        candidates.extend(node_binary_candidates_for_home(&home));
+        candidates.push(home.join(".volta").join("bin").join(node_binary_name()));
+
+        let nvm_dir = home.join(".nvm").join("versions").join("node");
+        if let Ok(entries) = std::fs::read_dir(nvm_dir) {
+            let mut versions = entries
+                .filter_map(|entry| entry.ok().map(|entry| entry.path()))
+                .collect::<Vec<_>>();
+            versions.sort();
+            versions.reverse();
+            candidates.extend(
+                versions
+                    .into_iter()
+                    .map(|version| version.join("bin").join("node")),
+            );
+        }
     }
 
-    candidates
-        .into_iter()
-        .filter(|path| path.is_file())
-        .collect()
-}
-
-fn node_binary_candidates_for_home(home: &Path) -> Vec<PathBuf> {
-    let mut candidates = vec![
-        home.join(".local/share/mise/shims")
-            .join(node_binary_name()),
-        home.join(".mise").join("shims").join(node_binary_name()),
-        home.join(".asdf").join("shims").join(node_binary_name()),
-        home.join(".volta").join("bin").join(node_binary_name()),
-    ];
-
-    let nvm_dir = home.join(".nvm").join("versions").join("node");
-    if let Ok(entries) = std::fs::read_dir(nvm_dir) {
-        let mut versions = entries
-            .filter_map(|entry| entry.ok().map(|entry| entry.path()))
-            .collect::<Vec<_>>();
-        versions.sort();
-        versions.reverse();
-        candidates.extend(
-            versions
-                .into_iter()
-                .map(|version| version.join("bin").join("node")),
-        );
-    }
-
-    candidates
+    candidates.into_iter().find(|path| path.is_file())
 }
 
 fn node_binary_name() -> &'static str {
@@ -323,7 +250,6 @@ fn mcp_config_paths_for_home(home: &Path) -> Vec<PathBuf> {
     vec![
         home.join(".claude.json"),
         home.join(".claude").join("mcp.json"),
-        home.join(".gemini").join("settings.json"),
         home.join(".cursor").join("mcp.json"),
         home.join(".config").join("mcp").join("mcp.json"),
     ]
@@ -387,28 +313,6 @@ fn build_mcp_entry(node_command: &str, index_js: &str, vault_path: &str) -> serd
     })
 }
 
-fn build_mcp_config_snippet(entry: &serde_json::Value) -> Result<String, String> {
-    let mut servers = serde_json::Map::new();
-    servers.insert(MCP_SERVER_NAME.to_string(), entry.clone());
-    let config = serde_json::json!({ "mcpServers": servers });
-
-    serde_json::to_string_pretty(&config)
-        .map_err(|e| format!("Failed to serialize MCP config snippet: {e}"))
-}
-
-/// Build the exact MCP config JSON users can copy into compatible tools.
-pub fn mcp_config_snippet(vault_path: &str) -> Result<String, String> {
-    let node = find_node().map_err(|e| {
-        format!("Node.js 18+ is required on PATH before Tolaria can build MCP config: {e}")
-    })?;
-    let server_dir = mcp_server_dir()?;
-    let index_js = server_dir.join("index.js").to_string_lossy().into_owned();
-    let node_command = node.to_string_lossy().into_owned();
-    let entry = build_mcp_entry(&node_command, &index_js, vault_path);
-
-    build_mcp_config_snippet(&entry)
-}
-
 /// Write MCP registration to a list of config file paths.
 /// Returns "registered" on first registration, "updated" if already present.
 fn register_mcp_to_configs(entry: &serde_json::Value, config_paths: &[PathBuf]) -> String {
@@ -598,20 +502,6 @@ mod tests {
         write_config_json(config_path, serde_json::json!({ "mcpServers": servers }));
     }
 
-    struct ExpectedMcpServer<'a> {
-        index_js: &'a str,
-        vault_path: &'a str,
-    }
-
-    fn assert_registered_tolaria_server(
-        config: &serde_json::Value,
-        expected: ExpectedMcpServer<'_>,
-    ) {
-        let server = &config["mcpServers"][MCP_SERVER_NAME];
-        assert_eq!(server["args"][0], expected.index_js);
-        assert_eq!(server["env"]["VAULT_PATH"], expected.vault_path);
-    }
-
     fn write_index_js(dir: &Path) -> PathBuf {
         let index_js = dir.join("index.js");
         std::fs::write(&index_js, "console.log('ok');").unwrap();
@@ -629,69 +519,14 @@ mod tests {
     }
 
     #[test]
-    fn build_mcp_config_snippet_wraps_tolaria_server_entry() {
-        let entry = test_mcp_entry("/path/to/index.js", "/my/vault");
-        let snippet = build_mcp_config_snippet(&entry).unwrap();
-        let config: serde_json::Value = serde_json::from_str(&snippet).unwrap();
-
-        assert_eq!(
-            config["mcpServers"][MCP_SERVER_NAME]["args"][0],
-            "/path/to/index.js"
-        );
-        assert_eq!(
-            config["mcpServers"][MCP_SERVER_NAME]["env"]["VAULT_PATH"],
-            "/my/vault"
-        );
-    }
-
-    #[test]
-    fn node_lookup_paths_keep_non_empty_lines_in_order() {
+    fn first_node_lookup_path_uses_first_non_empty_line() {
         let stdout = b"\nC:\\Program Files\\nodejs\\node.exe\r\nC:\\Other\\node.exe\r\n";
         assert_eq!(
-            node_lookup_paths(stdout),
-            vec![
-                PathBuf::from("C:\\Program Files\\nodejs\\node.exe"),
-                PathBuf::from("C:\\Other\\node.exe"),
-            ]
+            first_node_lookup_path(stdout).unwrap(),
+            PathBuf::from("C:\\Program Files\\nodejs\\node.exe")
         );
     }
 
-    #[test]
-    fn first_existing_path_skips_empty_and_missing_lines() {
-        let dir = tempfile::tempdir().unwrap();
-        let missing = dir.path().join("missing-node");
-        let node = dir.path().join("node");
-        std::fs::write(&node, "#!/bin/sh\n").unwrap();
-
-        let stdout = format!("\n{}\n{}\n", missing.display(), node.display());
-
-        assert_eq!(first_existing_path(&stdout), Some(node));
-    }
-
-    #[cfg(unix)]
-    #[test]
-    fn command_path_from_shell_finds_node_from_login_shell() {
-        use std::os::unix::fs::PermissionsExt;
-
-        let dir = tempfile::tempdir().unwrap();
-        let node = dir.path().join("node");
-        std::fs::write(&node, "#!/bin/sh\n").unwrap();
-        std::fs::set_permissions(&node, std::fs::Permissions::from_mode(0o755)).unwrap();
-
-        let shell = dir.path().join("shell");
-        std::fs::write(
-            &shell,
-            format!(
-                "#!/bin/sh\nif [ \"$1\" = \"-lc\" ]; then echo '{}'; fi\n",
-                node.display()
-            ),
-        )
-        .unwrap();
-        std::fs::set_permissions(&shell, std::fs::Permissions::from_mode(0o755)).unwrap();
-
-        assert_eq!(command_path_from_shell(&shell, "node"), Some(node));
-    }
-
     #[test]
     fn node_major_version_accepts_current_node_output() {
         assert_eq!(node_major_version("v24.13.1\n"), Some(24));
@@ -699,25 +534,6 @@ mod tests {
         assert_eq!(node_major_version("not-node"), None);
     }
 
-    #[test]
-    fn node_binary_candidates_include_shell_managed_installs() {
-        let home = PathBuf::from("/Users/alex");
-        let candidates = node_binary_candidates_for_home(&home);
-        let expected = [
-            home.join(".local/share/mise/shims/node"),
-            home.join(".asdf/shims/node"),
-            home.join(".volta/bin/node"),
-        ];
-
-        for candidate in expected {
-            assert!(
-                candidates.contains(&candidate),
-                "missing {}",
-                candidate.display()
-            );
-        }
-    }
-
     #[test]
     fn mcp_server_dir_candidates_prefer_exe_dir_before_macos_resources() {
         let dev_path = Path::new("/repo/mcp-server");
@@ -749,12 +565,13 @@ mod tests {
         assert!(!was_update);
 
         let config = read_config(&config_path);
-        assert_registered_tolaria_server(
-            &config,
-            ExpectedMcpServer {
-                index_js: "/test/index.js",
-                vault_path: "/test/vault",
-            },
+        assert_eq!(
+            config["mcpServers"][MCP_SERVER_NAME]["args"][0],
+            "/test/index.js"
+        );
+        assert_eq!(
+            config["mcpServers"][MCP_SERVER_NAME]["env"]["VAULT_PATH"],
+            "/test/vault"
         );
     }
 
@@ -849,35 +666,6 @@ mod tests {
         assert!(config["mcpServers"][MCP_SERVER_NAME].is_object());
     }
 
-    #[test]
-    fn upsert_preserves_gemini_settings_json_fields() {
-        let (_tmp, config_path) = temp_config_path("settings.json");
-        write_config_json(
-            &config_path,
-            serde_json::json!({
-                "theme": "GitHub",
-                "mcpServers": {
-                    "other": { "command": "example" }
-                }
-            }),
-        );
-        let entry = test_mcp_entry("/gemini/index.js", "/gemini-vault");
-
-        let was_update = upsert_mcp_config(&config_path, &entry).unwrap();
-        let config = read_config(&config_path);
-
-        assert!(!was_update);
-        assert_eq!(config["theme"], "GitHub");
-        assert_eq!(config["mcpServers"]["other"]["command"], "example");
-        assert_registered_tolaria_server(
-            &config,
-            ExpectedMcpServer {
-                index_js: "/gemini/index.js",
-                vault_path: "/gemini-vault",
-            },
-        );
-    }
-
     #[test]
     fn upsert_creates_parent_dirs() {
         let tmp = tempfile::tempdir().unwrap();
@@ -948,7 +736,6 @@ mod tests {
         let tmp = tempfile::tempdir().unwrap();
         let claude_user_cfg = tmp.path().join(".claude.json");
         let claude_cfg = tmp.path().join("claude").join("mcp.json");
-        let gemini_cfg = tmp.path().join(".gemini").join("settings.json");
         let cursor_cfg = tmp.path().join("cursor").join("mcp.json");
         let generic_cfg = tmp.path().join(".config").join("mcp").join("mcp.json");
         let entry = test_mcp_entry("/test/index.js", "/vault");
@@ -958,7 +745,6 @@ mod tests {
             &[
                 claude_user_cfg.clone(),
                 claude_cfg.clone(),
-                gemini_cfg.clone(),
                 cursor_cfg.clone(),
                 generic_cfg.clone(),
             ],
@@ -966,18 +752,14 @@ mod tests {
 
         assert!(claude_user_cfg.exists());
         assert!(claude_cfg.exists());
-        assert!(gemini_cfg.exists());
         assert!(cursor_cfg.exists());
         assert!(generic_cfg.exists());
 
         let raw = std::fs::read_to_string(&claude_user_cfg).unwrap();
         let config: serde_json::Value = serde_json::from_str(&raw).unwrap();
-        assert_registered_tolaria_server(
-            &config,
-            ExpectedMcpServer {
-                index_js: "/test/index.js",
-                vault_path: "/vault",
-            },
+        assert_eq!(
+            config["mcpServers"][MCP_SERVER_NAME]["args"][0],
+            "/test/index.js"
         );
     }
 
@@ -991,7 +773,6 @@ mod tests {
             vec![
                 home.join(".claude.json"),
                 home.join(".claude").join("mcp.json"),
-                home.join(".gemini").join("settings.json"),
                 home.join(".cursor").join("mcp.json"),
                 home.join(".config").join("mcp").join("mcp.json"),
             ]

src-tauri/src/opencode_cli.rs

@@ -1,120 +1,58 @@
 use crate::ai_agents::{AiAgentAvailability, AiAgentStreamEvent};
-pub use crate::cli_agent_runtime::AgentStreamRequest;
-use std::path::Path;
+use std::io::BufRead;
+
+#[derive(Debug, Clone)]
+pub struct AgentStreamRequest {
+    pub message: String,
+    pub system_prompt: Option<String>,
+    pub vault_path: String,
+}
 
 pub fn check_cli() -> AiAgentAvailability {
     crate::opencode_discovery::check_cli()
 }
 
-pub fn run_agent_stream<F>(request: AgentStreamRequest, emit: F) -> Result<String, String>
+pub fn run_agent_stream<F>(request: AgentStreamRequest, mut emit: F) -> Result<String, String>
 where
     F: FnMut(AiAgentStreamEvent),
 {
     let binary = crate::opencode_discovery::find_binary()?;
-    run_agent_stream_with_binary(&binary, request, emit)
-}
+    let mut command = crate::opencode_config::build_command(&binary, &request)?;
+    let mut child = command
+        .spawn()
+        .map_err(|error| format!("Failed to spawn opencode: {error}"))?;
 
-fn run_agent_stream_with_binary<F>(
-    binary: &Path,
-    request: AgentStreamRequest,
-    emit: F,
-) -> Result<String, String>
-where
-    F: FnMut(AiAgentStreamEvent),
-{
-    let command = crate::opencode_config::build_command(binary, &request)?;
-    crate::cli_agent_runtime::run_ai_agent_json_stream(
-        command,
-        "opencode",
-        emit,
-        crate::opencode_events::session_id,
-        crate::opencode_events::dispatch_event,
-        crate::opencode_events::format_error,
-    )
-}
+    let stdout = child.stdout.take().ok_or("No stdout handle")?;
+    let reader = std::io::BufReader::new(stdout);
+    let mut session_id = String::new();
 
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::ai_agents::AiAgentPermissionMode;
+    for line in reader.lines() {
+        let json = match crate::opencode_events::parse_line(line, &mut emit) {
+            Some(json) => json,
+            None => continue,
+        };
 
-    #[cfg(unix)]
-    fn executable_script(dir: &Path, body: &str) -> std::path::PathBuf {
-        use std::os::unix::fs::PermissionsExt;
-
-        let script = dir.join("opencode");
-        std::fs::write(&script, format!("#!/bin/sh\n{body}")).unwrap();
-        std::fs::set_permissions(&script, std::fs::Permissions::from_mode(0o755)).unwrap();
-        script
-    }
-
-    fn request(vault_path: String) -> AgentStreamRequest {
-        AgentStreamRequest {
-            message: "Summarize".into(),
-            system_prompt: None,
-            vault_path,
-            permission_mode: AiAgentPermissionMode::Safe,
+        if let Some(id) = crate::opencode_events::session_id(&json) {
+            session_id = id.to_string();
         }
+
+        crate::opencode_events::dispatch_event(&json, &mut emit);
     }
 
-    #[cfg(unix)]
-    #[test]
-    fn run_agent_stream_maps_opencode_json_events() {
-        let dir = tempfile::tempdir().unwrap();
-        let vault = tempfile::tempdir().unwrap();
-        let binary = executable_script(
-            dir.path(),
-            r#"printf '%s\n' '{"type":"session","sessionID":"open_1"}'
-printf '%s\n' '{"type":"message","text":"Done"}'
-"#,
-        );
-
-        let mut events = Vec::new();
-        let session_id = run_agent_stream_with_binary(
-            &binary,
-            request(vault.path().to_string_lossy().into_owned()),
-            |event| events.push(event),
-        )
-        .unwrap();
-
-        assert_eq!(session_id, "open_1");
-        assert!(matches!(
-            &events[0],
-            AiAgentStreamEvent::Init { session_id } if session_id == "open_1"
-        ));
-        assert!(matches!(
-            &events[1],
-            AiAgentStreamEvent::TextDelta { text } if text == "Done"
-        ));
-        assert!(matches!(events.last(), Some(AiAgentStreamEvent::Done)));
+    let stderr_output = child
+        .stderr
+        .take()
+        .and_then(|stderr| std::io::read_to_string(stderr).ok())
+        .unwrap_or_default();
+    let status = child
+        .wait()
+        .map_err(|error| format!("Wait failed: {error}"))?;
+    if !status.success() {
+        emit(AiAgentStreamEvent::Error {
+            message: crate::opencode_events::format_error(stderr_output, status.to_string()),
+        });
     }
 
-    #[cfg(unix)]
-    #[test]
-    fn run_agent_stream_reports_opencode_nonzero_exit_errors() {
-        let dir = tempfile::tempdir().unwrap();
-        let vault = tempfile::tempdir().unwrap();
-        let binary = executable_script(
-            dir.path(),
-            r#"printf '%s\n' '{"type":"session","sessionID":"open_1"}'
-printf '%s\n' 'provider login required' >&2
-exit 3
-"#,
-        );
-
-        let mut events = Vec::new();
-        let session_id = run_agent_stream_with_binary(
-            &binary,
-            request(vault.path().to_string_lossy().into_owned()),
-            |event| events.push(event),
-        )
-        .unwrap();
-
-        assert_eq!(session_id, "open_1");
-        assert!(events.iter().any(|event| matches!(
-            event,
-            AiAgentStreamEvent::Error { message } if message.contains("provider configured")
-        )));
-        assert!(matches!(events.last(), Some(AiAgentStreamEvent::Done)));
-    }
+    emit(AiAgentStreamEvent::Done);
+    Ok(session_id)
 }

src-tauri/src/opencode_config.rs

@@ -1,4 +1,3 @@
-use crate::ai_agents::AiAgentPermissionMode;
 use crate::opencode_cli::AgentStreamRequest;
 use std::path::Path;
 use std::process::Stdio;
@@ -13,7 +12,7 @@ pub(crate) fn build_command(
         .arg(build_prompt(request))
         .env(
             "OPENCODE_CONFIG_CONTENT",
-            build_config(&request.vault_path, request.permission_mode)?,
+            build_config(&request.vault_path)?,
         )
         .current_dir(&request.vault_path)
         .stdin(Stdio::null())
@@ -27,18 +26,30 @@ fn build_args() -> Vec<String> {
 }
 
 fn build_prompt(request: &AgentStreamRequest) -> String {
-    crate::cli_agent_runtime::build_prompt(&request.message, request.system_prompt.as_deref())
+    match request
+        .system_prompt
+        .as_ref()
+        .map(|prompt| prompt.trim())
+        .filter(|prompt| !prompt.is_empty())
+    {
+        Some(system_prompt) => format!(
+            "System instructions:\n{system_prompt}\n\nUser request:\n{}",
+            request.message
+        ),
+        None => request.message.clone(),
+    }
 }
 
-fn build_config(
-    vault_path: &str,
-    permission_mode: AiAgentPermissionMode,
-) -> Result<String, String> {
-    let mcp_server_path = crate::cli_agent_runtime::mcp_server_path_string()?;
+fn build_config(vault_path: &str) -> Result<String, String> {
+    let mcp_server = crate::mcp::mcp_server_dir()?.join("index.js");
+    let mcp_server_path = mcp_server
+        .to_str()
+        .ok_or("Invalid MCP server path")?
+        .to_string();
 
     serde_json::to_string(&serde_json::json!({
         "$schema": "https://opencode.ai/config.json",
-        "permission": permission_config(permission_mode),
+        "permission": permission_config(),
         "mcp": {
             "tolaria": {
                 "type": "local",
@@ -51,12 +62,7 @@ fn build_config(
     .map_err(|error| format!("Failed to serialize opencode config: {error}"))
 }
 
-fn permission_config(permission_mode: AiAgentPermissionMode) -> serde_json::Value {
-    let bash_permission = match permission_mode {
-        AiAgentPermissionMode::Safe => "deny",
-        AiAgentPermissionMode::PowerUser => "allow",
-    };
-
+fn permission_config() -> serde_json::Value {
     serde_json::json!({
         "read": "allow",
         "edit": "allow",
@@ -64,7 +70,7 @@ fn permission_config(permission_mode: AiAgentPermissionMode) -> serde_json::Valu
         "grep": "allow",
         "list": "allow",
         "external_directory": "deny",
-        "bash": bash_permission
+        "bash": "deny"
     })
 }
 
@@ -79,7 +85,6 @@ mod tests {
             message: "Rename the note".into(),
             system_prompt: None,
             vault_path: "/tmp/vault".into(),
-            permission_mode: crate::ai_agents::AiAgentPermissionMode::Safe,
         }
     }
 
@@ -113,9 +118,7 @@ mod tests {
 
     #[test]
     fn config_includes_permissions_and_tolaria_mcp_server() {
-        if let Ok(config) =
-            build_config("/tmp/vault", crate::ai_agents::AiAgentPermissionMode::Safe)
-        {
+        if let Ok(config) = build_config("/tmp/vault") {
             let json: serde_json::Value = serde_json::from_str(&config).unwrap();
             assert_eq!(json["permission"]["edit"], "allow");
             assert_eq!(json["permission"]["external_directory"], "deny");
@@ -133,18 +136,6 @@ mod tests {
         }
     }
 
-    #[test]
-    fn power_user_config_allows_bash_but_keeps_external_directories_denied() {
-        if let Ok(config) = build_config(
-            "/tmp/vault",
-            crate::ai_agents::AiAgentPermissionMode::PowerUser,
-        ) {
-            let json: serde_json::Value = serde_json::from_str(&config).unwrap();
-            assert_eq!(json["permission"]["bash"], "allow");
-            assert_eq!(json["permission"]["external_directory"], "deny");
-        }
-    }
-
     #[test]
     fn prompt_keeps_system_prompt_first() {
         let prompt = build_prompt(&AgentStreamRequest {

src-tauri/src/opencode_discovery.rs

@@ -5,7 +5,7 @@ pub(crate) fn check_cli() -> AiAgentAvailability {
     match find_binary() {
         Ok(binary) => AiAgentAvailability {
             installed: true,
-            version: crate::cli_agent_runtime::version_for_binary(&binary),
+            version: version_for_binary(&binary),
         },
         Err(_) => AiAgentAvailability {
             installed: false,
@@ -30,22 +30,23 @@ pub(crate) fn find_binary() -> Result<PathBuf, String> {
     Err("OpenCode CLI not found. Install it: https://opencode.ai/docs/".into())
 }
 
+fn version_for_binary(binary: &PathBuf) -> Option<String> {
+    crate::hidden_command(binary)
+        .arg("--version")
+        .output()
+        .ok()
+        .filter(|output| output.status.success())
+        .map(|output| String::from_utf8_lossy(&output.stdout).trim().to_string())
+}
+
 fn find_binary_on_path() -> Option<PathBuf> {
-    crate::hidden_command(path_lookup_command())
+    crate::hidden_command("which")
         .arg("opencode")
         .output()
         .ok()
         .and_then(|output| path_from_successful_output(&output))
 }
 
-fn path_lookup_command() -> &'static str {
-    if cfg!(windows) {
-        "where"
-    } else {
-        "which"
-    }
-}
-
 fn find_binary_in_user_shell() -> Option<PathBuf> {
     user_shell_candidates()
         .into_iter()
@@ -106,26 +107,12 @@ fn opencode_binary_candidates() -> Vec<PathBuf> {
 fn opencode_binary_candidates_for_home(home: &Path) -> Vec<PathBuf> {
     vec![
         home.join(".local/bin/opencode"),
-        home.join(".local/bin/opencode.exe"),
         home.join(".opencode/bin/opencode"),
-        home.join(".opencode/bin/opencode.exe"),
         home.join(".local/share/mise/shims/opencode"),
-        home.join(".local/share/mise/shims/opencode.exe"),
         home.join(".asdf/shims/opencode"),
-        home.join(".asdf/shims/opencode.exe"),
         home.join(".npm-global/bin/opencode"),
-        home.join(".npm-global/bin/opencode.cmd"),
-        home.join(".npm-global/bin/opencode.exe"),
         home.join(".npm/bin/opencode"),
-        home.join(".npm/bin/opencode.cmd"),
-        home.join(".npm/bin/opencode.exe"),
         home.join(".bun/bin/opencode"),
-        home.join(".bun/bin/opencode.exe"),
-        home.join("AppData/Roaming/npm/opencode.cmd"),
-        home.join("AppData/Roaming/npm/opencode.exe"),
-        home.join("AppData/Local/pnpm/opencode.cmd"),
-        home.join("AppData/Local/pnpm/opencode.exe"),
-        home.join("scoop/shims/opencode.exe"),
         PathBuf::from("/usr/local/bin/opencode"),
         PathBuf::from("/opt/homebrew/bin/opencode"),
     ]
@@ -158,38 +145,6 @@ mod tests {
         }
     }
 
-    #[test]
-    fn binary_candidates_include_windows_npm_and_toolchain_shims() {
-        let home = PathBuf::from(r"C:\Users\alex");
-        let candidates = opencode_binary_candidates_for_home(&home);
-        let expected = [
-            home.join(".npm-global/bin/opencode.cmd"),
-            home.join(".npm-global/bin/opencode.exe"),
-            home.join(".npm/bin/opencode.cmd"),
-            home.join(".npm/bin/opencode.exe"),
-            home.join("AppData/Roaming/npm/opencode.cmd"),
-            home.join("AppData/Roaming/npm/opencode.exe"),
-            home.join("AppData/Local/pnpm/opencode.cmd"),
-            home.join("AppData/Local/pnpm/opencode.exe"),
-            home.join("scoop/shims/opencode.exe"),
-        ];
-
-        for candidate in expected {
-            assert!(
-                candidates.contains(&candidate),
-                "missing {}",
-                candidate.display()
-            );
-        }
-    }
-
-    #[test]
-    fn path_lookup_command_matches_current_platform() {
-        let expected = if cfg!(windows) { "where" } else { "which" };
-
-        assert_eq!(path_lookup_command(), expected);
-    }
-
     #[test]
     fn first_existing_path_skips_empty_and_missing_lines() {
         let dir = tempfile::tempdir().unwrap();

src-tauri/src/opencode_events.rs

@@ -1,6 +1,5 @@
 use crate::ai_agents::AiAgentStreamEvent;
 
-#[cfg(test)]
 pub(crate) fn parse_line<F>(
     line: Result<String, std::io::Error>,
     emit: &mut F,
@@ -8,7 +7,22 @@ pub(crate) fn parse_line<F>(
 where
     F: FnMut(AiAgentStreamEvent),
 {
-    crate::cli_agent_runtime::parse_ai_agent_json_line(line, emit)
+    let line = match line {
+        Ok(line) => line,
+        Err(error) => {
+            emit(AiAgentStreamEvent::Error {
+                message: format!("Read error: {error}"),
+            });
+            return None;
+        }
+    };
+
+    let trimmed = line.trim();
+    if trimmed.is_empty() {
+        return None;
+    }
+
+    serde_json::from_str::<serde_json::Value>(trimmed).ok()
 }
 
 pub(crate) fn dispatch_event<F>(json: &serde_json::Value, emit: &mut F)
@@ -87,8 +101,12 @@ where
     F: FnMut(AiAgentStreamEvent),
 {
     let tool_id = tool_id(json).unwrap_or("tool").to_string();
-    let tool_name = tool_name(json).unwrap_or("tool").to_string();
-    let input = tool_input(json);
+    let tool_name = json["name"]
+        .as_str()
+        .or_else(|| json["tool"].as_str())
+        .unwrap_or("tool")
+        .to_string();
+    let input = json.get("input").map(|input| input.to_string());
 
     emit(AiAgentStreamEvent::ToolStart {
         tool_name,
@@ -102,7 +120,10 @@ where
     F: FnMut(AiAgentStreamEvent),
 {
     let tool_id = tool_id(json).unwrap_or("tool").to_string();
-    let output = tool_output(json);
+    let output = json["output"]
+        .as_str()
+        .map(|output| output.to_string())
+        .or_else(|| json.get("result").map(|result| result.to_string()));
 
     emit(AiAgentStreamEvent::ToolDone { tool_id, output });
 }
@@ -119,50 +140,24 @@ where
 }
 
 fn tool_id(json: &serde_json::Value) -> Option<&str> {
-    first_string_field(
-        json,
-        &["id", "toolID", "tool_id", "toolCallID", "toolCallId"],
-    )
+    json["id"]
+        .as_str()
+        .or_else(|| json["toolID"].as_str())
+        .or_else(|| json["tool_id"].as_str())
 }
 
 fn text_value(json: &serde_json::Value) -> Option<&str> {
-    first_string_field(json, &["text", "content", "message"])
+    json["text"]
+        .as_str()
+        .or_else(|| json["content"].as_str())
+        .or_else(|| json["message"].as_str())
 }
 
 fn message_value(json: &serde_json::Value) -> Option<&str> {
-    first_string_field(json, &["message", "error", "text"])
-}
-
-fn tool_name(json: &serde_json::Value) -> Option<&str> {
-    first_string_field(json, &["name", "tool", "toolName"])
-}
-
-fn tool_input(json: &serde_json::Value) -> Option<String> {
-    first_json_field(json, &["input", "args"]).map(|input| input.to_string())
-}
-
-fn tool_output(json: &serde_json::Value) -> Option<String> {
-    first_json_field(json, &["output", "result"]).map(display_json_value)
-}
-
-fn first_string_field<'a>(json: &'a serde_json::Value, keys: &[&str]) -> Option<&'a str> {
-    keys.iter()
-        .find_map(|key| json[*key].as_str().or_else(|| json["part"][*key].as_str()))
-}
-
-fn first_json_field<'a>(
-    json: &'a serde_json::Value,
-    keys: &[&str],
-) -> Option<&'a serde_json::Value> {
-    keys.iter()
-        .find_map(|key| json.get(*key).or_else(|| json["part"].get(*key)))
-}
-
-fn display_json_value(value: &serde_json::Value) -> String {
-    value
+    json["message"]
         .as_str()
-        .map(|output| output.to_string())
-        .unwrap_or_else(|| value.to_string())
+        .or_else(|| json["error"].as_str())
+        .or_else(|| json["text"].as_str())
 }
 
 fn is_auth_error(lower: &str) -> bool {

src-tauri/src/opencode_events_tests.rs

@@ -1,61 +1,5 @@
 use super::*;
 
-fn dispatch_events(events: impl IntoIterator<Item = serde_json::Value>) -> Vec<AiAgentStreamEvent> {
-    let mut mapped = Vec::new();
-
-    for event in events {
-        dispatch_event(&event, &mut |event| mapped.push(event));
-    }
-
-    mapped
-}
-
-struct ToolExpectation<'a> {
-    tool_id: &'a str,
-    tool_name: &'a str,
-    input: Option<&'a str>,
-    output: Option<&'a str>,
-}
-
-fn assert_tool_pair(events: &[AiAgentStreamEvent], expected: ToolExpectation<'_>) {
-    assert!(matches!(
-        &events[0],
-        AiAgentStreamEvent::ToolStart {
-            tool_name: actual_name,
-            tool_id: actual_id,
-            input: actual_input,
-        } if actual_name == expected.tool_name
-            && actual_id == expected.tool_id
-            && actual_input.as_deref() == expected.input
-    ));
-    assert!(matches!(
-        &events[1],
-        AiAgentStreamEvent::ToolDone {
-            tool_id: actual_id,
-            output: actual_output,
-        } if actual_id == expected.tool_id && actual_output.as_deref() == expected.output
-    ));
-}
-
-#[test]
-fn parse_line_reports_read_errors_and_skips_blank_or_invalid_lines() {
-    let mut events = Vec::new();
-
-    let read_error = parse_line(Err(std::io::Error::other("broken pipe")), &mut |event| {
-        events.push(event)
-    });
-    let blank = parse_line(Ok("   ".into()), &mut |event| events.push(event));
-    let invalid = parse_line(Ok("not json".into()), &mut |event| events.push(event));
-
-    assert!(read_error.is_none());
-    assert!(blank.is_none());
-    assert!(invalid.is_none());
-    assert!(matches!(
-        &events[0],
-        AiAgentStreamEvent::Error { message } if message.contains("broken pipe")
-    ));
-}
-
 #[test]
 fn dispatch_maps_session_reasoning_and_text() {
     let mut events = Vec::new();
@@ -82,90 +26,28 @@ fn dispatch_maps_session_reasoning_and_text() {
 }
 
 #[test]
-fn dispatch_maps_part_backed_reasoning_and_text() {
+fn dispatch_maps_tool_events() {
     let mut events = Vec::new();
-    let reasoning = serde_json::json!({
-        "type": "reasoning",
-        "part": { "type": "reasoning", "text": "Checking links" }
-    });
-    let text = serde_json::json!({
-        "type": "text",
-        "part": { "type": "text", "text": "Done from OpenCode" }
+    let tool_start = serde_json::json!({
+        "type": "tool_use",
+        "id": "tool_1",
+        "name": "read",
+        "input": { "path": "Note.md" }
     });
+    let tool_done = serde_json::json!({ "type": "tool_result", "id": "tool_1", "output": "ok" });
 
-    for event in [reasoning, text] {
-        dispatch_event(&event, &mut |event| events.push(event));
-    }
+    dispatch_event(&tool_start, &mut |event| events.push(event));
+    dispatch_event(&tool_done, &mut |event| events.push(event));
 
     assert!(matches!(
         &events[0],
-        AiAgentStreamEvent::ThinkingDelta { text } if text == "Checking links"
+        AiAgentStreamEvent::ToolStart { tool_name, tool_id, input }
+            if tool_name == "read" && tool_id == "tool_1" && input.as_deref() == Some(r#"{"path":"Note.md"}"#)
     ));
     assert!(matches!(
         &events[1],
-        AiAgentStreamEvent::TextDelta { text } if text == "Done from OpenCode"
-    ));
-}
-
-#[test]
-fn dispatch_maps_tool_events() {
-    let direct = dispatch_events([
-        serde_json::json!({
-            "type": "tool_use",
-            "id": "tool_1",
-            "name": "read",
-            "input": { "path": "Note.md" }
-        }),
-        serde_json::json!({ "type": "tool_result", "id": "tool_1", "output": "ok" }),
-    ]);
-    let part_backed = dispatch_events([
-        serde_json::json!({
-            "type": "tool_use",
-            "part": {
-                "id": "prt_tool_1",
-                "tool": "read",
-                "input": { "path": "Note.md" }
-            }
-        }),
-        serde_json::json!({
-            "type": "tool_result",
-            "part": {
-                "id": "prt_tool_1",
-                "output": "ok"
-            }
-        }),
-    ]);
-
-    assert_tool_pair(
-        &direct,
-        ToolExpectation {
-            tool_id: "tool_1",
-            tool_name: "read",
-            input: Some(r#"{"path":"Note.md"}"#),
-            output: Some("ok"),
-        },
-    );
-    assert_tool_pair(
-        &part_backed,
-        ToolExpectation {
-            tool_id: "prt_tool_1",
-            tool_name: "read",
-            input: Some(r#"{"path":"Note.md"}"#),
-            output: Some("ok"),
-        },
-    );
-}
-
-#[test]
-fn dispatch_maps_error_events() {
-    let mut events = Vec::new();
-    let error = serde_json::json!({ "type": "error", "message": "provider failed" });
-
-    dispatch_event(&error, &mut |event| events.push(event));
-
-    assert!(matches!(
-        &events[0],
-        AiAgentStreamEvent::Error { message } if message == "provider failed"
+        AiAgentStreamEvent::ToolDone { tool_id, output }
+            if tool_id == "tool_1" && output.as_deref() == Some("ok")
     ));
 }
 
@@ -179,12 +61,3 @@ fn format_error_explains_missing_auth_or_provider_setup() {
     assert!(message.contains("OpenCode CLI is not authenticated"));
     assert!(message.contains("opencode auth login"));
 }
-
-#[test]
-fn format_error_uses_status_or_first_stderr_lines() {
-    let empty = format_error(String::new(), "exit status: 2".into());
-    let truncated = format_error("line 1\nline 2\nline 3\nline 4".into(), "ignored".into());
-
-    assert_eq!(empty, "opencode exited with status exit status: 2");
-    assert_eq!(truncated, "line 1\nline 2\nline 3");
-}

src-tauri/src/pi_cli.rs

@@ -1,124 +1,62 @@
 use crate::ai_agents::{AiAgentAvailability, AiAgentStreamEvent};
-pub use crate::cli_agent_runtime::AgentStreamRequest;
-use std::path::Path;
+use std::io::BufRead;
+
+#[derive(Debug, Clone)]
+pub struct AgentStreamRequest {
+    pub message: String,
+    pub system_prompt: Option<String>,
+    pub vault_path: String,
+}
 
 pub fn check_cli() -> AiAgentAvailability {
     crate::pi_discovery::check_cli()
 }
 
-pub fn run_agent_stream<F>(request: AgentStreamRequest, emit: F) -> Result<String, String>
+pub fn run_agent_stream<F>(request: AgentStreamRequest, mut emit: F) -> Result<String, String>
 where
     F: FnMut(AiAgentStreamEvent),
 {
     let binary = crate::pi_discovery::find_binary()?;
-    run_agent_stream_with_binary(&binary, request, emit)
-}
-
-fn run_agent_stream_with_binary<F>(
-    binary: &Path,
-    request: AgentStreamRequest,
-    emit: F,
-) -> Result<String, String>
-where
-    F: FnMut(AiAgentStreamEvent),
-{
     let agent_dir = tempfile::Builder::new()
         .prefix("tolaria-pi-agent-")
         .tempdir()
         .map_err(|error| format!("Failed to create Pi config directory: {error}"))?;
-    let command = crate::pi_config::build_command(binary, &request, agent_dir.path())?;
-    crate::cli_agent_runtime::run_ai_agent_json_stream(
-        command,
-        "pi",
-        emit,
-        crate::pi_events::session_id,
-        crate::pi_events::dispatch_event,
-        crate::pi_events::format_error,
-    )
-}
+    let mut command = crate::pi_config::build_command(&binary, &request, agent_dir.path())?;
+    let mut child = command
+        .spawn()
+        .map_err(|error| format!("Failed to spawn pi: {error}"))?;
 
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::ai_agents::AiAgentPermissionMode;
+    let stdout = child.stdout.take().ok_or("No stdout handle")?;
+    let reader = std::io::BufReader::new(stdout);
+    let mut session_id = String::new();
 
-    #[cfg(unix)]
-    fn executable_script(dir: &Path, body: &str) -> std::path::PathBuf {
-        use std::os::unix::fs::PermissionsExt;
+    for line in reader.lines() {
+        let json = match crate::pi_events::parse_line(line, &mut emit) {
+            Some(json) => json,
+            None => continue,
+        };
 
-        let script = dir.join("pi");
-        std::fs::write(&script, format!("#!/bin/sh\n{body}")).unwrap();
-        std::fs::set_permissions(&script, std::fs::Permissions::from_mode(0o755)).unwrap();
-        script
-    }
-
-    fn request(vault_path: String) -> AgentStreamRequest {
-        AgentStreamRequest {
-            message: "Summarize".into(),
-            system_prompt: None,
-            vault_path,
-            permission_mode: AiAgentPermissionMode::Safe,
+        if let Some(id) = crate::pi_events::session_id(&json) {
+            session_id = id.to_string();
         }
+
+        crate::pi_events::dispatch_event(&json, &mut emit);
     }
 
-    #[cfg(unix)]
-    #[test]
-    fn run_agent_stream_maps_pi_json_events() {
-        let dir = tempfile::tempdir().unwrap();
-        let vault = tempfile::tempdir().unwrap();
-        let binary = executable_script(
-            dir.path(),
-            r#"printf '%s\n' '{"type":"session","id":"pi_1"}'
-printf '%s\n' '{"type":"message_update","assistantMessageEvent":{"type":"text_delta","delta":"Done"}}'
-"#,
-        );
-
-        let mut events = Vec::new();
-        let session_id = run_agent_stream_with_binary(
-            &binary,
-            request(vault.path().to_string_lossy().into_owned()),
-            |event| events.push(event),
-        )
-        .unwrap();
-
-        assert_eq!(session_id, "pi_1");
-        assert!(matches!(
-            &events[0],
-            AiAgentStreamEvent::Init { session_id } if session_id == "pi_1"
-        ));
-        assert!(matches!(
-            &events[1],
-            AiAgentStreamEvent::TextDelta { text } if text == "Done"
-        ));
-        assert!(matches!(events.last(), Some(AiAgentStreamEvent::Done)));
+    let stderr_output = child
+        .stderr
+        .take()
+        .and_then(|stderr| std::io::read_to_string(stderr).ok())
+        .unwrap_or_default();
+    let status = child
+        .wait()
+        .map_err(|error| format!("Wait failed: {error}"))?;
+    if !status.success() {
+        emit(AiAgentStreamEvent::Error {
+            message: crate::pi_events::format_error(stderr_output, status.to_string()),
+        });
     }
 
-    #[cfg(unix)]
-    #[test]
-    fn run_agent_stream_reports_pi_nonzero_exit_errors() {
-        let dir = tempfile::tempdir().unwrap();
-        let vault = tempfile::tempdir().unwrap();
-        let binary = executable_script(
-            dir.path(),
-            r#"printf '%s\n' '{"type":"session","id":"pi_1"}'
-printf '%s\n' 'api key login required' >&2
-exit 4
-"#,
-        );
-
-        let mut events = Vec::new();
-        let session_id = run_agent_stream_with_binary(
-            &binary,
-            request(vault.path().to_string_lossy().into_owned()),
-            |event| events.push(event),
-        )
-        .unwrap();
-
-        assert_eq!(session_id, "pi_1");
-        assert!(events.iter().any(|event| matches!(
-            event,
-            AiAgentStreamEvent::Error { message } if message.contains("not authenticated")
-        )));
-        assert!(matches!(events.last(), Some(AiAgentStreamEvent::Done)));
-    }
+    emit(AiAgentStreamEvent::Done);
+    Ok(session_id)
 }

src-tauri/src/pi_config.rs

@@ -1,4 +1,3 @@
-use crate::ai_agents::AiAgentPermissionMode;
 use crate::pi_cli::AgentStreamRequest;
 use std::path::Path;
 use std::process::Stdio;
@@ -8,7 +7,7 @@ pub(crate) fn build_command(
     request: &AgentStreamRequest,
     agent_dir: &Path,
 ) -> Result<std::process::Command, String> {
-    write_mcp_config(agent_dir, &request.vault_path, request.permission_mode)?;
+    write_mcp_config(agent_dir, &request.vault_path)?;
 
     let mut command = crate::hidden_command(binary);
     command
@@ -33,26 +32,34 @@ fn build_args() -> Vec<String> {
 }
 
 fn build_prompt(request: &AgentStreamRequest) -> String {
-    crate::cli_agent_runtime::build_prompt(&request.message, request.system_prompt.as_deref())
+    match request
+        .system_prompt
+        .as_ref()
+        .map(|prompt| prompt.trim())
+        .filter(|prompt| !prompt.is_empty())
+    {
+        Some(system_prompt) => format!(
+            "System instructions:\n{system_prompt}\n\nUser request:\n{}",
+            request.message
+        ),
+        None => request.message.clone(),
+    }
 }
 
-fn write_mcp_config(
-    agent_dir: &Path,
-    vault_path: &str,
-    permission_mode: AiAgentPermissionMode,
-) -> Result<(), String> {
+fn write_mcp_config(agent_dir: &Path, vault_path: &str) -> Result<(), String> {
     std::fs::create_dir_all(agent_dir)
         .map_err(|error| format!("Failed to create Pi agent directory: {error}"))?;
-    let config = build_mcp_config(vault_path, permission_mode)?;
+    let config = build_mcp_config(vault_path)?;
     std::fs::write(agent_dir.join("mcp.json"), config)
         .map_err(|error| format!("Failed to write Pi MCP config: {error}"))
 }
 
-fn build_mcp_config(
-    vault_path: &str,
-    _permission_mode: AiAgentPermissionMode,
-) -> Result<String, String> {
-    let mcp_server_path = crate::cli_agent_runtime::mcp_server_path_string()?;
+fn build_mcp_config(vault_path: &str) -> Result<String, String> {
+    let mcp_server = crate::mcp::mcp_server_dir()?.join("index.js");
+    let mcp_server_path = mcp_server
+        .to_str()
+        .ok_or("Invalid MCP server path")?
+        .to_string();
 
     serde_json::to_string(&serde_json::json!({
         "settings": {
@@ -86,7 +93,6 @@ mod tests {
             message: "Rename the note".into(),
             system_prompt: None,
             vault_path: "/tmp/vault".into(),
-            permission_mode: crate::ai_agents::AiAgentPermissionMode::Safe,
         }
     }
 
@@ -123,9 +129,7 @@ mod tests {
 
     #[test]
     fn mcp_config_includes_tolaria_server_for_active_vault() {
-        if let Ok(config) =
-            build_mcp_config("/tmp/vault", crate::ai_agents::AiAgentPermissionMode::Safe)
-        {
+        if let Ok(config) = build_mcp_config("/tmp/vault") {
             let json: serde_json::Value = serde_json::from_str(&config).unwrap();
             assert_eq!(json["settings"]["toolPrefix"], "none");
             assert_eq!(json["mcpServers"]["tolaria"]["command"], "node");
@@ -143,19 +147,6 @@ mod tests {
         }
     }
 
-    #[test]
-    fn power_user_mode_uses_the_same_pi_mcp_config_as_safe_mode() {
-        let safe =
-            build_mcp_config("/tmp/vault", crate::ai_agents::AiAgentPermissionMode::Safe).unwrap();
-        let power = build_mcp_config(
-            "/tmp/vault",
-            crate::ai_agents::AiAgentPermissionMode::PowerUser,
-        )
-        .unwrap();
-
-        assert_eq!(safe, power);
-    }
-
     #[test]
     fn prompt_keeps_system_prompt_first() {
         let prompt = build_prompt(&AgentStreamRequest {

src-tauri/src/pi_discovery.rs

@@ -5,7 +5,7 @@ pub(crate) fn check_cli() -> AiAgentAvailability {
     match find_binary() {
         Ok(binary) => AiAgentAvailability {
             installed: true,
-            version: crate::cli_agent_runtime::version_for_binary(&binary),
+            version: version_for_binary(&binary),
         },
         Err(_) => AiAgentAvailability {
             installed: false,
@@ -30,22 +30,23 @@ pub(crate) fn find_binary() -> Result<PathBuf, String> {
     Err("Pi CLI not found. Install it: https://pi.dev".into())
 }
 
+fn version_for_binary(binary: &PathBuf) -> Option<String> {
+    crate::hidden_command(binary)
+        .arg("--version")
+        .output()
+        .ok()
+        .filter(|output| output.status.success())
+        .map(|output| String::from_utf8_lossy(&output.stdout).trim().to_string())
+}
+
 fn find_binary_on_path() -> Option<PathBuf> {
-    crate::hidden_command(path_lookup_command())
+    crate::hidden_command("which")
         .arg("pi")
         .output()
         .ok()
         .and_then(|output| path_from_successful_output(&output))
 }
 
-fn path_lookup_command() -> &'static str {
-    if cfg!(windows) {
-        "where"
-    } else {
-        "which"
-    }
-}
-
 fn find_binary_in_user_shell() -> Option<PathBuf> {
     user_shell_candidates()
         .into_iter()
@@ -98,97 +99,25 @@ fn find_existing_binary(candidates: Vec<PathBuf>) -> Option<PathBuf> {
 }
 
 fn pi_binary_candidates() -> Vec<PathBuf> {
-    let mut candidates = pi_binary_candidates_from_env();
-
-    if let Some(home) = dirs::home_dir() {
-        candidates.extend(pi_binary_candidates_for_home(&home));
-    }
-
-    candidates.extend(pi_global_binary_candidates());
-    candidates
+    dirs::home_dir()
+        .map(|home| pi_binary_candidates_for_home(&home))
+        .unwrap_or_default()
 }
 
 fn pi_binary_candidates_for_home(home: &Path) -> Vec<PathBuf> {
-    let mut candidates = pi_nvm_binary_candidates_for_home(home);
-    candidates.extend([
-        home.join(".local/bin/pi"),
-        home.join(".local/bin/pi.exe"),
-        home.join(".pi/bin/pi"),
-        home.join(".pi/bin/pi.exe"),
-        home.join(".local/share/mise/shims/pi"),
-        home.join(".local/share/mise/shims/pi.exe"),
-        home.join(".asdf/shims/pi"),
-        home.join(".asdf/shims/pi.exe"),
-        home.join(".npm-global/bin/pi"),
-        home.join(".npm-global/bin/pi.cmd"),
-        home.join(".npm-global/bin/pi.exe"),
-        home.join(".npm/bin/pi"),
-        home.join(".npm/bin/pi.cmd"),
-        home.join(".npm/bin/pi.exe"),
-        home.join(".bun/bin/pi"),
-        home.join(".bun/bin/pi.exe"),
-        home.join("AppData/Roaming/npm/pi.cmd"),
-        home.join("AppData/Roaming/npm/pi.exe"),
-        home.join("AppData/Local/pnpm/pi.cmd"),
-        home.join("AppData/Local/pnpm/pi.exe"),
-        home.join("scoop/shims/pi.exe"),
-    ]);
-    candidates
-}
-
-fn pi_global_binary_candidates() -> Vec<PathBuf> {
     vec![
+        home.join(".local/bin/pi"),
+        home.join(".pi/bin/pi"),
+        home.join(".local/share/mise/shims/pi"),
+        home.join(".asdf/shims/pi"),
+        home.join(".npm-global/bin/pi"),
+        home.join(".npm/bin/pi"),
+        home.join(".bun/bin/pi"),
         PathBuf::from("/usr/local/bin/pi"),
         PathBuf::from("/opt/homebrew/bin/pi"),
     ]
 }
 
-fn pi_binary_candidates_from_env() -> Vec<PathBuf> {
-    let nvm_bin = std::env::var_os("NVM_BIN").map(PathBuf::from);
-    let npm_config_prefix = std::env::var_os("npm_config_prefix").map(PathBuf::from);
-    let npm_config_prefix_upper = std::env::var_os("NPM_CONFIG_PREFIX").map(PathBuf::from);
-
-    pi_binary_candidates_from_prefixes(nvm_bin, npm_config_prefix, npm_config_prefix_upper)
-}
-
-fn pi_binary_candidates_from_prefixes(
-    nvm_bin: Option<PathBuf>,
-    npm_config_prefix: Option<PathBuf>,
-    npm_config_prefix_upper: Option<PathBuf>,
-) -> Vec<PathBuf> {
-    let mut candidates = Vec::new();
-
-    if let Some(path) = nvm_bin.filter(|path| !path.as_os_str().is_empty()) {
-        candidates.push(path.join("pi"));
-    }
-    if let Some(path) = npm_config_prefix.filter(|path| !path.as_os_str().is_empty()) {
-        candidates.push(path.join("bin/pi"));
-    }
-    if let Some(path) = npm_config_prefix_upper.filter(|path| !path.as_os_str().is_empty()) {
-        candidates.push(path.join("bin/pi"));
-    }
-
-    candidates
-}
-
-fn pi_nvm_binary_candidates_for_home(home: &Path) -> Vec<PathBuf> {
-    let versions_dir = home.join(".nvm/versions/node");
-    let mut version_dirs = match std::fs::read_dir(versions_dir) {
-        Ok(entries) => entries
-            .flatten()
-            .map(|entry| entry.path())
-            .filter(|path| path.is_dir())
-            .collect::<Vec<_>>(),
-        Err(_) => return Vec::new(),
-    };
-
-    version_dirs.sort_by(|left, right| right.file_name().cmp(&left.file_name()));
-    version_dirs
-        .into_iter()
-        .map(|version_dir| version_dir.join("bin/pi"))
-        .collect()
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -204,6 +133,7 @@ mod tests {
             home.join(".asdf/shims/pi"),
             home.join(".npm-global/bin/pi"),
             home.join(".bun/bin/pi"),
+            PathBuf::from("/opt/homebrew/bin/pi"),
         ];
 
         for candidate in expected {
@@ -215,85 +145,6 @@ mod tests {
         }
     }
 
-    #[test]
-    fn binary_candidates_include_windows_npm_and_toolchain_shims() {
-        let home = PathBuf::from(r"C:\Users\alex");
-        let candidates = pi_binary_candidates_for_home(&home);
-        let expected = [
-            home.join(".npm-global/bin/pi.cmd"),
-            home.join(".npm-global/bin/pi.exe"),
-            home.join(".npm/bin/pi.cmd"),
-            home.join(".npm/bin/pi.exe"),
-            home.join("AppData/Roaming/npm/pi.cmd"),
-            home.join("AppData/Roaming/npm/pi.exe"),
-            home.join("AppData/Local/pnpm/pi.cmd"),
-            home.join("AppData/Local/pnpm/pi.exe"),
-            home.join("scoop/shims/pi.exe"),
-        ];
-
-        for candidate in expected {
-            assert!(
-                candidates.contains(&candidate),
-                "missing {}",
-                candidate.display()
-            );
-        }
-    }
-
-    #[test]
-    fn path_lookup_command_matches_current_platform() {
-        let expected = if cfg!(windows) { "where" } else { "which" };
-
-        assert_eq!(path_lookup_command(), expected);
-    }
-
-    #[test]
-    fn binary_candidates_include_nvm_node_version_installs() {
-        let home = tempfile::tempdir().unwrap();
-        let pi = home.path().join(".nvm/versions/node/v22.20.0/bin/pi");
-
-        std::fs::create_dir_all(pi.parent().unwrap()).unwrap();
-        std::fs::write(&pi, "#!/bin/sh\n").unwrap();
-
-        let candidates = pi_binary_candidates_for_home(home.path());
-
-        assert!(
-            candidates.contains(&pi),
-            "missing nvm candidate {}",
-            pi.display()
-        );
-    }
-
-    #[test]
-    fn binary_candidates_include_static_global_fallbacks() {
-        let candidates = pi_global_binary_candidates();
-
-        assert!(candidates.contains(&PathBuf::from("/usr/local/bin/pi")));
-        assert!(candidates.contains(&PathBuf::from("/opt/homebrew/bin/pi")));
-    }
-
-    #[test]
-    fn binary_candidates_include_env_provided_npm_and_nvm_prefixes() {
-        let nvm_bin = PathBuf::from("/Users/alex/.nvm/versions/node/v22.20.0/bin");
-        let npm_config_prefix = PathBuf::from("/Users/alex/.npm-global");
-        let npm_config_prefix_upper = PathBuf::from("/Users/alex/.npm");
-
-        let candidates = pi_binary_candidates_from_prefixes(
-            Some(nvm_bin.clone()),
-            Some(npm_config_prefix.clone()),
-            Some(npm_config_prefix_upper.clone()),
-        );
-
-        assert_eq!(
-            candidates,
-            vec![
-                nvm_bin.join("pi"),
-                npm_config_prefix.join("bin/pi"),
-                npm_config_prefix_upper.join("bin/pi"),
-            ]
-        );
-    }
-
     #[test]
     fn first_existing_path_skips_empty_and_missing_lines() {
         let dir = tempfile::tempdir().unwrap();

src-tauri/src/pi_events.rs

@@ -1,6 +1,5 @@
 use crate::ai_agents::AiAgentStreamEvent;
 
-#[cfg(test)]
 pub(crate) fn parse_line<F>(
     line: Result<String, std::io::Error>,
     emit: &mut F,
@@ -8,7 +7,22 @@ pub(crate) fn parse_line<F>(
 where
     F: FnMut(AiAgentStreamEvent),
 {
-    crate::cli_agent_runtime::parse_ai_agent_json_line(line, emit)
+    let line = match line {
+        Ok(line) => line,
+        Err(error) => {
+            emit(AiAgentStreamEvent::Error {
+                message: format!("Read error: {error}"),
+            });
+            return None;
+        }
+    };
+
+    let trimmed = line.trim();
+    if trimmed.is_empty() {
+        return None;
+    }
+
+    serde_json::from_str::<serde_json::Value>(trimmed).ok()
 }
 
 pub(crate) fn dispatch_event<F>(json: &serde_json::Value, emit: &mut F)

src-tauri/src/pi_events_tests.rs

@@ -1,24 +1,5 @@
 use super::*;
 
-#[test]
-fn parse_line_reports_read_errors_and_skips_blank_or_invalid_lines() {
-    let mut events = Vec::new();
-
-    let read_error = parse_line(Err(std::io::Error::other("broken pipe")), &mut |event| {
-        events.push(event)
-    });
-    let blank = parse_line(Ok("   ".into()), &mut |event| events.push(event));
-    let invalid = parse_line(Ok("not json".into()), &mut |event| events.push(event));
-
-    assert!(read_error.is_none());
-    assert!(blank.is_none());
-    assert!(invalid.is_none());
-    assert!(matches!(
-        &events[0],
-        AiAgentStreamEvent::Error { message } if message.contains("broken pipe")
-    ));
-}
-
 #[test]
 fn dispatch_maps_session_thinking_and_text() {
     let mut events = Vec::new();
@@ -81,19 +62,6 @@ fn dispatch_maps_tool_events() {
     ));
 }
 
-#[test]
-fn dispatch_maps_error_events() {
-    let mut events = Vec::new();
-    let error = serde_json::json!({ "type": "error", "message": "provider failed" });
-
-    dispatch_event(&error, &mut |event| events.push(event));
-
-    assert!(matches!(
-        &events[0],
-        AiAgentStreamEvent::Error { message } if message == "provider failed"
-    ));
-}
-
 #[test]
 fn format_error_explains_missing_auth_or_provider_setup() {
     let message = format_error(
@@ -104,12 +72,3 @@ fn format_error_explains_missing_auth_or_provider_setup() {
     assert!(message.contains("Pi CLI is not authenticated"));
     assert!(message.contains("pi /login"));
 }
-
-#[test]
-fn format_error_uses_status_or_first_stderr_lines() {
-    let empty = format_error(String::new(), "exit status: 2".into());
-    let truncated = format_error("line 1\nline 2\nline 3\nline 4".into(), "ignored".into());
-
-    assert_eq!(empty, "pi exited with status exit status: 2");
-    assert_eq!(truncated, "line 1\nline 2\nline 3");
-}

src-tauri/src/telemetry.rs

@@ -1,7 +1,5 @@
 use crate::settings;
-use chrono::NaiveDate;
 use regex::Regex;
-use std::borrow::Cow;
 use std::sync::Mutex;
 
 /// Global Sentry guard — must live for the duration of the app.
@@ -46,41 +44,6 @@ fn parse_embedded_sentry_dsn(raw: Option<&str>) -> Option<sentry::types::Dsn> {
     normalize_http_like_value(&normalized).parse().ok()
 }
 
-fn is_stable_calendar_release(version: &str) -> bool {
-    let mut parts = version.split('.');
-    let (Some(year), Some(month), Some(day)) = (parts.next(), parts.next(), parts.next()) else {
-        return false;
-    };
-
-    if parts.next().is_some() {
-        return false;
-    }
-
-    let (Ok(year), Ok(month), Ok(day)) = (
-        year.parse::<i32>(),
-        month.parse::<u32>(),
-        day.parse::<u32>(),
-    ) else {
-        return false;
-    };
-
-    NaiveDate::from_ymd_opt(year, month, day).is_some()
-}
-
-fn sentry_release_for_version(version: &'static str) -> Option<Cow<'static, str>> {
-    is_stable_calendar_release(version).then(|| version.into())
-}
-
-fn sentry_release_kind(version: &str) -> &'static str {
-    if is_stable_calendar_release(version) {
-        "stable"
-    } else if version.contains('-') {
-        "prerelease"
-    } else {
-        "internal"
-    }
-}
-
 /// Initialize Sentry if the user has opted in to crash reporting.
 /// Returns `true` if Sentry was initialized, `false` if skipped.
 pub fn init_sentry_from_settings() -> bool {
@@ -98,10 +61,9 @@ pub fn init_sentry_from_settings() -> bool {
     };
 
     let anonymous_id = settings.anonymous_id.unwrap_or_default();
-    let build_version = env!("CARGO_PKG_VERSION");
     let guard = sentry::init(sentry::ClientOptions {
         dsn: Some(dsn),
-        release: sentry_release_for_version(build_version),
+        release: Some(env!("CARGO_PKG_VERSION").into()),
         send_default_pii: false,
         before_send: Some(std::sync::Arc::new(|mut event| {
             if let Some(ref mut msg) = event.message {
@@ -117,8 +79,6 @@ pub fn init_sentry_from_settings() -> bool {
             id: Some(anonymous_id),
             ..Default::default()
         }));
-        scope.set_tag("tolaria.build_version", build_version);
-        scope.set_tag("tolaria.release_kind", sentry_release_kind(build_version));
     });
 
     *SENTRY_GUARD.lock().unwrap() = Some(guard);
@@ -200,26 +160,4 @@ mod tests {
         // Without SENTRY_DSN env var set at compile time, init should return false
         assert!(!init_sentry_from_settings());
     }
-
-    #[test]
-    fn test_sentry_release_for_stable_calendar_version() {
-        assert!(sentry_release_for_version("2026.4.28").is_some());
-    }
-
-    #[test]
-    fn test_sentry_release_for_alpha_version_is_none() {
-        assert!(sentry_release_for_version("2026.4.28-alpha.7").is_none());
-    }
-
-    #[test]
-    fn test_sentry_release_for_local_dev_version_is_none() {
-        assert!(sentry_release_for_version("0.1.0").is_none());
-    }
-
-    #[test]
-    fn test_sentry_release_kind_classifies_versions() {
-        assert_eq!(sentry_release_kind("2026.4.28"), "stable");
-        assert_eq!(sentry_release_kind("2026.4.28-alpha.7"), "prerelease");
-        assert_eq!(sentry_release_kind("0.1.0"), "internal");
-    }
 }

src-tauri/src/vault/config_seed.rs

@@ -58,16 +58,6 @@ _organized: true
 This file is only a Claude Code compatibility shim. Keep shared agent instructions in `AGENTS.md`.
 ";
 
-const GEMINI_MD_SHIM: &str = "---
-type: Note
-_organized: true
----
-
-@AGENTS.md
-
-This file is only a Gemini CLI compatibility shim. Keep shared agent instructions in `AGENTS.md`.
-";
-
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
 #[serde(rename_all = "snake_case")]
 pub enum AiGuidanceFileState {
@@ -81,16 +71,9 @@ pub enum AiGuidanceFileState {
 pub struct VaultAiGuidanceStatus {
     pub agents_state: AiGuidanceFileState,
     pub claude_state: AiGuidanceFileState,
-    pub gemini_state: AiGuidanceFileState,
     pub can_restore: bool,
 }
 
-struct GuidancePaths {
-    agents: PathBuf,
-    claude: PathBuf,
-    gemini: PathBuf,
-}
-
 #[derive(Debug, Default)]
 struct LegacyAgentsMigrationOutcome {
     copied_to_root: bool,
@@ -126,10 +109,6 @@ fn matches_claude_shim(content: &str) -> bool {
         || trimmed == CLAUDE_MD_SHIM.trim()
 }
 
-fn matches_gemini_shim(content: &str) -> bool {
-    content.trim() == GEMINI_MD_SHIM.trim()
-}
-
 fn claude_shim_can_be_replaced(path: &Path) -> bool {
     !path.exists() || {
         let content = read_file_or_empty(path);
@@ -137,13 +116,6 @@ fn claude_shim_can_be_replaced(path: &Path) -> bool {
     }
 }
 
-fn gemini_shim_can_be_replaced(path: &Path) -> bool {
-    !path.exists() || {
-        let content = read_file_or_empty(path);
-        content.trim().is_empty() || matches_gemini_shim(&content)
-    }
-}
-
 fn sync_managed_file(
     path: &Path,
     content: &str,
@@ -178,12 +150,9 @@ fn classify_guidance_file(
     AiGuidanceFileState::Custom
 }
 
-fn guidance_paths(vault_path: &Path) -> GuidancePaths {
-    GuidancePaths {
-        agents: vault_path.join("AGENTS.md"),
-        claude: vault_path.join("CLAUDE.md"),
-        gemini: vault_path.join("GEMINI.md"),
-    }
+fn guidance_paths(vault_path: &Path) -> (PathBuf, PathBuf) {
+    let vault = vault_path;
+    (vault.join("AGENTS.md"), vault.join("CLAUDE.md"))
 }
 
 fn classify_agents_file(path: &Path) -> AiGuidanceFileState {
@@ -198,10 +167,6 @@ fn classify_claude_file(path: &Path) -> AiGuidanceFileState {
     classify_guidance_file(path, matches_claude_shim, claude_shim_can_be_replaced)
 }
 
-fn classify_gemini_file(path: &Path) -> AiGuidanceFileState {
-    classify_guidance_file(path, matches_gemini_shim, gemini_shim_can_be_replaced)
-}
-
 fn guidance_file_needs_restore(state: AiGuidanceFileState) -> bool {
     matches!(
         state,
@@ -210,43 +175,29 @@ fn guidance_file_needs_restore(state: AiGuidanceFileState) -> bool {
 }
 
 fn build_ai_guidance_status(vault_path: &Path) -> VaultAiGuidanceStatus {
-    let paths = guidance_paths(vault_path);
-    let agents_state = classify_agents_file(&paths.agents);
-    let claude_state = classify_claude_file(&paths.claude);
-    let gemini_state = classify_gemini_file(&paths.gemini);
+    let (agents_path, claude_path) = guidance_paths(vault_path);
+    let agents_state = classify_agents_file(&agents_path);
+    let claude_state = classify_claude_file(&claude_path);
 
     VaultAiGuidanceStatus {
         agents_state,
         claude_state,
-        gemini_state,
         can_restore: guidance_file_needs_restore(agents_state)
-            || guidance_file_needs_restore(claude_state)
-            || guidance_file_needs_restore(gemini_state),
+            || guidance_file_needs_restore(claude_state),
     }
 }
 
 fn sync_claude_shim_file(vault_path: &Path) -> Result<bool, String> {
-    let paths = guidance_paths(vault_path);
-    sync_managed_file(&paths.claude, CLAUDE_MD_SHIM, claude_shim_can_be_replaced)
+    let (_, claude_path) = guidance_paths(vault_path);
+    sync_managed_file(&claude_path, CLAUDE_MD_SHIM, claude_shim_can_be_replaced)
 }
 
-fn sync_gemini_shim_file(vault_path: &Path) -> Result<bool, String> {
-    let paths = guidance_paths(vault_path);
-    sync_managed_file(&paths.gemini, GEMINI_MD_SHIM, gemini_shim_can_be_replaced)
-}
-
-fn sync_required_ai_guidance_files(vault_path: &Path) -> Result<bool, String> {
+fn sync_ai_guidance_files(vault_path: &Path) -> Result<bool, String> {
     let wrote_agents = sync_default_agents_file(vault_path)?;
     let wrote_claude = sync_claude_shim_file(vault_path)?;
     Ok(wrote_agents || wrote_claude)
 }
 
-fn sync_all_ai_guidance_files(vault_path: &Path) -> Result<bool, String> {
-    let wrote_required = sync_required_ai_guidance_files(vault_path)?;
-    let wrote_gemini = sync_gemini_shim_file(vault_path)?;
-    Ok(wrote_required || wrote_gemini)
-}
-
 fn migrate_legacy_agents_file(
     root_agents: &Path,
     config_agents: &Path,
@@ -290,8 +241,8 @@ fn cleanup_empty_config_dir(vault: &Path) -> Result<bool, String> {
 }
 
 pub(super) fn sync_default_agents_file(vault_path: &Path) -> Result<bool, String> {
-    let paths = guidance_paths(vault_path);
-    sync_managed_file(&paths.agents, AGENTS_MD, root_agents_can_be_replaced)
+    let (agents_path, _) = guidance_paths(vault_path);
+    sync_managed_file(&agents_path, AGENTS_MD, root_agents_can_be_replaced)
 }
 
 pub fn get_ai_guidance_status(
@@ -304,7 +255,7 @@ pub fn restore_ai_guidance_files(
     vault_path: impl AsRef<str>,
 ) -> Result<VaultAiGuidanceStatus, String> {
     let vault_path = Path::new(vault_path.as_ref());
-    sync_all_ai_guidance_files(vault_path)?;
+    sync_ai_guidance_files(vault_path)?;
     Ok(build_ai_guidance_status(vault_path))
 }
 
@@ -312,7 +263,7 @@ pub fn restore_ai_guidance_files(
 /// Also seeds Tolaria-managed root type definitions used by repair/bootstrap flows.
 pub fn seed_config_files(vault_path: impl AsRef<str>) {
     let vault_path = Path::new(vault_path.as_ref());
-    if sync_required_ai_guidance_files(vault_path).unwrap_or(false) {
+    if sync_ai_guidance_files(vault_path).unwrap_or(false) {
         log::info!("Seeded vault AI guidance files at vault root");
     }
 
@@ -356,7 +307,7 @@ pub fn migrate_agents_md(vault_path: impl AsRef<str>) {
         log::info!("Removed empty config/ directory");
     }
 
-    let _ = sync_required_ai_guidance_files(vault);
+    let _ = sync_ai_guidance_files(vault);
 }
 
 /// Repair config files: ensure `AGENTS.md` at vault root and root type definitions.
@@ -369,7 +320,7 @@ pub fn repair_config_files(vault_path: impl AsRef<str>) -> Result<String, String
 
     migrate_legacy_agents_file(&root_agents, &config_agents)?;
     let _ = cleanup_empty_config_dir(vault)?;
-    sync_required_ai_guidance_files(vault)?;
+    sync_ai_guidance_files(vault)?;
 
     write_if_missing(&vault.join("type.md"), TYPE_TYPE_DEFINITION)?;
     write_if_missing(&vault.join("note.md"), NOTE_TYPE_DEFINITION)?;
@@ -404,10 +355,6 @@ mod tests {
         fs::write(vault.join("CLAUDE.md"), content).unwrap();
     }
 
-    fn write_root_gemini(vault: &Path, content: &str) {
-        fs::write(vault.join("GEMINI.md"), content).unwrap();
-    }
-
     fn write_legacy_agents(vault: &Path, content: &str) {
         fs::write(config_dir(vault).join("agents.md"), content).unwrap();
     }
@@ -420,10 +367,6 @@ mod tests {
         fs::read_to_string(vault.join("CLAUDE.md")).unwrap()
     }
 
-    fn read_root_gemini(vault: &Path) -> String {
-        fs::read_to_string(vault.join("GEMINI.md")).unwrap()
-    }
-
     type VaultOperation = fn(&Path);
 
     fn run_seed(vault: &Path) {
@@ -511,52 +454,15 @@ mod tests {
         assert!(content.contains(expected_root_text));
     }
 
-    fn assert_required_agents_file_seeded(vault: &Path) {
-        assert!(vault.join("AGENTS.md").exists());
-        assert!(read_root_agents(vault).contains("Tolaria Vault"));
-    }
-
-    fn assert_required_guidance_shims_seeded(vault: &Path) {
-        assert_eq!(read_root_claude(vault), CLAUDE_MD_SHIM);
-        assert!(!vault.join("GEMINI.md").exists());
-    }
-
-    fn assert_required_guidance_files_seeded(vault: &Path) {
-        assert_required_agents_file_seeded(vault);
-        assert_required_guidance_shims_seeded(vault);
-    }
-
-    fn assert_root_type_definitions_seeded(vault: &Path) {
-        assert!(vault.join("type.md").exists());
-        assert!(vault.join("note.md").exists());
-        assert!(!vault.join("config").exists());
-    }
-
-    fn assert_type_definition_content(vault: &Path) {
-        let type_content = fs::read_to_string(vault.join("type.md")).unwrap();
-        let note_content = fs::read_to_string(vault.join("note.md")).unwrap();
-        assert_type_definition_body(&type_content);
-        assert_note_definition_body(&note_content);
-    }
-
-    fn assert_type_definition_body(type_content: &str) {
-        assert!(type_content.contains("type: Type"));
-        assert!(type_content.contains("# Type"));
-        assert!(type_content.contains("visible: false"));
-    }
-
-    fn assert_note_definition_body(note_content: &str) {
-        assert!(note_content.contains("type: Type"));
-        assert!(note_content.contains("# Note"));
-    }
-
     #[test]
     fn test_seed_config_files_creates_guidance_files_at_root() {
         let (_dir, vault) = create_vault();
 
         seed_config_files(vault.to_str().unwrap());
 
-        assert_required_guidance_files_seeded(&vault);
+        assert!(vault.join("AGENTS.md").exists());
+        assert!(read_root_agents(&vault).contains("Tolaria Vault"));
+        assert_eq!(read_root_claude(&vault), CLAUDE_MD_SHIM);
     }
 
     #[test]
@@ -565,8 +471,16 @@ mod tests {
 
         seed_config_files(vault.to_str().unwrap());
 
-        assert_root_type_definitions_seeded(&vault);
-        assert_type_definition_content(&vault);
+        assert!(vault.join("type.md").exists());
+        assert!(vault.join("note.md").exists());
+        let type_content = fs::read_to_string(vault.join("type.md")).unwrap();
+        let note_content = fs::read_to_string(vault.join("note.md")).unwrap();
+        assert!(type_content.contains("type: Type"));
+        assert!(type_content.contains("# Type"));
+        assert!(type_content.contains("visible: false"));
+        assert!(note_content.contains("type: Type"));
+        assert!(note_content.contains("# Note"));
+        assert!(!vault.join("config").exists());
     }
 
     #[test]
@@ -690,12 +604,20 @@ mod tests {
         let msg = repair_config_files(vault.to_str().unwrap()).unwrap();
         assert_eq!(msg, "Config files repaired");
 
-        assert_required_guidance_files_seeded(&vault);
-        assert_root_type_definitions_seeded(&vault);
-        assert_type_definition_content(&vault);
-        assert!(fs::read_to_string(vault.join("note.md"))
-            .unwrap()
-            .contains("general-purpose document"));
+        assert!(vault.join("AGENTS.md").exists());
+        assert!(vault.join("CLAUDE.md").exists());
+        assert!(vault.join("type.md").exists());
+        assert!(vault.join("note.md").exists());
+        assert!(!vault.join("config").exists());
+
+        let agents = read_root_agents(&vault);
+        assert!(agents.contains("Tolaria Vault"));
+        let type_content = fs::read_to_string(vault.join("type.md")).unwrap();
+        assert!(type_content.contains("# Type"));
+        assert!(type_content.contains("visible: false"));
+        let note_content = fs::read_to_string(vault.join("note.md")).unwrap();
+        assert!(note_content.contains("type: Type"));
+        assert!(note_content.contains("general-purpose document"));
     }
 
     #[test]
@@ -734,15 +656,9 @@ mod tests {
         write_root_claude(&vault, "");
 
         let status = get_ai_guidance_status(vault.to_str().unwrap()).unwrap();
-        assert_eq!(
-            status,
-            VaultAiGuidanceStatus {
-                agents_state: AiGuidanceFileState::Custom,
-                claude_state: AiGuidanceFileState::Broken,
-                gemini_state: AiGuidanceFileState::Missing,
-                can_restore: true,
-            }
-        );
+        assert_eq!(status.agents_state, AiGuidanceFileState::Custom);
+        assert_eq!(status.claude_state, AiGuidanceFileState::Broken);
+        assert!(status.can_restore);
     }
 
     #[test]
@@ -752,18 +668,11 @@ mod tests {
         write_root_claude(&vault, "");
 
         let status = restore_ai_guidance_files(vault.to_str().unwrap()).unwrap();
-        assert_eq!(
-            status,
-            VaultAiGuidanceStatus {
-                agents_state: AiGuidanceFileState::Custom,
-                claude_state: AiGuidanceFileState::Managed,
-                gemini_state: AiGuidanceFileState::Managed,
-                can_restore: false,
-            }
-        );
+        assert_eq!(status.agents_state, AiGuidanceFileState::Custom);
+        assert_eq!(status.claude_state, AiGuidanceFileState::Managed);
+        assert!(!status.can_restore);
         assert!(read_root_agents(&vault).contains("Custom Agent Config"));
         assert_eq!(read_root_claude(&vault), CLAUDE_MD_SHIM);
-        assert_eq!(read_root_gemini(&vault), GEMINI_MD_SHIM);
     }
 
     #[test]
@@ -772,28 +681,8 @@ mod tests {
         write_root_agents(&vault, "");
 
         let status = restore_ai_guidance_files(vault.to_str().unwrap()).unwrap();
-        assert_eq!(
-            status,
-            VaultAiGuidanceStatus {
-                agents_state: AiGuidanceFileState::Managed,
-                claude_state: AiGuidanceFileState::Managed,
-                gemini_state: AiGuidanceFileState::Managed,
-                can_restore: false,
-            }
-        );
-    }
-
-    #[test]
-    fn test_restore_ai_guidance_files_preserves_custom_gemini() {
-        let (_dir, vault) = create_vault();
-        write_root_agents(&vault, AGENTS_MD);
-        write_root_claude(&vault, CLAUDE_MD_SHIM);
-        write_root_gemini(&vault, "# Custom Gemini instructions\nDo not overwrite\n");
-
-        let status = restore_ai_guidance_files(vault.to_str().unwrap()).unwrap();
-
-        assert_eq!(status.gemini_state, AiGuidanceFileState::Custom);
+        assert_eq!(status.agents_state, AiGuidanceFileState::Managed);
+        assert_eq!(status.claude_state, AiGuidanceFileState::Managed);
         assert!(!status.can_restore);
-        assert!(read_root_gemini(&vault).contains("Custom Gemini instructions"));
     }
 }

src-tauri/src/vault/views.rs

@@ -1,8 +1,7 @@
 use chrono::{DateTime, Duration, Months, NaiveDate, NaiveDateTime, Utc};
-use regex::{Regex, RegexBuilder};
+use regex::RegexBuilder;
 use serde::de::{self, MapAccess, Visitor};
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
-use std::cmp::Ordering;
 use std::fmt;
 use std::fs;
 use std::path::Path;
@@ -16,8 +15,6 @@ pub struct ViewDefinition {
     pub icon: Option<String>,
     #[serde(default)]
     pub color: Option<String>,
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub order: Option<i64>,
     #[serde(default)]
     pub sort: Option<String>,
     #[serde(
@@ -257,19 +254,10 @@ pub fn scan_views(vault_path: &Path) -> Vec<ViewFile> {
         }
     }
 
-    views.sort_by(compare_views);
+    views.sort_by(|a, b| a.filename.cmp(&b.filename));
     views
 }
 
-fn compare_views(left: &ViewFile, right: &ViewFile) -> Ordering {
-    let order = left
-        .definition
-        .order
-        .unwrap_or(i64::MAX)
-        .cmp(&right.definition.order.unwrap_or(i64::MAX));
-    order.then_with(|| left.filename.cmp(&right.filename))
-}
-
 /// Save a view definition as YAML to `vault_path/views/{filename}`.
 pub fn save_view(
     vault_path: &Path,
@@ -434,157 +422,120 @@ fn supports_regex(op: &FilterOp) -> bool {
     )
 }
 
-enum ConditionField<'a> {
-    Scalar(Option<String>),
-    Relationship(&'a [String]),
-}
-
 fn evaluate_condition(cond: &FilterCondition, entry: &VaultEntry) -> bool {
     let field = cond.field.as_str();
-    if let Some(result) = evaluate_condition_bool_field(field, entry, &cond.op, &cond.value) {
-        return result;
+    let mut relationship_values: Option<&[String]> = None;
+
+    // Boolean fields
+    match field {
+        "archived" => return evaluate_bool_field(entry.archived, &cond.op, &cond.value),
+        "favorite" => return evaluate_bool_field(entry.favorite, &cond.op, &cond.value),
+        _ => {}
     }
 
-    let field_value = resolve_condition_field(field, entry);
+    // String/option fields
+    let field_value: Option<String> = match field {
+        "type" | "isA" => entry.is_a.clone(),
+        "status" => entry.status.clone(),
+        "title" => Some(entry.title.clone()),
+        "body" => Some(entry.snippet.clone()),
+        _ => {
+            // Check properties first, then relationships
+            if let Some(prop) = entry.properties.get(field) {
+                match prop {
+                    serde_json::Value::String(s) => Some(s.clone()),
+                    serde_json::Value::Number(n) => Some(n.to_string()),
+                    serde_json::Value::Bool(b) => Some(b.to_string()),
+                    _ => None,
+                }
+            } else if let Some(rels) = entry.relationships.get(field) {
+                relationship_values = Some(rels);
+                None
+            } else {
+                None
+            }
+        }
+    };
+
     let cond_value = cond.value.as_ref().and_then(yaml_value_to_string);
-    let regex = condition_regex(cond, cond_value.as_deref());
+    let regex = if cond.regex && supports_regex(&cond.op) {
+        cond_value.as_deref().and_then(build_regex)
+    } else {
+        None
+    };
 
     if cond.regex && supports_regex(&cond.op) && regex.is_none() {
         return false;
     }
 
     if let Some(re) = regex.as_ref() {
-        return evaluate_regex_condition(&cond.op, &field_value, re);
+        let matched = if let Some(prop) = field_value.as_deref() {
+            re.is_match(prop)
+        } else if let Some(rels) = relationship_values {
+            rels.iter().any(|item| {
+                relationship_candidates(item)
+                    .into_iter()
+                    .any(|candidate| re.is_match(&candidate))
+            })
+        } else {
+            false
+        };
+        return match cond.op {
+            FilterOp::Contains | FilterOp::Equals => matched,
+            FilterOp::NotContains | FilterOp::NotEquals => !matched,
+            _ => false,
+        };
     }
 
-    match field_value {
-        ConditionField::Relationship(rels) => evaluate_relationship_op(&cond.op, rels, &cond.value),
-        ConditionField::Scalar(value) => evaluate_scalar_op(
-            &cond.op,
-            value.as_deref(),
-            cond_value.as_deref(),
-            &cond.value,
-        ),
+    if let Some(rels) = relationship_values {
+        return evaluate_relationship_op(&cond.op, rels, &cond.value);
     }
-}
 
-fn evaluate_condition_bool_field(
-    field: &str,
-    entry: &VaultEntry,
-    op: &FilterOp,
-    value: &Option<serde_yaml::Value>,
-) -> Option<bool> {
-    match field {
-        "archived" => Some(evaluate_bool_field(entry.archived, op, value)),
-        "favorite" => Some(evaluate_bool_field(entry.favorite, op, value)),
-        _ => None,
-    }
-}
-
-fn resolve_condition_field<'a>(field: &str, entry: &'a VaultEntry) -> ConditionField<'a> {
-    match field {
-        "type" | "isA" => ConditionField::Scalar(entry.is_a.clone()),
-        "status" => ConditionField::Scalar(entry.status.clone()),
-        "title" => ConditionField::Scalar(Some(entry.title.clone())),
-        "body" => ConditionField::Scalar(Some(entry.snippet.clone())),
-        _ => resolve_dynamic_condition_field(field, entry),
-    }
-}
-
-fn resolve_dynamic_condition_field<'a>(field: &str, entry: &'a VaultEntry) -> ConditionField<'a> {
-    if let Some(prop) = entry.properties.get(field) {
-        return ConditionField::Scalar(json_scalar_to_string(prop));
-    }
-    if let Some(relationships) = entry.relationships.get(field) {
-        return ConditionField::Relationship(relationships);
-    }
-    ConditionField::Scalar(None)
-}
-
-fn json_scalar_to_string(value: &serde_json::Value) -> Option<String> {
-    match value {
-        serde_json::Value::String(value) => Some(value.clone()),
-        serde_json::Value::Number(value) => Some(value.to_string()),
-        serde_json::Value::Bool(value) => Some(value.to_string()),
-        _ => None,
-    }
-}
-
-fn condition_regex(cond: &FilterCondition, cond_value: Option<&str>) -> Option<Regex> {
-    if cond.regex && supports_regex(&cond.op) {
-        cond_value.and_then(build_regex)
-    } else {
-        None
-    }
-}
-
-fn evaluate_regex_condition(op: &FilterOp, field: &ConditionField<'_>, regex: &Regex) -> bool {
-    let matched = match field {
-        ConditionField::Scalar(Some(value)) => regex.is_match(value),
-        ConditionField::Relationship(values) => values.iter().any(|item| {
-            relationship_candidates(item)
-                .into_iter()
-                .any(|candidate| regex.is_match(&candidate))
-        }),
-        ConditionField::Scalar(None) => false,
-    };
-
-    match op {
-        FilterOp::Contains | FilterOp::Equals => matched,
-        FilterOp::NotContains | FilterOp::NotEquals => !matched,
-        _ => false,
-    }
-}
-
-fn evaluate_scalar_op(
-    op: &FilterOp,
-    field_value: Option<&str>,
-    cond_value: Option<&str>,
-    raw_value: &Option<serde_yaml::Value>,
-) -> bool {
-    match op {
-        FilterOp::Equals => match (field_value, cond_value) {
+    match cond.op {
+        FilterOp::Equals => match (&field_value, &cond_value) {
             (Some(f), Some(v)) => f.eq_ignore_ascii_case(v),
             (None, None) => true,
             _ => false,
         },
-        FilterOp::NotEquals => match (field_value, cond_value) {
+        FilterOp::NotEquals => match (&field_value, &cond_value) {
             (Some(f), Some(v)) => !f.eq_ignore_ascii_case(v),
             (None, None) => false,
             _ => true,
         },
-        FilterOp::Contains => match (field_value, cond_value) {
+        FilterOp::Contains => match (&field_value, &cond_value) {
             (Some(f), Some(v)) => f.to_lowercase().contains(&v.to_lowercase()),
             _ => false,
         },
-        FilterOp::NotContains => match (field_value, cond_value) {
+        FilterOp::NotContains => match (&field_value, &cond_value) {
             (Some(f), Some(v)) => !f.to_lowercase().contains(&v.to_lowercase()),
             (None, _) => true,
             _ => true,
         },
         FilterOp::AnyOf => {
-            let values = raw_value
+            let values = cond
+                .value
                 .as_ref()
                 .and_then(yaml_value_to_string_vec)
                 .unwrap_or_default();
-            match field_value {
+            match &field_value {
                 Some(f) => values.iter().any(|v| f.eq_ignore_ascii_case(v)),
                 None => false,
             }
         }
         FilterOp::NoneOf => {
-            let values = raw_value
+            let values = cond
+                .value
                 .as_ref()
                 .and_then(yaml_value_to_string_vec)
                 .unwrap_or_default();
-            match field_value {
+            match &field_value {
                 Some(f) => !values.iter().any(|v| f.eq_ignore_ascii_case(v)),
                 None => true,
             }
         }
-        FilterOp::IsEmpty => field_value.map_or(true, str::is_empty),
-        FilterOp::IsNotEmpty => field_value.is_some_and(|s| !s.is_empty()),
-        FilterOp::Before => match (field_value, cond_value) {
+        FilterOp::IsEmpty => field_value.as_deref().map_or(true, |s| s.is_empty()),
+        FilterOp::IsNotEmpty => field_value.as_deref().is_some_and(|s| !s.is_empty()),
+        FilterOp::Before => match (&field_value, &cond_value) {
             (Some(f), Some(v)) => match (
                 parse_date_filter_timestamp(f, Utc::now()),
                 parse_date_filter_timestamp(v, Utc::now()),
@@ -594,7 +545,7 @@ fn evaluate_scalar_op(
             },
             _ => false,
         },
-        FilterOp::After => match (field_value, cond_value) {
+        FilterOp::After => match (&field_value, &cond_value) {
             (Some(f), Some(v)) => match (
                 parse_date_filter_timestamp(f, Utc::now()),
                 parse_date_filter_timestamp(v, Utc::now()),
@@ -630,61 +581,80 @@ fn evaluate_relationship_op(
 ) -> bool {
     match op {
         FilterOp::Contains => {
-            relationship_target(value).is_some_and(|target| relationship_contains(rels, &target))
+            let target = value.as_ref().and_then(yaml_value_to_string);
+            match target {
+                Some(t) => {
+                    let t_stem = wikilink_stem(&t).to_lowercase();
+                    rels.iter()
+                        .any(|r| wikilink_stem(r).to_lowercase() == t_stem)
+                }
+                None => false,
+            }
         }
         FilterOp::NotContains => {
-            relationship_target(value).map_or(true, |target| !relationship_contains(rels, &target))
+            let target = value.as_ref().and_then(yaml_value_to_string);
+            match target {
+                Some(t) => {
+                    let t_stem = wikilink_stem(&t).to_lowercase();
+                    !rels
+                        .iter()
+                        .any(|r| wikilink_stem(r).to_lowercase() == t_stem)
+                }
+                None => true,
+            }
+        }
+        FilterOp::AnyOf => {
+            let values = value
+                .as_ref()
+                .and_then(yaml_value_to_string_vec)
+                .unwrap_or_default();
+            rels.iter().any(|r| {
+                let r_stem = wikilink_stem(r).to_lowercase();
+                values
+                    .iter()
+                    .any(|v| wikilink_stem(v).to_lowercase() == r_stem)
+            })
+        }
+        FilterOp::NoneOf => {
+            let values = value
+                .as_ref()
+                .and_then(yaml_value_to_string_vec)
+                .unwrap_or_default();
+            !rels.iter().any(|r| {
+                let r_stem = wikilink_stem(r).to_lowercase();
+                values
+                    .iter()
+                    .any(|v| wikilink_stem(v).to_lowercase() == r_stem)
+            })
         }
-        FilterOp::AnyOf => relationship_any_of(rels, &relationship_values(value)),
-        FilterOp::NoneOf => !relationship_any_of(rels, &relationship_values(value)),
         FilterOp::IsEmpty => rels.is_empty(),
         FilterOp::IsNotEmpty => !rels.is_empty(),
-        FilterOp::Equals => relationship_target(value).map_or_else(
-            || rels.is_empty(),
-            |target| relationship_equals(rels, &target),
-        ),
-        FilterOp::NotEquals => relationship_target(value).map_or_else(
-            || !rels.is_empty(),
-            |target| !relationship_equals(rels, &target),
-        ),
+        FilterOp::Equals => {
+            let target = value.as_ref().and_then(yaml_value_to_string);
+            match target {
+                Some(t) => {
+                    rels.len() == 1
+                        && wikilink_stem(&rels[0]).to_lowercase()
+                            == wikilink_stem(&t).to_lowercase()
+                }
+                None => rels.is_empty(),
+            }
+        }
+        FilterOp::NotEquals => {
+            let target = value.as_ref().and_then(yaml_value_to_string);
+            match target {
+                Some(t) => {
+                    rels.len() != 1
+                        || wikilink_stem(&rels[0]).to_lowercase()
+                            != wikilink_stem(&t).to_lowercase()
+                }
+                None => !rels.is_empty(),
+            }
+        }
         _ => false,
     }
 }
 
-fn relationship_target(value: &Option<serde_yaml::Value>) -> Option<String> {
-    value.as_ref().and_then(yaml_value_to_string)
-}
-
-fn relationship_values(value: &Option<serde_yaml::Value>) -> Vec<String> {
-    value
-        .as_ref()
-        .and_then(yaml_value_to_string_vec)
-        .unwrap_or_default()
-}
-
-fn normalized_wikilink_stem(value: &str) -> String {
-    wikilink_stem(value).to_lowercase()
-}
-
-fn relationship_contains(rels: &[String], target: &str) -> bool {
-    let target_stem = normalized_wikilink_stem(target);
-    rels.iter()
-        .any(|relationship| normalized_wikilink_stem(relationship) == target_stem)
-}
-
-fn relationship_any_of(rels: &[String], values: &[String]) -> bool {
-    rels.iter().any(|relationship| {
-        let relationship_stem = normalized_wikilink_stem(relationship);
-        values
-            .iter()
-            .any(|value| normalized_wikilink_stem(value) == relationship_stem)
-    })
-}
-
-fn relationship_equals(rels: &[String], target: &str) -> bool {
-    rels.len() == 1 && relationship_contains(rels, target)
-}
-
 fn yaml_value_to_string(v: &serde_yaml::Value) -> Option<String> {
     match v {
         serde_yaml::Value::String(s) => Some(s.clone()),
@@ -716,7 +686,6 @@ mod tests {
             name: name.to_string(),
             icon: None,
             color: None,
-            order: None,
             sort: None,
             list_properties_display: Vec::new(),
             filters: FilterGroup::All(vec![FilterNode::Condition(FilterCondition {
@@ -994,34 +963,6 @@ filters:
         assert_eq!(views[1].definition.name, "Beta");
     }
 
-    #[test]
-    fn test_scan_views_sorts_by_persisted_order_then_filename() {
-        let dir = tempfile::TempDir::new().unwrap();
-        let views_dir = dir.path().join("views");
-        fs::create_dir_all(&views_dir).unwrap();
-
-        let alpha = "name: Alpha\norder: 20\nfilters:\n  all:\n    - field: type\n      op: equals\n      value: Note\n";
-        let beta = "name: Beta\norder: 10\nfilters:\n  all:\n    - field: type\n      op: equals\n      value: Note\n";
-        let gamma = "name: Gamma\nfilters:\n  all:\n    - field: type\n      op: equals\n      value: Note\n";
-        fs::write(views_dir.join("alpha.yml"), alpha).unwrap();
-        fs::write(views_dir.join("beta.yml"), beta).unwrap();
-        fs::write(views_dir.join("gamma.yml"), gamma).unwrap();
-
-        let views = scan_views(dir.path());
-
-        assert_eq!(
-            views
-                .iter()
-                .map(|view| (view.filename.as_str(), view.definition.order))
-                .collect::<Vec<_>>(),
-            vec![
-                ("beta.yml", Some(10)),
-                ("alpha.yml", Some(20)),
-                ("gamma.yml", None),
-            ]
-        );
-    }
-
     #[test]
     fn test_migrate_views_from_old_location() {
         let dir = tempfile::TempDir::new().unwrap();