diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index 5620ede1..2860e501 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -45,5 +45,14 @@ jobs:
       - name: Typecheck
         run: pnpm typecheck
 
+      - name: Assert design-system boundary
+        run: pnpm -C apps/desktop assert:design-system-boundary
+
+      - name: Assert design-system flag-off boot
+        run: pnpm -C apps/desktop test:boot:design-system-off
+
+      - name: Measure Agent Dashboard storage
+        run: pnpm -C apps/desktop measure:agent-dashboard-storage
+
       - name: Run tests
         run: pnpm test
diff --git a/.gitignore b/.gitignore
index 8a8728f3..01660e56 100644
--- a/.gitignore
+++ b/.gitignore
@@ -26,6 +26,9 @@ apps/desktop/.generated/
 apps/desktop/test-results/
 apps/desktop/playwright-report/
 
+# Desktop-local workflow/debug artifacts
+apps/desktop/.closedloop-ai/
+
 # UI Numbers Audit generated reports (FEA-1415 / PLN-738)
 # These embed a timestamp; regenerate locally via `pnpm --filter desktop audit:report`
 # or `node apps/desktop/test-e2e/agent-monitor/inventory/scan-tiles.mjs`.
diff --git a/THIRD_PARTY_NOTICES.md b/THIRD_PARTY_NOTICES.md
index 2873a25b..1328fc49 100644
--- a/THIRD_PARTY_NOTICES.md
+++ b/THIRD_PARTY_NOTICES.md
@@ -13,11 +13,9 @@ development/build, and the desktop build generates a runtime tree under
 - **Pinned commit:** `840c518d7fa69231de049e41b893938228b67e40`
 - **Imported via:** pnpm dependencies `agent-dashboard` and
   `agent-dashboard-client`
-- **Usage:** Bundled and run as a local `127.0.0.1` sidecar process by the
-  desktop app (the embedded "Claude Dashboard" tab). The desktop build applies
-  three local host patches while generating
-  `apps/desktop/.generated/agent-monitor/`: loopback-only bind, explicit
-  `CCAM_AUTO_INSTALL_HOOKS` gating, and a hook uninstall script.
+- **Usage:** Bundled and run as the default local `127.0.0.1` legacy sidecar
+  dashboard. The desktop build applies local host patches while generating
+  `apps/desktop/.generated/agent-monitor/`.
 - **License:** MIT — © 2026 Son Nguyen.
 
 Bundled runtime dependencies remain pure JS. The generated sidecar runtime uses
@@ -57,9 +55,8 @@ SOFTWARE.
 - **Used as:** documentation/algorithm reference for the OpenAI **Codex** CLI
   rollout JSONL format — the cumulative→session token semantics and the
   `turn_context.model` attribution rule (`docs/codex.md`). No CodexBar source
-  is bundled. Our own Codex ingestion modules
-  (`apps/desktop/scripts/agent-monitor-codex/codex-*.js`, copied into the
-  generated runtime tree at build time) were merely informed by it.
+  is bundled. Our own first-party Codex ingestion modules
+  (`apps/desktop/src/main/collectors/codex/`) were merely informed by it.
 - **License:** MIT — © 2026 Peter Steinberger.
 
 ```
diff --git a/apps/desktop/CLAUDE.md b/apps/desktop/CLAUDE.md
index d3693041..b08711c1 100644
--- a/apps/desktop/CLAUDE.md
+++ b/apps/desktop/CLAUDE.md
@@ -136,108 +136,94 @@ Typical log locations:
 
 The Diagnostics tab shows the current in-memory gateway log plus a bounded previous-session tail read from `main.log` at startup. First-run or unreadable log files must not block boot; return an empty previous-session tail and continue.
 
-## Agent Monitor Sidecar
-
-The desktop app bundles the MIT-licensed `Claude-Code-Agent-Monitor`
-(`agent-dashboard` + `agent-dashboard-client`, pinned in
-`apps/desktop/package.json`) and runs a generated runtime tree as a managed
-localhost **sidecar** for local Claude Code session/agent observability. It is
-the single embedded observability tool. It powers the **Dashboard** and the
-agent nav items (Sessions, Kanban, Activity Feed, etc.) in the desktop left
-sidebar. The feature is gated by the persisted `agentMonitorEnabled` desktop
-setting, which **defaults ON**; when disabled, the agent nav items are hidden
-and only the Gateway section remains.
-
-- **Process model:** `src/main/agent-monitor-sidecar.ts` spawns the generated
-  `server/index.js` from `apps/desktop/.generated/agent-monitor/` (packaged:
-  unpacked `extraResources/agent-monitor`) using the Electron binary as Node
-  (`ELECTRON_RUN_AS_NODE=1`, `process.execPath`) — a packaged app ships no
-  standalone `node`. Started fire-and-forget from `boot()` **only when
-  `agentMonitorEnabled` is true**, and still before the gateway-start try-block
-  so a gateway-start failure never prevents it from running and a sidecar
-  failure never blocks or fails app boot.
+## Agent Monitor
+
+> **Status (FEA-1504):** Agent Monitor has three boot modes. The default user
+> experience is the legacy sidecar-backed dashboard (`agentMonitorEnabled=true`,
+> `agentDashboardDesignSystemEnabled=false`): pnpm-managed upstream packages are
+> materialized into `.generated/agent-monitor`, shipped unpacked, and rendered in
+> the legacy iframe shell. The in-process design-system dashboard is a Labs
+> opt-in only. When `agentDashboardDesignSystemEnabled` is not the literal
+> boolean `true`, the main process must not load `src/main/database/`,
+> `src/main/collectors/`, `AgentHookListener`, `desktop:db:*`, or the `app://`
+> design renderer path.
+
+The desktop app provides local Claude Code (and opt-in Codex) session/agent
+observability. It powers the **Dashboard** and the agent nav items (Sessions,
+Activity, Analytics, Workflows, Kanban) in the desktop left sidebar. The feature
+is gated by the persisted `agentMonitorEnabled` desktop setting, which
+**defaults ON**; when disabled, the agent nav items are hidden and only the
+Gateway section remains.
+
+- **Legacy sidecar (default):** `src/main/agent-monitor-sidecar.ts` launches the
+  generated Claude-Code-Agent-Monitor runtime tree. `build:agent-monitor`
+  materializes the tree from pnpm-managed upstream packages; package/stage logic
+  must keep `.generated/agent-monitor` available for default users.
+- **Design-system runtime (Labs opt-in):** `src/main/agent-dashboard-design-system-runtime.ts`
+  is the only module allowed to import `src/main/database/`,
+  `src/main/collectors/`, `AgentHookListener`, or register `desktop:db:*`. It is
+  reached only through `await import()` after boot mode resolves to
+  `design-system`.
+- **Disabled mode:** `agentMonitorEnabled=false` starts no sidecar, no
+  design-system runtime, no dashboard-derived sync source, and no
+  dashboard-derived cost source.
+- **Hook listener:** in design-system mode, `src/main/agent-monitor-listener.ts`
+  binds `127.0.0.1:4820` in the main process and accepts the hook payload
+  (`POST /api/hooks/event`, `GET /api/health`). Each event is gated by the
+  FEA-1407 sandbox check, harness-stamped from `__provider`, and applied by the
+  lifecycle state machine.
+- **Collection layer (`src/main/collectors/`):** design-system mode uses
+  `CollectorManager` for best-effort boot bulk import and live file watchers for
+  all five agent CLIs, writing through the first-party `importSession` into the
+  same in-process DB.
 - **Fixed port (differs from the gateway):** `127.0.0.1:4820`
-  (`AGENT_MONITOR_PORT` in `src/shared/contracts.ts`), passed via
-  `DASHBOARD_PORT`. It MUST be fixed — Claude Code hooks bake a port at install
-  time and the hook handler POSTs to `127.0.0.1:${CLAUDE_DASHBOARD_PORT||4820}`,
-  so 4820 (upstream's default) means hooks need zero per-hook env. 4820 is
-  outside `PORT_PROBE_ORDER`, so it never collides with the gateway.
-- **Durable DB:** `DASHBOARD_DB_PATH` is set to
-  `app.getPath("userData")/agent-monitor/dashboard.db` (the packaged app dir is
-  read-only). Uses Node's built-in `node:sqlite`; the generated `server/db.js`
-  is patched to prefer `./compat-sqlite`, and staged packaging removes the
-  hoisted `better-sqlite3` module as a belt-and-suspenders guard.
-- **UI:** embedded in the main window (`src/renderer/index.html`) as a plain
-  `<iframe>` pointed at the sidecar URL fetched via
-  `desktop:get-agent-monitor-url` (renderer polls until `ready`, then sets
-  `src` once). No separate window. The host left sidebar drives it: the
-  **Dashboard** + agent nav items each map to a sidecar route. The first load
-  bakes the route + `embed=1` into the iframe `src`; later agent-nav clicks
-  are a `postMessage` (`{ type: "closedloop:navigate", path }`) so there is no
-  reload. In embed mode the sidecar's own `Layout` drops its internal sidebar
-  (see `scripts/agent-monitor-embed/Layout.tsx`) so the host shell is the only
-  chrome. The agent nav items are hidden when the feature is disabled. The
-  embed depends on the renderer having **no CSP** — if a CSP is ever added it
-  must include `frame-src http://127.0.0.1:*`. Iframes in a `display:none`
-  panel collapse to 0px, so an explicit px height is set via JS *after* the
-  panel is `.active`, re-applied on `resize`.
-- **Hooks are explicit opt-in (consent-bearing).** Upstream silently writes 8
-  hooks into `~/.claude/settings.json` on every startup — the generated
-  `server/index.js` gates that behind `CCAM_AUTO_INSTALL_HOOKS` (which the
-  sidecar sets to `"0"`).
-  The user enables/disables tracking via the toggle on the Agent Dashboard
-  view → `src/main/agent-monitor-hooks.ts` writes/removes the 8 hook entries. The
-  hook command runs the Electron binary as Node against a **userData copy** of
-  `hook-handler.js` (location-independent across app moves/updates), at the
-  fixed port 4820. Default is OFF; disabling fully removes the entries;
-  re-enabling is idempotent and self-heals a stale path (also repaired at boot
-  via `syncAgentMonitorHooksOnBoot()`). Disk state: a dedicated electron-store
-  (`agent-monitor-hooks`, key `enabled`).
-- **Lifecycle:** health-checked readiness on `GET /api/health` (60s ready
-  timeout — first run synchronously imports legacy `~/.claude` sessions; ready
-  ≠ import-complete, the iframe populates progressively), crash-restart with
-  exponential backoff (hard cap; a fixed-port `EADDRINUSE` degrades to "no
-  monitor", never blocks boot or Claude Code), process-group SIGTERM→SIGKILL
-  stop wired into `runShutdownSequence` (`agentMonitor.stop`, before
-  `server.stop`).
-- **Security model (by design):** the sidecar reads `~/.claude` **directly**,
-  *outside* the gateway `isPathAllowed` sandbox. Acceptable and intentional:
-  bound to `127.0.0.1` only (patched at build time; verified the LAN interface
-  is refused), the user's own local data, no cloud egress, no auth (consistent
-  with the unauthenticated `/health` precedent). Hooks only mutate global
-  Claude config on explicit user opt-in and are fully reversible.
-- **Build/packaging:** `scripts/build-agent-monitor.mjs` (run via
-  `pnpm build:agent-monitor`, chained into `build`) resolves the pnpm-managed
-  upstream packages, builds the client with Vite, generates
-  `apps/desktop/.generated/agent-monitor/`, applies the ClosedLoop host
-  patches (loopback bind, `CCAM_AUTO_INSTALL_HOOKS` gate, uninstall script,
-  `compat-sqlite` bootstrap), and hard-gates the build on the generated
-  `compat-sqlite.js` working under Electron-as-Node. Shipped via
-  `electron-builder.yml` `extraResources` (unpacked, outside the asar)
-  preserving the `server/` ↔ `client/dist/` relative layout.
-- **Multi-harness support (5 agent tools):** the same dashboard ingests
-  sessions from **Claude Code** (via hooks), **OpenAI Codex** (rollout JSONL
-  under `~/.codex/sessions/`), **Cursor** (agent transcripts under
-  `~/.cursor/projects/`), **GitHub Copilot** (chat JSON under VS Code
-  `workspaceStorage/` + CLI JSONL under `~/.copilot/session-state/`), and
-  **OpenCode** (per-message JSON under `~/.local/share/opencode/storage/`).
-  All non-Claude tools have **no hook system** — their data comes from
-  file-based importing/watching. Proven, architecture-independent modules
-  live in-repo at `apps/desktop/scripts/agent-monitor-{codex,cursor,copilot,
-  opencode}/{tool}-{home,parser,import,watcher}.js` and are copied into the
-  generated `server/lib/` at materialize time. Each parser emits the same
-  normalized shape as the upstream Claude importer so the shared
-  `importSession()` renders all harnesses through the unchanged UI; all
-  watchers self-heal if data directories don't exist at boot (no app restart
-  needed for a first-ever session with any tool). All non-Claude paths are
-  best-effort and never block boot or the Claude path. The build hard-gates
-  all watcher/import wiring so a future upstream bump can't silently drop
-  any harness. The user-facing nav/tray label is **"Agent Dashboard"**
-  (internal ids/IPC channels unchanged). Environment variable overrides:
-  `$CODEX_HOME`, `$CURSOR_HOME`, `$COPILOT_HOME`, `$OPENCODE_DATA_DIR`.
-- **Update procedure:** bump the git dependency commit(s) in
-  `apps/desktop/package.json`, regenerate the lockfile, and rerun
-  `pnpm -C apps/desktop build:agent-monitor`. Any change here requires the
-  `apps/desktop/package.json` version bump (CI-enforced) and a clean-machine
-  packaged-DMG smoke test (the highest-risk path: `node:sqlite` from the
-  asar-external, universal-merged binary).
+  (`AGENT_MONITOR_PORT` in `src/shared/contracts.ts`). It MUST be fixed — the
+  hook handler POSTs to `127.0.0.1:${CLAUDE_DASHBOARD_PORT||4820}`, baked into
+  `~/.claude/settings.json` at install time, so 4820 means hooks need zero
+  per-hook env. 4820 is outside `PORT_PROBE_ORDER`, so it never collides with
+  the gateway. (FEA-1500 tracks migrating this transport later.)
+- **Durable DB:** `app.getPath("userData")/agent-dashboard.sqlite` (schema in
+  `src/main/database/schema.ts`), Node's built-in `node:sqlite`. Persisted
+  collector caches live under `<userData>/agent-monitor/`.
+- **UI:** a first-party React app in the main window (`src/renderer/`) — NO
+  iframe. The left sidebar drives the **Dashboard** + agent nav items; live
+  updates arrive via the `desktop:db:changed` IPC push after each write.
+- **Hooks are explicit opt-in (consent-bearing).** The user enables/disables
+  tracking via the toggle → `src/main/agent-monitor-hooks.ts` writes/removes the
+  hook entries in `~/.claude/settings.json` (and, opt-in, `~/.codex/hooks.json`).
+  The hook command runs the Electron binary as Node against a **userData copy**
+  of the first-party `hook-handler.js` (location-independent across app
+  moves/updates), at the fixed port 4820. Default is OFF; disabling fully removes
+  the entries; re-enabling is idempotent and self-heals a stale path (also
+  repaired at boot via `syncAgentMonitorHooksOnBoot()`). When hooks are ON they
+  own live Claude capture, so the Claude **file watcher** is gated off (boot
+  historical import still runs); the four non-Claude tools always file-watch.
+  Disk state: a dedicated electron-store (`agent-monitor-hooks`, key `enabled`).
+- **First-party hook handlers:** `resources/hooks/{hook-handler,codex-hook-handler}.js`
+  — zero-dependency CommonJS scripts that POST `{ hook_type, data }` to
+  `:4820`. Shipped via `electron-builder.yml` `extraResources` (`to: hooks`,
+  unpacked) and resolved by `agent-monitor-path.ts`. No build step, no generated
+  tree.
+- **Security model (by design):** the collectors + listener read the agent-CLI
+  home dirs (`~/.claude`, `~/.codex`, …) **directly**, outside the gateway
+  `isPathAllowed` sandbox, but every captured session is dropped unless its
+  `cwd` is inside the FEA-1407 sandbox base directory (fail-closed). The listener
+  is bound to `127.0.0.1` only; no cloud egress from collectors. Hooks only
+  mutate global Claude/Codex config on explicit user opt-in and are reversible.
+- **Multi-harness support (5 agent tools):** ingests sessions from **Claude
+  Code** (hooks live + file historical), **OpenAI Codex** (rollout JSONL under
+  `~/.codex/sessions/`), **Cursor** (agent transcripts under `~/.cursor/projects/`),
+  **GitHub Copilot** (chat JSON under VS Code `workspaceStorage/` + CLI JSONL
+  under `~/.copilot/session-state/`), and **OpenCode** (the `opencode.db` SQLite
+  store under `~/.local/share/opencode/`). The four non-Claude tools have **no
+  hook system** — file import/watching is the only capture path. Each
+  harness's parser (`src/main/collectors/<tool>/`) emits the same normalized
+  session shape so `importSession` renders all harnesses through the unchanged
+  UI. Environment variable overrides: `$CODEX_HOME`, `$CURSOR_HOME`,
+  `$COPILOT_HOME`, `$OPENCODE_DATA_DIR` (Claude uses `$CLAUDE_HOME`).
+- **Build/packaging:** the main process is plain `tsc` → `dist/`; there is no
+  agent-monitor generative build step. Packaging ships `dist/` (via
+  `stage-packaging-app.mjs`) plus the unpacked `resources/hooks` handlers. Any
+  change to `apps/desktop/` requires the `package.json` version bump
+  (CI-enforced) and a clean-machine packaged-DMG smoke test (the highest-risk
+  path: `node:sqlite` from the asar-external, universal-merged binary).
diff --git a/apps/desktop/electron-builder.yml b/apps/desktop/electron-builder.yml
index 41cdee6f..aaac6ee9 100644
--- a/apps/desktop/electron-builder.yml
+++ b/apps/desktop/electron-builder.yml
@@ -28,6 +28,14 @@ extraResources:
       - scripts/**/*
       - package.json
       - LICENSE
+  # First-party agent-monitor hook handlers (FEA-1503), shipped unpacked outside
+  # the asar so they resolve as real files. agent-monitor-hooks.ts copies them
+  # into userData at install time; the installed hook command runs them via the
+  # Electron binary as Node (ELECTRON_RUN_AS_NODE) against that userData copy.
+  - from: resources/hooks
+    to: hooks
+    filter:
+      - "*.js"
 
 mac:
   icon: resources/icon.icns
diff --git a/apps/desktop/eslint.config.js b/apps/desktop/eslint.config.js
index 12218837..e45a2665 100644
--- a/apps/desktop/eslint.config.js
+++ b/apps/desktop/eslint.config.js
@@ -7,6 +7,12 @@ export default tseslint.config(
   ...tseslint.configs.recommended,
   {
     files: ["src/**/*.ts"],
+    // src/renderer is built by Vite and is excluded from tsconfig.json, so it
+    // is not part of the type-aware TypeScript program. Exclude it from this
+    // type-checked block too (otherwise its .ts/.d.ts files error with
+    // "parserOptions.project ... file not found"); renderer files are still
+    // linted by the recommended (syntactic) config above.
+    ignores: ["src/renderer/**"],
     languageOptions: {
       parserOptions: {
         project: "./tsconfig.json",
diff --git a/apps/desktop/package.json b/apps/desktop/package.json
index 40b29676..ebe46e1c 100644
--- a/apps/desktop/package.json
+++ b/apps/desktop/package.json
@@ -1,6 +1,6 @@
 {
   "name": "desktop",
-  "version": "0.15.106",
+  "version": "0.15.111",
   "description": "ClosedLoop Desktop",
   "author": "ClosedLoop AI <support@closedloop.ai>",
   "private": true,
@@ -12,14 +12,19 @@
     "clean:dist": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\"",
     "clean:package": "node -e \"require('fs').rmSync('dist-dmg',{recursive:true,force:true})\"",
     "prebuild": "node -e \"const{execSync:e}=require('child_process'),{writeFileSync:w}=require('fs');const h=e('git rev-parse HEAD').toString().trim();w('src/shared/build-info.ts','// AUTO-GENERATED — do not edit\\nexport const BUILD_COMMIT_HASH = \\\"'+h+'\\\";\\n');\"",
-    "build": "pnpm clean:dist && pnpm prebuild && tsc -p tsconfig.json && pnpm build:agent-monitor",
+    "build": "pnpm clean:dist && pnpm prebuild && tsc -p tsconfig.json && pnpm build:renderer && pnpm build:agent-monitor",
+    "build:renderer": "vite build --config vite.renderer.config.ts",
     "build:agent-monitor": "node scripts/build-agent-monitor.mjs",
     "dashboard:reset": "node scripts/reset-dashboard-db.mjs",
     "dashboard:reset-packs": "node scripts/reset-dashboard-db.mjs --packs-only",
     "stage:package": "node scripts/stage-packaging-app.mjs",
-    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "typecheck": "tsc -p tsconfig.json --noEmit && pnpm typecheck:renderer",
+    "typecheck:renderer": "tsc -p tsconfig.renderer.json --noEmit",
     "lint": "eslint src/",
-    "test": "tsx --test test/*.test.ts && node --test \"scripts/agent-monitor-packs/__tests__/*.test.js\" \"scripts/agent-monitor-pull-requests/__tests__/*.test.js\"",
+    "assert:design-system-boundary": "tsx --test test/agent-dashboard-boundary.test.ts",
+    "test:boot:design-system-off": "node --import tsx scripts/assert-design-system-boot-off.mjs",
+    "measure:agent-dashboard-storage": "node scripts/measure-agent-dashboard-storage.mjs",
+    "test": "tsx --test --test-concurrency=1 test/*.test.ts && node --test \"scripts/agent-monitor-packs/__tests__/*.test.js\" \"scripts/agent-monitor-pull-requests/__tests__/*.test.js\"",
     "pretest:contract": "pnpm build:agent-monitor",
     "test:contract": "node --test \"test-e2e/agent-monitor/specs/api-contract/*.test.mjs\"",
     "pretest:e2e": "pnpm build:agent-monitor",
@@ -37,7 +42,8 @@
     "release": "pnpm clean:package && pnpm build && pnpm stage:package && node scripts/run-electron-builder.mjs --publish always"
   },
   "dependencies": {
-    "@closedloop-ai/loops-api": "0.2.11",
+    "@closedloop-ai/design-system": "0.1.1-dev.26892521643.1",
+    "@closedloop-ai/loops-api": ">=0.3.1",
     "@pydantic/genai-prices": "0.0.62",
     "agent-dashboard": "github:hoangsonww/Claude-Code-Agent-Monitor#840c518d7fa69231de049e41b893938228b67e40",
     "busboy": "^1.6.0",
@@ -45,13 +51,23 @@
     "electron-store": "^8.2.0",
     "electron-updater": "^6.8.3",
     "glob": "^11.0.1",
+    "lucide-react": "^0.556.0",
+    "react": "^19.2.6",
+    "react-day-picker": "^9.14.0",
+    "react-dom": "^19.2.6",
+    "react-hook-form": "^7.76.1",
+    "react-resizable-panels": "^3.0.6",
     "socket.io-client": "^4.8.1",
     "zod": "^4.0.0"
   },
   "devDependencies": {
     "@playwright/test": "^1.60.0",
+    "@tailwindcss/typography": "^0.5.19",
+    "@tailwindcss/vite": "^4.3.0",
     "@types/busboy": "^1.5.4",
     "@types/node": "^22.13.8",
+    "@types/react": "^19.2.0",
+    "@types/react-dom": "^19.2.0",
     "@typescript-eslint/eslint-plugin": "^8.57.1",
     "@typescript-eslint/parser": "^8.57.1",
     "@vitejs/plugin-react": "4.3.4",
@@ -61,8 +77,10 @@
     "electron-builder": "^26.8.1",
     "eslint": "^10.0.3",
     "postcss": "8.5.1",
-    "tailwindcss": "3.4.17",
+    "tailwindcss": "4.3.0",
+    "tailwindcss-legacy": "npm:tailwindcss@3.4.17",
     "tsx": "^4.19.3",
+    "tw-animate-css": "^1.4.0",
     "typescript": "^5.8.2",
     "typescript-eslint": "^8.57.1",
     "vite": "6.1.0"
diff --git a/apps/desktop/resources/hooks/codex-hook-handler.js b/apps/desktop/resources/hooks/codex-hook-handler.js
new file mode 100644
index 00000000..56077c40
--- /dev/null
+++ b/apps/desktop/resources/hooks/codex-hook-handler.js
@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+
+/**
+ * @file codex-hook-handler.js
+ * @description Codex CLI hook handler (FEA-1503; first-party, moved out of the
+ * deleted vendor scripts tree). Mirrors the Claude `hook-handler.js` but posts
+ * to the Codex-owned listener route so the in-process listener stamps the
+ * session row with `harness='codex'` without trusting payload data.
+ *
+ * Zero-dependency, plain CommonJS, fail-silent — a hook must never block a Codex
+ * turn. Codex calls this once per lifecycle event (SessionStart, UserPromptSubmit,
+ * PreToolUse, PostToolUse, Stop) with the event name as the single argv arg. The
+ * port + path + payload envelope are a backward-compatible contract (FEA-1500).
+ *
+ * Part of FEA-1444 (opt-in Codex hook ingestion).
+ */
+
+const http = require("http");
+
+const hookType = process.argv[2] || "unknown";
+const port = parseInt(process.env.CLAUDE_DASHBOARD_PORT || "4820", 10);
+
+let input = "";
+
+process.stdin.setEncoding("utf8");
+process.stdin.on("data", (chunk) => (input += chunk));
+process.stdin.on("end", () => {
+  let parsedData;
+  try {
+    parsedData = JSON.parse(input);
+  } catch {
+    parsedData = { raw: input };
+  }
+
+  const data =
+    parsedData && typeof parsedData === "object" && !Array.isArray(parsedData)
+      ? parsedData
+      : { raw: parsedData };
+
+  const payload = JSON.stringify({ hook_type: hookType, data });
+
+  const req = http.request(
+    {
+      hostname: "127.0.0.1",
+      port,
+      path: "/api/hooks/codex/event",
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Content-Length": Buffer.byteLength(payload),
+      },
+      timeout: 3000,
+    },
+    (res) => {
+      res.resume();
+      process.exit(0);
+    },
+  );
+
+  req.on("error", () => process.exit(0));
+  req.on("timeout", () => {
+    req.destroy();
+    process.exit(0);
+  });
+
+  req.write(payload);
+  req.end();
+});
+
+// Safety net timeout — Codex's default hook timeout is around 5s.
+setTimeout(() => process.exit(0), 5000);
diff --git a/apps/desktop/resources/hooks/hook-handler.js b/apps/desktop/resources/hooks/hook-handler.js
new file mode 100644
index 00000000..3f564bfa
--- /dev/null
+++ b/apps/desktop/resources/hooks/hook-handler.js
@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+
+/**
+ * @file hook-handler.js
+ * @description First-party Claude Code hook handler (FEA-1503). Replaces the
+ * vendor-generated `hook-handler.js` — we now own and ship this script. Claude
+ * Code invokes it once per lifecycle event (SessionStart, UserPromptSubmit,
+ * PreToolUse, PostToolUse, Stop, SubagentStop, Notification, SessionEnd) with the
+ * event name as the single argv arg and the event payload on stdin. It forwards
+ * `{ hook_type, data }` to the in-process agent-monitor listener on the fixed
+ * loopback port 4820.
+ *
+ * Zero-dependency, plain CommonJS, fail-silent: it runs via the Electron binary
+ * as Node (ELECTRON_RUN_AS_NODE) from a userData copy, and must NEVER block or
+ * fail a Claude turn. The port + path + payload envelope are a backward-compatible
+ * contract baked into ~/.claude/settings.json (see FEA-1500); do not change them.
+ */
+
+const http = require("http");
+
+const hookType = process.argv[2] || "unknown";
+const port = parseInt(process.env.CLAUDE_DASHBOARD_PORT || "4820", 10);
+
+let input = "";
+
+process.stdin.setEncoding("utf8");
+process.stdin.on("data", (chunk) => (input += chunk));
+process.stdin.on("end", () => {
+  let parsedData;
+  try {
+    parsedData = JSON.parse(input);
+  } catch {
+    parsedData = { raw: input };
+  }
+
+  const data =
+    parsedData && typeof parsedData === "object" && !Array.isArray(parsedData)
+      ? parsedData
+      : { raw: parsedData };
+
+  const payload = JSON.stringify({ hook_type: hookType, data });
+
+  const req = http.request(
+    {
+      hostname: "127.0.0.1",
+      port,
+      path: "/api/hooks/event",
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Content-Length": Buffer.byteLength(payload),
+      },
+      timeout: 3000,
+    },
+    (res) => {
+      res.resume();
+      process.exit(0);
+    },
+  );
+
+  req.on("error", () => process.exit(0));
+  req.on("timeout", () => {
+    req.destroy();
+    process.exit(0);
+  });
+
+  req.write(payload);
+  req.end();
+});
+
+// Safety net — never let the handler linger longer than Claude's hook timeout.
+setTimeout(() => process.exit(0), 5000);
diff --git a/apps/desktop/scripts/assert-design-system-boot-off.mjs b/apps/desktop/scripts/assert-design-system-boot-off.mjs
new file mode 100644
index 00000000..42ba3eb5
--- /dev/null
+++ b/apps/desktop/scripts/assert-design-system-boot-off.mjs
@@ -0,0 +1,530 @@
+#!/usr/bin/env node
+import { execFileSync } from "node:child_process";
+import { EventEmitter } from "node:events";
+import { existsSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import Module, { registerHooks } from "node:module";
+
+const appDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+
+if (process.argv[2] === "--probe-child") {
+  await runProbeChild(process.argv[3]);
+} else {
+  runParent();
+}
+
+function runParent() {
+  const modes = ["disabled", "legacy"];
+  const summaries = [];
+  for (const mode of modes) {
+    const output = execFileSync(
+      process.execPath,
+      [
+        "--import",
+        "tsx",
+        fileURLToPath(import.meta.url),
+        "--probe-child",
+        mode,
+      ],
+      {
+        cwd: appDir,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "inherit"],
+      },
+    ).trim();
+    summaries.push(JSON.parse(lastJsonLine(output)));
+  }
+  console.log(JSON.stringify({ ok: true, modes: summaries }, null, 2));
+}
+
+function lastJsonLine(output) {
+  const lines = output.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  const line = [...lines].reverse().find((candidate) => candidate.startsWith("{"));
+  if (!line) {
+    throw new Error(`Boot probe did not emit JSON output:\n${output}`);
+  }
+  return line;
+}
+
+async function runProbeChild(mode) {
+  if (mode !== "disabled" && mode !== "legacy") {
+    throw new Error(`Unknown boot probe mode: ${mode}`);
+  }
+
+  const userDataPath = mkdtempSync(
+    path.join(tmpdir(), `agent-dashboard-${mode}-boot-`),
+  );
+  const state = createProbeState(mode, userDataPath);
+  globalThis.__agentDashboardBootProbeState = state;
+
+  const electronCjsStub = createElectronCjsStub(state);
+  globalThis.__agentDashboardBootProbeElectronCjs = electronCjsStub;
+  const originalLoad = Module._load;
+  Module._load = function load(request, parent, isMain) {
+    if (request === "electron") {
+      return electronCjsStub;
+    }
+    return originalLoad.call(this, request, parent, isMain);
+  };
+
+  registerHooks({
+    resolve(specifier, context, nextResolve) {
+      if (specifier === "electron") {
+        return stub("electron");
+      }
+      if (specifier === "electron-log/main.js") {
+        return stub("electron-log-main");
+      }
+      if (specifier === "electron-updater") {
+        return stub("electron-updater");
+      }
+      if (specifier === "electron-store") {
+        return stub("electron-store");
+      }
+      if (specifier === "node:child_process") {
+        return stub("node-child-process");
+      }
+      if (specifier === "node:sqlite") {
+        return stub("node-sqlite");
+      }
+      return nextResolve(specifier, context);
+    },
+    load(url, context, nextLoad) {
+      if (url.startsWith("file:")) {
+        const filePath = fileURLToPath(url);
+        if (isDesignOnlyModule(filePath)) {
+          state.loadedDesignModules.push(toAppRelative(filePath));
+        }
+      }
+      return nextLoad(url, context);
+    },
+  });
+
+  let exitAfterCleanup = false;
+  try {
+    await import(pathToFileURL(path.join(appDir, "src/main/index.ts")).href);
+    state.app.emit("ready");
+    await waitFor(() => state.browserWindows.length > 0, 4_000);
+    await settle();
+
+    const summary = summarizeState(state);
+    assertNoDesignBootEffects(summary);
+    process.stdout.write(JSON.stringify(summary));
+    exitAfterCleanup = true;
+  } finally {
+    rmSync(userDataPath, { recursive: true, force: true });
+    if (exitAfterCleanup) {
+      process.exit(0);
+    }
+  }
+}
+
+function createProbeState(mode, userDataPath) {
+  return {
+    mode,
+    userDataPath,
+    app: null,
+    settingsSeed:
+      mode === "disabled"
+        ? { agentMonitorEnabled: false, agentDashboardDesignSystemEnabled: false }
+        : { agentMonitorEnabled: true, agentDashboardDesignSystemEnabled: false },
+    loadedDesignModules: [],
+    databaseOpens: [],
+    ipcHandlers: new Set(),
+    ipcRemovedHandlers: [],
+    protocolPrivilegedSchemes: [],
+    protocolHandles: [],
+    protocolUnhandles: [],
+    browserWindows: [],
+    loadFiles: [],
+    loadUrls: [],
+    exits: [],
+    childProcesses: [],
+  };
+}
+
+function createElectronCjsStub(state) {
+  class ProbeApp extends EventEmitter {
+    isPackaged = false;
+    dock = {
+      setIcon: () => undefined,
+    };
+
+    getVersion() {
+      return "0.0.0-boot-probe";
+    }
+
+    setName() {}
+
+    setAboutPanelOptions() {}
+
+    getPath(name) {
+      if (name === "userData") {
+        return state.userDataPath;
+      }
+      if (name === "logs") {
+        return path.join(state.userDataPath, "logs");
+      }
+      return state.userDataPath;
+    }
+
+    exit(code = 0) {
+      state.exits.push(code);
+    }
+
+    quit() {
+      state.exits.push(0);
+    }
+  }
+
+  class ProbeBrowserWindow extends EventEmitter {
+    constructor(options) {
+      super();
+      this.options = options;
+      this.visible = false;
+      this.webContents = new EventEmitter();
+      this.webContents.send = (channel, payload) => {
+        state.sentMessages ??= [];
+        state.sentMessages.push({ channel, payload });
+      };
+      this.webContents.setWindowOpenHandler = (handler) => {
+        this.windowOpenHandler = handler;
+      };
+      state.browserWindows.push({
+        preload: options?.webPreferences?.preload ?? null,
+        additionalArguments:
+          options?.webPreferences?.additionalArguments ?? [],
+      });
+    }
+
+    loadFile(filePath) {
+      state.loadFiles.push(filePath);
+      return Promise.resolve();
+    }
+
+    loadURL(url) {
+      state.loadUrls.push(url);
+      return Promise.resolve();
+    }
+
+    once(eventName, listener) {
+      if (eventName === "ready-to-show") {
+        queueMicrotask(listener);
+        return this;
+      }
+      return super.once(eventName, listener);
+    }
+
+    show() {
+      this.visible = true;
+    }
+
+    hide() {
+      this.visible = false;
+    }
+
+    focus() {}
+
+    isVisible() {
+      return this.visible;
+    }
+
+    close() {
+      this.emit("close", { preventDefault: () => undefined });
+    }
+  }
+
+  class ProbeNotification extends EventEmitter {
+    constructor(options) {
+      super();
+      this.options = options;
+    }
+
+    show() {}
+  }
+
+  class ProbeTray extends EventEmitter {
+    setToolTip() {}
+    setContextMenu() {}
+    setImage() {}
+    setTitle() {}
+    destroy() {}
+  }
+
+  const app = new ProbeApp();
+  state.app = app;
+  return {
+    app,
+    BrowserWindow: ProbeBrowserWindow,
+    Notification: ProbeNotification,
+    Tray: ProbeTray,
+    Menu: { buildFromTemplate: (template) => template },
+    nativeTheme: { themeSource: "system" },
+    nativeImage: {
+      createFromPath: () => ({ setTemplateImage: () => undefined }),
+    },
+    protocol: {
+      registerSchemesAsPrivileged: (schemes) => {
+        state.protocolPrivilegedSchemes.push(...schemes);
+      },
+      handle: (scheme) => {
+        state.protocolHandles.push(scheme);
+      },
+      unhandle: (scheme) => {
+        state.protocolUnhandles.push(scheme);
+      },
+    },
+    ipcMain: {
+      handle: (channel) => {
+        state.ipcHandlers.add(channel);
+      },
+      removeHandler: (channel) => {
+        state.ipcRemovedHandlers.push(channel);
+        state.ipcHandlers.delete(channel);
+      },
+    },
+    dialog: {
+      showMessageBox: async () => ({ response: 0 }),
+      showOpenDialog: async () => ({ canceled: true, filePaths: [] }),
+    },
+    shell: {
+      openExternal: async () => undefined,
+      openPath: async () => "",
+    },
+    safeStorage: {
+      isEncryptionAvailable: () => true,
+      encryptString: (text) => Buffer.from(text, "utf8"),
+      decryptString: (buffer) => Buffer.from(buffer).toString("utf8"),
+    },
+    powerMonitor: new EventEmitter(),
+  };
+}
+
+function stub(kind) {
+  return {
+    shortCircuit: true,
+    url: `data:text/javascript,${encodeURIComponent(stubSource(kind))}`,
+  };
+}
+
+function stubSource(kind) {
+  if (kind === "electron") {
+    return `
+      const cjs = globalThis.__agentDashboardBootProbeElectronCjs;
+      export const app = cjs.app;
+      export const BrowserWindow = cjs.BrowserWindow;
+      export const Notification = cjs.Notification;
+      export const Tray = cjs.Tray;
+      export const Menu = cjs.Menu;
+      export const nativeTheme = cjs.nativeTheme;
+      export const nativeImage = cjs.nativeImage;
+      export const protocol = cjs.protocol;
+      export const ipcMain = cjs.ipcMain;
+      export const dialog = cjs.dialog;
+      export const shell = cjs.shell;
+      export const safeStorage = cjs.safeStorage;
+      export const powerMonitor = cjs.powerMonitor;
+      export default cjs;
+    `;
+  }
+  if (kind === "electron-log-main") {
+    return `
+      const fileTransport = {
+        level: false,
+        fileName: "main.log",
+        maxSize: 0,
+        archiveLogFn: undefined,
+        getFile: () => ({ path: globalThis.__agentDashboardBootProbeState.userDataPath + "/logs/main.log" }),
+      };
+      const electronLog = {
+        initialize: () => undefined,
+        transports: {
+          console: { level: false, writeFn: () => undefined },
+          file: fileTransport,
+        },
+        error: () => undefined,
+        warn: () => undefined,
+        debug: () => undefined,
+        info: () => undefined,
+      };
+      export default electronLog;
+    `;
+  }
+  if (kind === "electron-updater") {
+    return `
+      export const autoUpdater = {
+        logger: null,
+        autoDownload: false,
+        autoInstallOnAppQuit: false,
+        on: () => undefined,
+        checkForUpdates: async () => null,
+        quitAndInstall: () => undefined,
+      };
+      export default { autoUpdater };
+    `;
+  }
+  if (kind === "electron-store") {
+    return `
+      export default class Store {
+        constructor() {
+          this.store = { ...globalThis.__agentDashboardBootProbeState.settingsSeed };
+        }
+        get(key, defaultValue) {
+          return Object.prototype.hasOwnProperty.call(this.store, key) ? this.store[key] : defaultValue;
+        }
+        set(key, value) {
+          this.store[key] = value;
+        }
+        delete(key) {
+          delete this.store[key];
+        }
+      }
+    `;
+  }
+  if (kind === "node-child-process") {
+    return `
+      import { EventEmitter } from "node:events";
+      function child() {
+        const instance = new EventEmitter();
+        instance.pid = Math.floor(Math.random() * 100000) + 1000;
+        instance.stdout = new EventEmitter();
+        instance.stderr = new EventEmitter();
+        instance.kill = () => true;
+        globalThis.__agentDashboardBootProbeState.childProcesses.push(instance.pid);
+        return instance;
+      }
+      export function spawn() { return child(); }
+      export function spawnSync() { return { status: 0, stdout: "", stderr: "" }; }
+      export function execSync() { return ""; }
+      export function execFileSync() { return ""; }
+      export function execFile(_file, _args, options, callback) {
+        const cb = typeof options === "function" ? options : callback;
+        queueMicrotask(() => cb?.(null, "", ""));
+        return child();
+      }
+    `;
+  }
+  if (kind === "node-sqlite") {
+    return `
+      export class DatabaseSync {
+        constructor(filename) {
+          this.filename = filename;
+          globalThis.__agentDashboardBootProbeState.databaseOpens.push(String(filename));
+        }
+        exec() {}
+        prepare() {
+          return {
+            all: () => [],
+            get: () => undefined,
+            run: () => ({ changes: 0, lastInsertRowid: 0 }),
+          };
+        }
+        close() {}
+      }
+    `;
+  }
+  throw new Error(`Unknown stub kind: ${kind}`);
+}
+
+function summarizeState(state) {
+  const dbHandlers = [...state.ipcHandlers].filter((channel) =>
+    channel.startsWith("desktop:db:"),
+  );
+  const designDbPath = path.join(state.userDataPath, "agent-dashboard.sqlite");
+  return {
+    mode: state.mode,
+    userDataPath: state.userDataPath,
+    loadedDesignModules: state.loadedDesignModules,
+    dbHandlers,
+    databaseOpens: state.databaseOpens,
+    designDatabaseFileExists: existsSync(designDbPath),
+    appProtocolPrivileged:
+      state.protocolPrivilegedSchemes.some((entry) => entry?.scheme === "app"),
+    appProtocolHandled: state.protocolHandles.includes("app"),
+    browserWindows: state.browserWindows,
+    loadFiles: state.loadFiles.map(toAppRelative),
+    loadUrls: state.loadUrls,
+    exits: state.exits,
+  };
+}
+
+function assertNoDesignBootEffects(summary) {
+  const failures = [];
+  if (summary.loadedDesignModules.length > 0) {
+    failures.push(`loaded design modules: ${summary.loadedDesignModules.join(", ")}`);
+  }
+  if (summary.dbHandlers.length > 0) {
+    failures.push(`registered DB IPC handlers: ${summary.dbHandlers.join(", ")}`);
+  }
+  const designDbOpens = summary.databaseOpens.filter((opened) =>
+    opened.endsWith("agent-dashboard.sqlite"),
+  );
+  if (designDbOpens.length > 0) {
+    failures.push(`opened design DB: ${designDbOpens.join(", ")}`);
+  }
+  if (summary.designDatabaseFileExists) {
+    failures.push("created agent-dashboard.sqlite under temp userData");
+  }
+  if (summary.appProtocolPrivileged) {
+    failures.push("privileged app:// protocol");
+  }
+  if (summary.appProtocolHandled) {
+    failures.push("registered app:// protocol handler");
+  }
+  const designPreloads = summary.browserWindows.filter((window) =>
+    String(window.preload).endsWith("preload-design-system.js"),
+  );
+  if (designPreloads.length > 0) {
+    failures.push("loaded design-system preload");
+  }
+  const designArgs = summary.browserWindows.filter((window) =>
+    window.additionalArguments.includes(
+      "--closedloop-agent-dashboard-design-system",
+    ),
+  );
+  if (designArgs.length > 0) {
+    failures.push("passed design-system renderer argument");
+  }
+  const appUrls = summary.loadUrls.filter((url) => String(url).startsWith("app://"));
+  if (appUrls.length > 0) {
+    failures.push(`loaded app:// URL: ${appUrls.join(", ")}`);
+  }
+  if (summary.exits.some((code) => code !== 0)) {
+    failures.push(`boot called app.exit with non-zero code: ${summary.exits.join(", ")}`);
+  }
+  if (failures.length > 0) {
+    throw new Error(`${summary.mode} boot no-load assertion failed: ${failures.join("; ")}`);
+  }
+}
+
+function isDesignOnlyModule(filePath) {
+  const relative = toAppRelative(filePath);
+  return (
+    relative === "src/main/agent-dashboard-design-system-runtime.ts" ||
+    relative === "src/main/agent-monitor-listener.ts" ||
+    relative.startsWith("src/main/collectors/") ||
+    relative.startsWith("src/main/database/") ||
+    relative === "src/main/preload-design-system.ts"
+  );
+}
+
+function toAppRelative(filePath) {
+  return path.relative(appDir, filePath).split(path.sep).join("/");
+}
+
+async function waitFor(predicate, timeoutMs) {
+  const startedAt = Date.now();
+  while (!predicate()) {
+    if (Date.now() - startedAt > timeoutMs) {
+      throw new Error("Timed out waiting for Desktop boot probe side effects");
+    }
+    await new Promise((resolve) => setTimeout(resolve, 20));
+  }
+}
+
+async function settle() {
+  await Promise.resolve();
+  await new Promise((resolve) => setImmediate(resolve));
+}
diff --git a/apps/desktop/scripts/build-agent-monitor.mjs b/apps/desktop/scripts/build-agent-monitor.mjs
index dcaa9cb2..0a39dd2f 100644
--- a/apps/desktop/scripts/build-agent-monitor.mjs
+++ b/apps/desktop/scripts/build-agent-monitor.mjs
@@ -24,6 +24,7 @@ import {
   readFileSync,
   readdirSync,
   rmSync,
+  symlinkSync,
   writeFileSync,
 } from "node:fs";
 import { createRequire } from "node:module";
@@ -33,6 +34,7 @@ import { fileURLToPath } from "node:url";
 
 const SOURCE_ROOT_PACKAGE = "agent-dashboard";
 const SOURCE_CLIENT_PACKAGE = "agent-dashboard-client";
+const LEGACY_TAILWIND_PACKAGE = "tailwindcss-legacy";
 
 const scriptDir = path.dirname(fileURLToPath(import.meta.url));
 const appDir = path.resolve(scriptDir, "..");
@@ -44,6 +46,7 @@ const sourceRootDir = resolvePackageRoot(SOURCE_ROOT_PACKAGE);
 const sourceClientDir = resolvePackageRoot(SOURCE_CLIENT_PACKAGE);
 const sourceRootPkg = path.join(sourceRootDir, "package.json");
 const sourceClientPkg = path.join(sourceClientDir, "package.json");
+const legacyTailwindDir = resolvePackageRoot(LEGACY_TAILWIND_PACKAGE);
 const sourceServerEntry = path.join(sourceRootDir, "server", "index.js");
 const sourceSessionsRoute = path.join(sourceRootDir, "server", "routes", "sessions.js");
 const sourceHooksRoute = path.join(sourceRootDir, "server", "routes", "hooks.js");
@@ -526,7 +529,9 @@ function currentStamp() {
 function buildClient() {
   patchClientSource();
   rmSync(sourceClientDistDir, { recursive: true, force: true });
-  runNodeScript("vite build", viteBin, ["build"], sourceClientDir);
+  withLegacyTailwindForClientBuild(() => {
+    runNodeScript("vite build", viteBin, ["build"], sourceClientDir);
+  });
   if (!existsSync(path.join(sourceClientDistDir, "index.html"))) {
     throw new Error(
       `Client build completed but ${path.join(sourceClientDistDir, "index.html")} is missing.`,
@@ -534,6 +539,25 @@ function buildClient() {
   }
 }
 
+function withLegacyTailwindForClientBuild(work) {
+  const clientNodeModulesDir = path.join(sourceClientDir, "node_modules");
+  const clientTailwindLink = path.join(clientNodeModulesDir, "tailwindcss");
+  const createdLink = !existsSync(clientTailwindLink);
+
+  if (createdLink) {
+    mkdirSync(clientNodeModulesDir, { recursive: true });
+    symlinkSync(legacyTailwindDir, clientTailwindLink, "dir");
+  }
+
+  try {
+    work();
+  } finally {
+    if (createdLink) {
+      rmSync(clientTailwindLink, { recursive: true, force: true });
+    }
+  }
+}
+
 function materializeRuntimeTree() {
   rmSync(generatedRootDir, { recursive: true, force: true });
   mkdirSync(generatedRootDir, { recursive: true });
diff --git a/apps/desktop/scripts/measure-agent-dashboard-storage.mjs b/apps/desktop/scripts/measure-agent-dashboard-storage.mjs
new file mode 100644
index 00000000..476747ef
--- /dev/null
+++ b/apps/desktop/scripts/measure-agent-dashboard-storage.mjs
@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+/**
+ * Measure Agent Dashboard SQLite storage without creating missing DB files.
+ *
+ * The legacy sidecar DB lives at `<userData>/agent-monitor/dashboard.db`; the
+ * Labs design-system DB lives at `<userData>/agent-dashboard.sqlite`. Missing
+ * files are reported as absent and are never opened.
+ */
+import { existsSync, statSync } from "node:fs";
+import { homedir, platform } from "node:os";
+import path from "node:path";
+import { DatabaseSync } from "node:sqlite";
+
+const APP_NAME = "ClosedLoop";
+
+const userDataPath = parseUserDataArg(process.argv) ?? defaultUserDataPath();
+const targets = [
+  {
+    mode: "legacy",
+    path: path.join(userDataPath, "agent-monitor", "dashboard.db"),
+  },
+  {
+    mode: "design-system",
+    path: path.join(userDataPath, "agent-dashboard.sqlite"),
+  },
+];
+
+const measurements = targets.map(measureExistingDatabase);
+console.log(JSON.stringify({ userDataPath, measurements }, null, 2));
+
+function parseUserDataArg(argv) {
+  const index = argv.indexOf("--user-data");
+  if (index < 0) {
+    return null;
+  }
+  const value = argv[index + 1];
+  if (!value) {
+    throw new Error("--user-data requires a path value");
+  }
+  return path.resolve(value);
+}
+
+function defaultUserDataPath() {
+  switch (platform()) {
+    case "darwin":
+      return path.join(homedir(), "Library", "Application Support", APP_NAME);
+    case "win32":
+      return path.join(
+        process.env.APPDATA || path.join(homedir(), "AppData", "Roaming"),
+        APP_NAME,
+      );
+    default:
+      return path.join(homedir(), ".config", APP_NAME);
+  }
+}
+
+function measureExistingDatabase(target) {
+  if (!existsSync(target.path)) {
+    return {
+      mode: target.mode,
+      path: target.path,
+      exists: false,
+      bytes: 0,
+      tables: [],
+      indexes: [],
+    };
+  }
+
+  const db = new DatabaseSync(target.path);
+  try {
+    const objects = db
+      .prepare(
+        `
+          SELECT type, name
+          FROM sqlite_master
+          WHERE type IN ('table', 'index')
+          ORDER BY type ASC, name ASC
+        `,
+      )
+      .all();
+    return {
+      mode: target.mode,
+      path: target.path,
+      exists: true,
+      bytes: statSync(target.path).size,
+      tables: objects
+        .filter((row) => row.type === "table")
+        .map((row) => row.name),
+      indexes: objects
+        .filter((row) => row.type === "index")
+        .map((row) => row.name),
+    };
+  } finally {
+    db.close();
+  }
+}
diff --git a/apps/desktop/scripts/reset-dashboard-db.mjs b/apps/desktop/scripts/reset-dashboard-db.mjs
index e9b6b70d..49573a95 100644
--- a/apps/desktop/scripts/reset-dashboard-db.mjs
+++ b/apps/desktop/scripts/reset-dashboard-db.mjs
@@ -1,49 +1,43 @@
 #!/usr/bin/env node
 /**
- * @file reset-dashboard-db.mjs — wipe the Agent Dashboard sidecar's local DB.
+ * @file reset-dashboard-db.mjs — wipe the in-process Agent Dashboard DB.
  *
- * Two modes:
- *   (default)     full wipe — removes dashboard.db + dashboard.db-wal/-shm.
- *                 Loses sessions, events, agents, plans, AND pack inventory.
- *                 Use for first-time-user-experience (FTUE) testing.
- *   --packs-only  wipe only the pack inventory tables
- *                 (agent_packs, skills, project_pack_associations).
- *                 Preserves sessions, events, agents, plans. Use when
- *                 iterating on the scanner.
+ * Full wipe — removes `agent-dashboard.sqlite` + its `-wal`/`-shm` sidecars.
+ * Loses all collected sessions, events, agents, and token usage. Use for
+ * first-time-user-experience (FTUE) testing — the next launch re-derives history
+ * from the on-disk agent-CLI transcripts (FEA-1503 collection layer).
  *
- * The Electron sidecar must be STOPPED before running this — node:sqlite
- * locks the DB file. The script will refuse with a clear message if the
- * sidecar is still running (port 4820 is bound).
+ * The ClosedLoop app must be STOPPED before running this — node:sqlite locks the
+ * DB file and the in-process hook listener holds 127.0.0.1:4820. The script
+ * refuses with a clear message if the app is still running (port 4820 is bound).
  *
- * Cross-platform DB path resolution mirrors `app.getPath("userData")` from
- * the Electron main process — see apps/desktop/CLAUDE.md "Agent Monitor
- * Sidecar" section for the canonical location.
+ * Cross-platform DB path resolution mirrors `app.getPath("userData")` from the
+ * Electron main process (`<userData>/agent-dashboard.sqlite`).
  */
 import { existsSync, rmSync } from "node:fs";
 import { homedir, platform } from "node:os";
 import { join } from "node:path";
 import net from "node:net";
 
-const PACKS_ONLY = process.argv.includes("--packs-only");
 const APP_NAME = "ClosedLoop";
+const DB_FILE = "agent-dashboard.sqlite";
 
 function dashboardDbPath() {
   switch (platform()) {
     case "darwin":
-      return join(homedir(), "Library", "Application Support", APP_NAME, "agent-monitor", "dashboard.db");
+      return join(homedir(), "Library", "Application Support", APP_NAME, DB_FILE);
     case "win32":
       return join(
         process.env.APPDATA || join(homedir(), "AppData", "Roaming"),
         APP_NAME,
-        "agent-monitor",
-        "dashboard.db",
+        DB_FILE,
       );
     default:
-      return join(homedir(), ".config", APP_NAME, "agent-monitor", "dashboard.db");
+      return join(homedir(), ".config", APP_NAME, DB_FILE);
   }
 }
 
-async function sidecarIsRunning(port = 4820) {
+async function appIsRunning(port = 4820) {
   return new Promise((resolve) => {
     const sock = net.connect({ port, host: "127.0.0.1", timeout: 200 }, () => {
       sock.end();
@@ -57,13 +51,23 @@ async function sidecarIsRunning(port = 4820) {
   });
 }
 
+function removeAll(dbPath) {
+  for (const ext of ["", "-wal", "-shm"]) {
+    const f = dbPath + ext;
+    if (existsSync(f)) {
+      rmSync(f, { force: true });
+      console.log(`[reset-dashboard-db] removed ${f}`);
+    }
+  }
+}
+
 async function main() {
   const dbPath = dashboardDbPath();
 
-  if (await sidecarIsRunning()) {
+  if (await appIsRunning()) {
     console.error(
-      "[reset-dashboard-db] Sidecar is running on 127.0.0.1:4820 — stop the\n" +
-        "ClosedLoop app first (Cmd-Q the tray icon) so the DB is unlocked.",
+      "[reset-dashboard-db] ClosedLoop is running on 127.0.0.1:4820 — quit the\n" +
+        "app first (Cmd-Q the tray icon) so the DB is unlocked.",
     );
     process.exit(1);
   }
@@ -73,59 +77,13 @@ async function main() {
     return;
   }
 
-  if (PACKS_ONLY) {
-    // Open via node:sqlite (built-in, same path the sidecar uses) and run
-    // DELETE on just the three inventory tables. Refuse to run on older
-    // Node — the previous fallback silently wiped the WHOLE DB (sessions,
-    // events, agents, plans), which was actively dangerous because the
-    // command name `--packs-only` promised the opposite. (shafty PR review
-    // P2.)
-    let DatabaseSync;
-    try {
-      ({ DatabaseSync } = await import("node:sqlite"));
-    } catch (e) {
-      console.error(
-        "[reset-dashboard-db] --packs-only requires Node >=22.5 (node:sqlite\n" +
-          "  built-in module). Refusing to widen this into a full DB wipe.\n" +
-          "  Upgrade Node or run `pnpm -C apps/desktop dashboard:reset`\n" +
-          "  if you explicitly want the full FTUE reset. Reason:",
-        e && e.message,
-      );
-      process.exit(2);
-    }
-    const db = new DatabaseSync(dbPath);
-    try {
-      for (const t of ["agent_packs", "skills", "project_pack_associations"]) {
-        try {
-          db.exec(`DELETE FROM ${t};`);
-          console.log(`[reset-dashboard-db] cleared ${t}`);
-        } catch (e) {
-          console.warn(`[reset-dashboard-db] could not clear ${t}:`, e && e.message);
-        }
-      }
-    } finally {
-      db.close();
-    }
-    console.log("[reset-dashboard-db] Pack inventory wiped. Restart the sidecar to rescan.");
-    return;
-  }
-
   removeAll(dbPath);
   console.log(
-    "[reset-dashboard-db] Full DB wiped. Next sidecar boot starts at FTUE state.",
+    "[reset-dashboard-db] Full DB wiped. Next launch starts at FTUE state and\n" +
+      "re-imports history from your on-disk agent-CLI transcripts.",
   );
 }
 
-function removeAll(dbPath) {
-  for (const ext of ["", "-wal", "-shm"]) {
-    const f = dbPath + ext;
-    if (existsSync(f)) {
-      rmSync(f, { force: true });
-      console.log(`[reset-dashboard-db] removed ${f}`);
-    }
-  }
-}
-
 main().catch((err) => {
   console.error("[reset-dashboard-db] failed:", err);
   process.exit(1);
diff --git a/apps/desktop/scripts/stage-packaging-app.mjs b/apps/desktop/scripts/stage-packaging-app.mjs
index 88a1da18..8d56c8ef 100644
--- a/apps/desktop/scripts/stage-packaging-app.mjs
+++ b/apps/desktop/scripts/stage-packaging-app.mjs
@@ -106,10 +106,11 @@ const stagePackageJson = {
   type: packageJson.type,
   main: packageJson.main,
   dependencies: Object.fromEntries(
-    Object.entries(installedDependencies).map(([dependencyName, dependency]) => [
-      dependencyName,
-      resolveStageDependencySpec(packageJson, dependencyName, dependency),
-    ]),
+    Object.entries(installedDependencies)
+      .map(([dependencyName, dependency]) => [
+        dependencyName,
+        resolveStageDependencySpec(packageJson, dependencyName, dependency),
+      ]),
   ),
 };
 const stageRootPackageJson = {
@@ -130,7 +131,17 @@ await writeFile(
   stageRootPackageJsonFile,
   `${JSON.stringify(stageRootPackageJson, null, 2)}\n`,
 );
-await writeFile(stageNpmrcFile, `${repoNpmrc.trimEnd()}\nnode-linker=hoisted\n`);
+await writeFile(
+  stageNpmrcFile,
+  [
+    repoNpmrc.trimEnd(),
+    "node-linker=hoisted",
+    "minimum-release-age-exclude[]=@closedloop-ai/design-system",
+    "minimum-release-age-exclude[]=@closedloop-ai/loops-api",
+    "minimum-release-age-exclude[]=@pydantic/genai-prices",
+    "",
+  ].join("\n"),
+);
 
 const installResult = spawnSync(
   "pnpm",
diff --git a/apps/desktop/src/main/agent-dashboard-design-system-runtime.ts b/apps/desktop/src/main/agent-dashboard-design-system-runtime.ts
new file mode 100644
index 00000000..3a2ccb4e
--- /dev/null
+++ b/apps/desktop/src/main/agent-dashboard-design-system-runtime.ts
@@ -0,0 +1,226 @@
+import path from "node:path";
+import { app, ipcMain, type BrowserWindow } from "electron";
+import { AgentHookListener } from "./agent-monitor-listener.js";
+import { CollectorManager } from "./collectors/collector-manager.js";
+import {
+  loadMeteredUsageRows,
+  type MeteredUsageRow,
+} from "./reconciliation-worker.js";
+import { detectBillingMode } from "./billing-mode-detector.js";
+import { openAgentDatabase, type AgentDatabase } from "./database/index.js";
+import { coerceDbId } from "./database/ipc-validation.js";
+import { createLifecycle } from "./database/lifecycle.js";
+import { isAgentMonitorHooksEnabled } from "./agent-monitor-hooks.js";
+
+const DESIGN_SYSTEM_DB_IPC_CHANNELS = [
+  "desktop:db:get-sessions",
+  "desktop:db:get-session",
+  "desktop:db:get-agents",
+  "desktop:db:get-events",
+  "desktop:db:get-dashboard-summary",
+  "desktop:db:get-sessions-with-details",
+  "desktop:db:get-event-feed",
+  "desktop:db:get-events-with-session",
+  "desktop:db:get-event-count-by-type",
+  "desktop:db:get-token-analytics",
+  "desktop:db:get-agent-hierarchy",
+  "desktop:db:get-analytics",
+  "desktop:db:get-workflow-data",
+] as const;
+
+export interface AgentDashboardDesignSystemRuntimeOptions {
+  getSandboxBaseDirectory: () => string;
+  getWindow: () => BrowserWindow | null;
+  onTerminalFailure: (reason: string) => void;
+  userDataPath?: string;
+  log?: (scope: string, message: string) => void;
+}
+
+export interface AgentDashboardDesignSystemRuntime {
+  connection: AgentDatabase["connection"];
+  getUrl: () => string | null;
+  isReady: () => boolean;
+  start: () => void;
+  stop: () => Promise<void>;
+  close: () => void;
+  restartCollectors: () => void;
+  registerIpcHandlers: () => void;
+  loadMeteredUsageRows: (cutoffIso: string) => MeteredUsageRow[];
+}
+
+/**
+ * Resolve the opt-in design-system dashboard database. This helper lives inside
+ * the dynamic boundary so default/legacy boot never imports code that can create
+ * or migrate `agent-dashboard.sqlite`.
+ */
+export function resolveAgentDashboardDatabasePath(
+  userDataPath = app.getPath("userData"),
+): string {
+  return path.join(userDataPath, "agent-dashboard.sqlite");
+}
+
+/**
+ * Create the in-process design-system dashboard runtime. Import this module only
+ * after the Labs flag has selected design-system mode; all imports below this
+ * boundary can open SQLite, bind the hook port, register IPC, or start watchers.
+ */
+export function createAgentDashboardDesignSystemRuntime(
+  options: AgentDashboardDesignSystemRuntimeOptions,
+): AgentDashboardDesignSystemRuntime {
+  const log = options.log ?? (() => {});
+  const agentDatabase = openAgentDatabase(
+    resolveAgentDashboardDatabasePath(options.userDataPath),
+  );
+  let dbIpcRegistered = false;
+  let closed = false;
+
+  const lifecycle = createLifecycle(agentDatabase.connection, {
+    tokenUsage: agentDatabase.tokenUsage,
+    detectBillingMode,
+    emit: (sessionId: string) => {
+      agentDatabase.sessions.handleSessionMutation(sessionId);
+      options.getWindow()?.webContents.send("desktop:db:changed", { sessionId });
+    },
+    log: (message: string) => log("agent-lifecycle", message),
+  });
+
+  const hookListener = new AgentHookListener({
+    lifecycle,
+    getSandboxBaseDirectory: options.getSandboxBaseDirectory,
+    log: (message: string) => log("agent-monitor-listener", message),
+    onBindError: options.onTerminalFailure,
+  });
+
+  const collectorManager = new CollectorManager({
+    agentDatabase,
+    detectBillingMode,
+    getSandboxBaseDirectory: options.getSandboxBaseDirectory,
+    stateDir: path.join(options.userDataPath ?? app.getPath("userData"), "agent-monitor"),
+    emit: (sessionId?: string) => {
+      options.getWindow()?.webContents.send("desktop:db:changed", { sessionId });
+    },
+    shouldWatchClaude: () => !isAgentMonitorHooksEnabled(),
+    log: (message: string) => log("agent-collectors", message),
+  });
+
+  const runtime: AgentDashboardDesignSystemRuntime = {
+    connection: agentDatabase.connection,
+    getUrl: () => hookListener.getUrl(),
+    isReady: () => hookListener.isReady(),
+    start: () => {
+      if (closed) {
+        return;
+      }
+      void hookListener.start();
+      collectorManager.start();
+    },
+    stop: async () => {
+      if (closed) {
+        return;
+      }
+      collectorManager.stop();
+      await hookListener.stop();
+    },
+    close: () => {
+      if (closed) {
+        return;
+      }
+      closed = true;
+      unregisterDesignSystemDbIpcHandlers();
+      agentDatabase.close();
+    },
+    restartCollectors: () => {
+      if (closed) {
+        return;
+      }
+      collectorManager.stop();
+      collectorManager.start();
+    },
+    registerIpcHandlers: () => {
+      if (dbIpcRegistered) {
+        return;
+      }
+      dbIpcRegistered = true;
+      registerDesignSystemDbIpcHandlers(agentDatabase);
+    },
+    loadMeteredUsageRows: (cutoffIso: string) =>
+      loadMeteredUsageRows(agentDatabase.connection, cutoffIso),
+  };
+
+  return runtime;
+}
+
+function registerDesignSystemDbIpcHandlers(agentDatabase: AgentDatabase): void {
+  ipcMain.handle("desktop:db:get-sessions", () => agentDatabase.sessions.getAll());
+
+  ipcMain.handle("desktop:db:get-session", (_event, id: unknown) => {
+    const sessionId = coerceDbId(id);
+    if (sessionId === null) return undefined;
+    return agentDatabase.sessions.getById(sessionId);
+  });
+
+  ipcMain.handle("desktop:db:get-agents", (_event, sessionId: unknown) => {
+    const id = coerceDbId(sessionId);
+    if (id === null) return [];
+    return agentDatabase.agents.getBySession(id);
+  });
+
+  ipcMain.handle(
+    "desktop:db:get-events",
+    (_event, sessionId: unknown, agentId?: unknown) => {
+      const sid = coerceDbId(sessionId);
+      if (sid === null) return [];
+      const aid = coerceDbId(agentId);
+      if (aid !== null) {
+        return agentDatabase.events.getBySessionAndAgent(sid, aid);
+      }
+      return agentDatabase.events.getBySession(sid);
+    },
+  );
+
+  ipcMain.handle("desktop:db:get-dashboard-summary", () =>
+    agentDatabase.getSummary(),
+  );
+
+  ipcMain.handle("desktop:db:get-sessions-with-details", () =>
+    agentDatabase.sessions.getAllWithDetails(),
+  );
+
+  ipcMain.handle("desktop:db:get-event-feed", () =>
+    agentDatabase.events.getAll(),
+  );
+
+  ipcMain.handle("desktop:db:get-events-with-session", (_event, sessionId: unknown) => {
+    const id = coerceDbId(sessionId);
+    if (id === null) return [];
+    return agentDatabase.events.getWithSession(id);
+  });
+
+  ipcMain.handle("desktop:db:get-event-count-by-type", () =>
+    agentDatabase.events.getCountByType(),
+  );
+
+  ipcMain.handle("desktop:db:get-token-analytics", () =>
+    agentDatabase.dashboard.getTokenAnalytics(),
+  );
+
+  ipcMain.handle("desktop:db:get-agent-hierarchy", (_event, sessionId: unknown) => {
+    const id = coerceDbId(sessionId);
+    if (id === null) return [];
+    return agentDatabase.agents.getBySessionWithChildren(id, agentDatabase.events);
+  });
+
+  ipcMain.handle("desktop:db:get-analytics", () =>
+    agentDatabase.dashboard.getAnalytics(),
+  );
+
+  ipcMain.handle("desktop:db:get-workflow-data", () =>
+    agentDatabase.dashboard.getWorkflowData(),
+  );
+}
+
+function unregisterDesignSystemDbIpcHandlers(): void {
+  for (const channel of DESIGN_SYSTEM_DB_IPC_CHANNELS) {
+    ipcMain.removeHandler(channel);
+  }
+}
diff --git a/apps/desktop/src/main/agent-dashboard-mode.ts b/apps/desktop/src/main/agent-dashboard-mode.ts
new file mode 100644
index 00000000..c0d0f2ec
--- /dev/null
+++ b/apps/desktop/src/main/agent-dashboard-mode.ts
@@ -0,0 +1,42 @@
+import type { SettingsStore } from "./settings-store.js";
+
+/**
+ * Labs flag that opts into the in-process design-system Agent Dashboard when
+ * the broader Agent Monitor feature remains enabled.
+ */
+export const AGENT_DASHBOARD_DESIGN_SYSTEM_FLAG =
+  "agentDashboardDesignSystemEnabled";
+
+/**
+ * Boot-owned dashboard runtime mode. Only `design-system` may load the
+ * in-process database, app:// renderer, design preload, listeners, or collectors.
+ */
+export type AgentDashboardMode = "disabled" | "legacy" | "design-system";
+
+/**
+ * Resolve the boot-owned Agent Dashboard mode from persisted feature flags.
+ *
+ * The design-system flag is strict on purpose: only the literal boolean `true`
+ * opts into the in-process runtime. Missing, false, or tampered non-boolean
+ * values keep the default legacy sidecar experience.
+ */
+export function resolveAgentDashboardMode(
+  settingsStore: Pick<SettingsStore, "getAgentMonitorEnabled" | "getFlag">,
+): AgentDashboardMode {
+  if (!settingsStore.getAgentMonitorEnabled()) {
+    return "disabled";
+  }
+
+  return settingsStore.getFlag(AGENT_DASHBOARD_DESIGN_SYSTEM_FLAG) === true
+    ? "design-system"
+    : "legacy";
+}
+
+/**
+ * Narrow an already-resolved dashboard mode to the design-system runtime branch.
+ */
+export function isDesignSystemDashboardMode(
+  mode: AgentDashboardMode,
+): mode is "design-system" {
+  return mode === "design-system";
+}
diff --git a/apps/desktop/src/main/agent-monitor-hooks-core.ts b/apps/desktop/src/main/agent-monitor-hooks-core.ts
new file mode 100644
index 00000000..85c6752c
--- /dev/null
+++ b/apps/desktop/src/main/agent-monitor-hooks-core.ts
@@ -0,0 +1,259 @@
+// Electron-free core of the Agent Monitor hook installer. Path resolution,
+// `app.getPath()`, `electron-store`, and the `gatewayLog` logger live in the
+// outer `agent-monitor-hooks.ts` shell; this module owns only the
+// settings-file manipulation, hook-entry generation, and idempotent merge
+// logic so the behavior can be exercised under `tsx --test` without an
+// Electron runtime.
+//
+// FEA-1444: extended with Codex hook handling. The Codex path mirrors the
+// Claude path: distinct handler filename, distinct settings file, separate
+// idempotency predicate. Both file targets are JSON with the same outer
+// `{ hooks: { <EventName>: [{ matcher?, hooks: [{ type, command }] }] } }`
+// shape (Codex's experimental hook config gated by `[features].codex_hooks`).
+
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  writeFileSync,
+} from "node:fs";
+import path from "node:path";
+
+// Distinct handler filenames let isClaudeEntry / isCodexEntry coexist safely
+// even if a future bug ever co-mingles entries in one settings file.
+export const CLAUDE_HANDLER_FILENAME = "hook-handler.js";
+export const CODEX_HANDLER_FILENAME = "codex-hook-handler.js";
+
+// Mirrors the upstream install-hooks.js contract: same event set, same
+// matcher rule. Re-verify on every upstream bump.
+export const HOOKS_WITH_MATCHER = [
+  "PreToolUse",
+  "PostToolUse",
+  "Stop",
+  "SubagentStop",
+  "Notification",
+] as const;
+export const HOOKS_WITHOUT_MATCHER = [
+  "SessionStart",
+  "SessionEnd",
+  "UserPromptSubmit",
+] as const;
+export const HOOK_TYPES = [...HOOKS_WITH_MATCHER, ...HOOKS_WITHOUT_MATCHER];
+
+// FEA-1444: Codex hook surface is narrower than Claude's (no SessionEnd,
+// SubagentStop, or Notification today). Per Daniel Levesque's reference
+// writer in closedloop-ai/workflow `telemetry/codex-hook-writer.js`.
+// Re-verify on Codex version bumps.
+export const CODEX_HOOKS_WITH_MATCHER = [
+  "PreToolUse",
+  "PostToolUse",
+] as const;
+export const CODEX_HOOKS_WITHOUT_MATCHER = [
+  "SessionStart",
+  "UserPromptSubmit",
+  "Stop",
+] as const;
+export const CODEX_HOOK_TYPES = [
+  ...CODEX_HOOKS_WITH_MATCHER,
+  ...CODEX_HOOKS_WITHOUT_MATCHER,
+];
+// Codex `SessionStart` accepts a matcher distinguishing fresh startup from
+// a resumed session; the other events do not honor matchers.
+export const CODEX_SESSION_START_MATCHER = "startup|resume";
+
+/**
+ * Filename-boundary check: matches a path token equal to `filename` preceded
+ * by a path separator. Prevents `codex-hook-handler.js` from matching the
+ * `hook-handler.js` probe (and vice versa).
+ */
+function commandReferences(entry: unknown, filename: string): boolean {
+  if (!entry || typeof entry !== "object") {
+    return false;
+  }
+  const e = entry as {
+    command?: unknown;
+    hooks?: Array<{ command?: unknown }>;
+  };
+  const haystack = (s: unknown) =>
+    typeof s === "string" &&
+    (s.includes(`/${filename}"`) ||
+      s.includes(`/${filename} `) ||
+      s.includes(`\\${filename}"`) ||
+      s.includes(`\\${filename} `));
+  if (haystack(e.command)) {
+    return true;
+  }
+  if (Array.isArray(e.hooks)) {
+    return e.hooks.some((h) => haystack(h?.command));
+  }
+  return false;
+}
+
+export function isClaudeEntry(entry: unknown): boolean {
+  return commandReferences(entry, CLAUDE_HANDLER_FILENAME);
+}
+
+export function isCodexEntry(entry: unknown): boolean {
+  return commandReferences(entry, CODEX_HANDLER_FILENAME);
+}
+
+/**
+ * Returns the shell-ready hook command. Caller supplies `execPath` (typically
+ * `process.execPath`) so the command spawns the Electron binary as Node via
+ * `ELECTRON_RUN_AS_NODE=1` — no system `node` is required.
+ */
+export function makeHookCommand(
+  execPath: string,
+  handler: string,
+  hookType: string,
+): string {
+  return `ELECTRON_RUN_AS_NODE=1 "${execPath}" "${handler}" ${JSON.stringify(hookType)}`;
+}
+
+export function makeClaudeHookEntry(
+  execPath: string,
+  handler: string,
+  hookType: string,
+): Record<string, unknown> {
+  const entry: Record<string, unknown> = {
+    hooks: [
+      { type: "command", command: makeHookCommand(execPath, handler, hookType) },
+    ],
+  };
+  if ((HOOKS_WITH_MATCHER as readonly string[]).includes(hookType)) {
+    entry.matcher = "*";
+  }
+  return entry;
+}
+
+export function makeCodexHookEntry(
+  execPath: string,
+  handler: string,
+  hookType: string,
+): Record<string, unknown> {
+  const entry: Record<string, unknown> = {
+    hooks: [
+      { type: "command", command: makeHookCommand(execPath, handler, hookType) },
+    ],
+  };
+  if ((CODEX_HOOKS_WITH_MATCHER as readonly string[]).includes(hookType)) {
+    entry.matcher = "*";
+  } else if (hookType === "SessionStart") {
+    entry.matcher = CODEX_SESSION_START_MATCHER;
+  }
+  return entry;
+}
+
+export function readSettingsFile(file: string): Record<string, unknown> {
+  if (!existsSync(file)) {
+    return {};
+  }
+  return JSON.parse(readFileSync(file, "utf8")) as Record<string, unknown>;
+}
+
+/**
+ * Atomic-rename write: stage to a sibling `.tmp` file, then `rename` so a
+ * crash mid-write never leaves a half-written settings file the user's
+ * tooling has to recover from.
+ */
+export function writeSettingsFile(file: string, settings: unknown): void {
+  const dir = path.dirname(file);
+  mkdirSync(dir, { recursive: true });
+  const tempFile = path.join(
+    dir,
+    `${path.basename(file)}.${process.pid}.${Date.now()}.tmp`,
+  );
+  writeFileSync(tempFile, JSON.stringify(settings, null, 2) + "\n", "utf8");
+  renameSync(tempFile, file);
+}
+
+export interface ApplyHooksInput {
+  /** Path to the JSON settings file to mutate. */
+  file: string;
+  /** Hook event names to install. */
+  hookTypes: readonly string[];
+  /** Identity predicate: returns true for an entry owned by this installer. */
+  isOurEntry: (entry: unknown) => boolean;
+  /** Factory: produce the canonical entry for one hook type. */
+  makeEntry: (hookType: string) => Record<string, unknown>;
+}
+
+/**
+ * Idempotent in-place install: replaces a stale entry of ours (self-heals a
+ * moved handler path) or appends a fresh one. Mirrors upstream
+ * `install-hooks.js`. Returns the number of entries installed plus the
+ * number repaired.
+ */
+export function applyHookInstall(
+  input: ApplyHooksInput,
+): { installed: number; repaired: number } {
+  const settings = readSettingsFile(input.file);
+  const hooks = (settings.hooks ??= {}) as Record<string, unknown[]>;
+  let installed = 0;
+  let repaired = 0;
+
+  for (const hookType of input.hookTypes) {
+    const list = (hooks[hookType] ??= []);
+    const idx = list.findIndex(input.isOurEntry);
+    const entry = input.makeEntry(hookType);
+    if (idx >= 0) {
+      list[idx] = entry;
+      repaired += 1;
+    } else {
+      list.push(entry);
+      installed += 1;
+    }
+  }
+  writeSettingsFile(input.file, settings);
+  return { installed, repaired };
+}
+
+export interface ApplyUninstallInput {
+  /** Path to the JSON settings file to clean. No-op if missing. */
+  file: string;
+  /** Identity predicate: returns true for an entry owned by this installer. */
+  isOurEntry: (entry: unknown) => boolean;
+}
+
+/**
+ * Removes only entries identified by `isOurEntry`. Preserves other entries.
+ * Deletes empty per-event arrays and the outer `hooks` block when nothing
+ * remains, so the file stays clean.
+ */
+export function applyHookUninstall(input: ApplyUninstallInput): {
+  removed: number;
+} {
+  if (!existsSync(input.file)) {
+    return { removed: 0 };
+  }
+  const settings = readSettingsFile(input.file);
+  const hooks = settings.hooks as Record<string, unknown[]> | undefined;
+  if (!hooks) {
+    return { removed: 0 };
+  }
+  let removed = 0;
+  for (const hookType of Object.keys(hooks)) {
+    const list = hooks[hookType];
+    if (!Array.isArray(list)) {
+      continue;
+    }
+    const kept = list.filter((e) => {
+      const ours = input.isOurEntry(e);
+      if (ours) {
+        removed += 1;
+      }
+      return !ours;
+    });
+    if (kept.length > 0) {
+      hooks[hookType] = kept;
+    } else {
+      delete hooks[hookType];
+    }
+  }
+  if (Object.keys(hooks).length === 0) {
+    delete settings.hooks;
+  }
+  writeSettingsFile(input.file, settings);
+  return { removed };
+}
diff --git a/apps/desktop/src/main/agent-monitor-hooks.ts b/apps/desktop/src/main/agent-monitor-hooks.ts
index 576a62e1..750a45e1 100644
--- a/apps/desktop/src/main/agent-monitor-hooks.ts
+++ b/apps/desktop/src/main/agent-monitor-hooks.ts
@@ -1,40 +1,33 @@
 import { app } from "electron";
-import {
-  copyFileSync,
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  renameSync,
-  writeFileSync,
-} from "node:fs";
+import { copyFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
 
 import Store from "electron-store";
 
 import { gatewayLog } from "./gateway-logger.js";
-import { resolveAgentMonitorPaths } from "./agent-monitor-path.js";
+import { resolveAgentMonitorHookPaths } from "./agent-monitor-path.js";
+import {
+  applyHookInstall,
+  applyHookUninstall,
+  CODEX_HOOK_TYPES,
+  HOOK_TYPES,
+  isClaudeEntry,
+  isCodexEntry,
+  makeClaudeHookEntry,
+  makeCodexHookEntry,
+} from "./agent-monitor-hooks-core.js";
 
 const TAG = "agent-monitor-hooks";
 
-// Mirrors the upstream install-hooks.js contract: same event set, same matcher
-// rule. Re-verify on every upstream bump.
-const HOOKS_WITH_MATCHER = [
-  "PreToolUse",
-  "PostToolUse",
-  "Stop",
-  "SubagentStop",
-  "Notification",
-] as const;
-const HOOKS_WITHOUT_MATCHER = [
-  "SessionStart",
-  "SessionEnd",
-  "UserPromptSubmit",
-] as const;
-const HOOK_TYPES = [...HOOKS_WITH_MATCHER, ...HOOKS_WITHOUT_MATCHER];
-
 interface HooksFlagStore {
   enabled: boolean;
+  // FEA-1444: opt-in flag for installing Codex hooks alongside Claude hooks.
+  // Defaults false — Codex telemetry already flows via the rollout-tail
+  // watcher (FEA-1189), and enabling hooks without event-level dedup against
+  // that watcher would double-count. Future work tracks the dedup; until then
+  // this stays opt-in so existing users see no behavior change.
+  codexOptIn?: boolean;
 }
 
 let flagStore: Store<HooksFlagStore> | null = null;
@@ -47,35 +40,38 @@ export function isAgentMonitorHooksEnabled(): boolean {
   return store().get("enabled", false) === true;
 }
 
-// Matches install-hooks.js / uninstall-hooks.js isOurEntry: any hook whose
-// command references hook-handler.js. Keeps install/uninstall symmetric with
-// the generated CLI scripts.
-function isOurEntry(entry: unknown): boolean {
-  if (!entry || typeof entry !== "object") {
-    return false;
-  }
-  const e = entry as {
-    command?: unknown;
-    hooks?: Array<{ command?: unknown }>;
-  };
-  if (typeof e.command === "string" && e.command.includes("hook-handler.js")) {
-    return true;
-  }
-  if (Array.isArray(e.hooks)) {
-    return e.hooks.some(
-      (h) => typeof h?.command === "string" && h.command.includes("hook-handler.js"),
-    );
-  }
-  return false;
+export function isAgentMonitorCodexHooksOptIn(): boolean {
+  return store().get("codexOptIn", false) === true;
 }
 
-// Same resolution as agent-dashboard/server/lib/claude-home.js:
+// Same resolution as collectors/claude/claude-home.ts:
 // CLAUDE_HOME || ~/.claude, then settings.json.
 function claudeSettingsPath(): string {
   const home = process.env.CLAUDE_HOME || path.join(os.homedir(), ".claude");
   return path.join(home, "settings.json");
 }
 
+// Mirrors scripts/agent-monitor-codex/codex-home.js getCodexHome: honor
+// $CODEX_HOME first (some setups use a comma-separated list whose first entry
+// is the active root), fall back to ~/.codex.
+function codexHomeDir(): string {
+  const raw = process.env.CODEX_HOME;
+  if (raw && raw.trim()) {
+    const first = raw.split(",")[0]?.trim();
+    if (first) {
+      return first.replace(/^~(?=\/)/, os.homedir());
+    }
+  }
+  return path.join(os.homedir(), ".codex");
+}
+
+// Codex's experimental hook config (gated by `[features].codex_hooks = true`
+// in Codex's own `config.toml`) lives in `$CODEX_HOME/hooks.json`. The JSON
+// shape mirrors Claude Code's `settings.json` hooks block.
+function codexHooksPath(): string {
+  return path.join(codexHomeDir(), "hooks.json");
+}
+
 // A zero-dependency single file (pure node:http). Copying it to userData makes
 // the installed hook command independent of the .app location (survives app
 // move/rename and in-place updates).
@@ -83,13 +79,19 @@ function userDataHandlerPath(): string {
   return path.join(app.getPath("userData"), "agent-monitor", "hook-handler.js");
 }
 
+function userDataCodexHandlerPath(): string {
+  return path.join(
+    app.getPath("userData"),
+    "agent-monitor",
+    "codex-hook-handler.js",
+  );
+}
+
 function refreshHandlerCopy(): string {
-  const { scriptsDir } = resolveAgentMonitorPaths();
-  const src = path.join(scriptsDir, "hook-handler.js");
+  const { hooksDir } = resolveAgentMonitorHookPaths();
+  const src = path.join(hooksDir, "hook-handler.js");
   if (!existsSync(src)) {
-    throw new Error(
-      `hook-handler.js not found at ${src} — run \`pnpm -C apps/desktop build:agent-monitor\``,
-    );
+    throw new Error(`hook-handler.js not found at ${src}`);
   }
   const dest = userDataHandlerPath();
   mkdirSync(path.dirname(dest), { recursive: true });
@@ -100,64 +102,33 @@ function refreshHandlerCopy(): string {
   return dest;
 }
 
-function makeHookCommand(handler: string, hookType: string): string {
-  // Executed by Claude Code via the shell. Use the Electron binary as Node
-  // (ELECTRON_RUN_AS_NODE) so no system `node` is required. Port defaults to
-  // 4820 inside hook-handler.js, which matches our fixed sidecar port — so no
-  // per-hook env is needed (avoids depending on Claude Code honoring it).
-  return `ELECTRON_RUN_AS_NODE=1 "${process.execPath}" "${handler}" ${JSON.stringify(hookType)}`;
-}
-
-function makeHookEntry(
-  handler: string,
-  hookType: string,
-): Record<string, unknown> {
-  const entry: Record<string, unknown> = {
-    hooks: [{ type: "command", command: makeHookCommand(handler, hookType) }],
-  };
-  if ((HOOKS_WITH_MATCHER as readonly string[]).includes(hookType)) {
-    entry.matcher = "*";
+// FEA-1444 / FEA-1503: the Codex wrapper handler is first-party and ships under
+// `apps/desktop/resources/hooks/` (packaged: unpacked `extraResources/hooks`),
+// resolved via the same hooksDir as the Claude handler.
+function refreshCodexHandlerCopy(): string {
+  const { hooksDir } = resolveAgentMonitorHookPaths();
+  const src = path.join(hooksDir, "codex-hook-handler.js");
+  if (!existsSync(src)) {
+    throw new Error(`codex-hook-handler.js not found at ${src}`);
   }
-  return entry;
-}
-
-function readSettings(file: string): Record<string, unknown> {
-  if (!existsSync(file)) {
-    return {};
+  const dest = userDataCodexHandlerPath();
+  mkdirSync(path.dirname(dest), { recursive: true });
+  const srcContent = readFileSync(src);
+  if (!existsSync(dest) || !readFileSync(dest).equals(srcContent)) {
+    copyFileSync(src, dest);
   }
-  return JSON.parse(readFileSync(file, "utf8")) as Record<string, unknown>;
-}
-
-function writeSettings(file: string, settings: unknown): void {
-  const dir = path.dirname(file);
-  mkdirSync(dir, { recursive: true });
-  const tempFile = path.join(
-    dir,
-    `${path.basename(file)}.${process.pid}.${Date.now()}.tmp`,
-  );
-  writeFileSync(tempFile, JSON.stringify(settings, null, 2) + "\n", "utf8");
-  renameSync(tempFile, file);
+  return dest;
 }
 
-// Idempotent: replaces a stale entry of ours in place (self-heals a moved
-// handler path), otherwise appends. Mirrors upstream install-hooks.js.
 function installHooks(): void {
   const handler = refreshHandlerCopy();
-  const file = claudeSettingsPath();
-  const settings = readSettings(file);
-  const hooks = (settings.hooks ??= {}) as Record<string, unknown[]>;
-
-  for (const hookType of HOOK_TYPES) {
-    const list = (hooks[hookType] ??= []);
-    const idx = list.findIndex(isOurEntry);
-    const entry = makeHookEntry(handler, hookType);
-    if (idx >= 0) {
-      list[idx] = entry;
-    } else {
-      list.push(entry);
-    }
-  }
-  writeSettings(file, settings);
+  applyHookInstall({
+    file: claudeSettingsPath(),
+    hookTypes: HOOK_TYPES,
+    isOurEntry: isClaudeEntry,
+    makeEntry: (hookType) =>
+      makeClaudeHookEntry(process.execPath, handler, hookType),
+  });
   gatewayLog.info(
     TAG,
     `installed/repaired ${HOOK_TYPES.length} Claude Code hooks -> ${handler}`,
@@ -165,39 +136,44 @@ function installHooks(): void {
 }
 
 function uninstallHooks(): void {
-  const file = claudeSettingsPath();
-  if (!existsSync(file)) {
-    return;
-  }
-  const settings = readSettings(file);
-  const hooks = settings.hooks as Record<string, unknown[]> | undefined;
-  if (!hooks) {
-    return;
-  }
-  let removed = 0;
-  for (const hookType of Object.keys(hooks)) {
-    const list = hooks[hookType];
-    if (!Array.isArray(list)) {
-      continue;
-    }
-    const kept = list.filter((e) => {
-      const ours = isOurEntry(e);
-      if (ours) {
-        removed += 1;
-      }
-      return !ours;
-    });
-    if (kept.length > 0) {
-      hooks[hookType] = kept;
-    } else {
-      delete hooks[hookType];
-    }
-  }
-  if (Object.keys(hooks).length === 0) {
-    delete settings.hooks;
-  }
-  writeSettings(file, settings);
-  gatewayLog.info(TAG, `removed ${removed} Claude Code hook entr${removed === 1 ? "y" : "ies"}`);
+  const result = applyHookUninstall({
+    file: claudeSettingsPath(),
+    isOurEntry: isClaudeEntry,
+  });
+  gatewayLog.info(
+    TAG,
+    `removed ${result.removed} Claude Code hook entr${result.removed === 1 ? "y" : "ies"}`,
+  );
+}
+
+// FEA-1444: install Codex hooks alongside Claude hooks. Same idempotency +
+// self-heal semantics as installHooks(), targeting `$CODEX_HOME/hooks.json`
+// and the Codex wrapper handler. Caller is responsible for gating on
+// `isAgentMonitorCodexHooksOptIn()`.
+function installCodexHooks(): void {
+  const handler = refreshCodexHandlerCopy();
+  applyHookInstall({
+    file: codexHooksPath(),
+    hookTypes: CODEX_HOOK_TYPES,
+    isOurEntry: isCodexEntry,
+    makeEntry: (hookType) =>
+      makeCodexHookEntry(process.execPath, handler, hookType),
+  });
+  gatewayLog.info(
+    TAG,
+    `installed/repaired ${CODEX_HOOK_TYPES.length} Codex hooks -> ${handler}`,
+  );
+}
+
+function uninstallCodexHooks(): void {
+  const result = applyHookUninstall({
+    file: codexHooksPath(),
+    isOurEntry: isCodexEntry,
+  });
+  gatewayLog.info(
+    TAG,
+    `removed ${result.removed} Codex hook entr${result.removed === 1 ? "y" : "ies"}`,
+  );
 }
 
 export interface AgentMonitorHooksResult {
@@ -212,8 +188,18 @@ export function setAgentMonitorHooksEnabled(
   try {
     if (enabled) {
       installHooks();
+      // FEA-1444: when the user previously opted into Codex hooks, install
+      // those too. If they have not opted in, ensure no stale Codex entries
+      // remain (a previous opt-in followed by opt-out, then re-enable, must
+      // not silently re-install Codex hooks).
+      if (isAgentMonitorCodexHooksOptIn()) {
+        installCodexHooks();
+      } else {
+        uninstallCodexHooks();
+      }
     } else {
       uninstallHooks();
+      uninstallCodexHooks();
     }
     store().set("enabled", enabled);
     return { ok: true, enabled };
@@ -227,6 +213,49 @@ export function setAgentMonitorHooksEnabled(
   }
 }
 
+// FEA-1444: flip the Codex opt-in flag. When the master `enabled` flag is
+// already on, immediately install/uninstall the Codex hook entries to reflect
+// the new opt-in state.
+//
+// Currently exported but not yet wired to any IPC handler — the renderer
+// toggle is a separate follow-up ticket. Until then this is reachable only
+// from tests / dev consoles. Do not remove: removing this would make
+// codexOptIn permanently false in production builds.
+//
+// Persist-then-apply order is intentional: a side-effect failure (e.g.,
+// `~/.codex/hooks.json` locked or malformed) must not silently lose the
+// user's intent. `syncAgentMonitorHooksOnBoot` re-applies from the
+// persisted intent at next launch, so the eventual state remains
+// consistent with what the user asked for. See CLAUDE.md learned pattern:
+// "Setting toggles must update persisted state and in-memory side effects
+// together."
+export function setAgentMonitorCodexHooksOptIn(
+  optIn: boolean,
+): AgentMonitorHooksResult {
+  store().set("codexOptIn", optIn);
+  try {
+    if (isAgentMonitorHooksEnabled()) {
+      if (optIn) {
+        installCodexHooks();
+      } else {
+        uninstallCodexHooks();
+      }
+    }
+    return { ok: true, enabled: isAgentMonitorHooksEnabled() };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    gatewayLog.error(
+      TAG,
+      `failed to apply Codex hook opt-in side effect (intent persisted as ${optIn}): ${message}`,
+    );
+    return {
+      ok: false,
+      enabled: isAgentMonitorHooksEnabled(),
+      error: message,
+    };
+  }
+}
+
 // Boot-time repair: if the user previously opted in, re-copy the handler and
 // re-write the entries so a moved/updated .app self-heals. No-op when disabled
 // (and never throws into boot).
@@ -242,4 +271,23 @@ export function syncAgentMonitorHooksOnBoot(): void {
       `boot hook repair failed: ${error instanceof Error ? error.message : String(error)}`,
     );
   }
+  // FEA-1444: reconcile Codex hook state with the persisted intent. When
+  // opted in, self-heal the install (mirrors the Claude repair above).
+  // When opted out, remove any stale entries that may linger from a prior
+  // opt-in whose uninstall failed at the file layer (setAgentMonitorCodex-
+  // HooksOptIn persists intent before applying side effects). Independent
+  // try/catch so a Codex-side failure cannot suppress the Claude-side
+  // repair logging above.
+  try {
+    if (isAgentMonitorCodexHooksOptIn()) {
+      installCodexHooks();
+    } else {
+      uninstallCodexHooks();
+    }
+  } catch (error) {
+    gatewayLog.warn(
+      TAG,
+      `boot Codex hook reconcile failed: ${error instanceof Error ? error.message : String(error)}`,
+    );
+  }
 }
diff --git a/apps/desktop/src/main/agent-monitor-listener.ts b/apps/desktop/src/main/agent-monitor-listener.ts
new file mode 100644
index 00000000..f40f1b52
--- /dev/null
+++ b/apps/desktop/src/main/agent-monitor-listener.ts
@@ -0,0 +1,232 @@
+import http from "node:http";
+import type { AddressInfo } from "node:net";
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { z } from "zod";
+import { AGENT_MONITOR_PORT } from "../shared/contracts.js";
+import { isSessionInSandbox } from "./agent-session-sync-service.js";
+import type { createLifecycle, HookData } from "./database/lifecycle.js";
+
+// CLOSEDLOOP-TICKET FEA-1500: remove legacy HTTP hook listener on 4820 after
+// transport migration (FEA-1497 breaking-change discipline contract #1). The hook
+// commands baked into ~/.claude/settings.json and ~/.codex/hooks.json POST to
+// 127.0.0.1:4820/api/hooks/event; this in-process listener replaces the vendor
+// sidecar that previously owned that port. The contract (port, path, payload
+// envelope) MUST stay backward-compatible until all installs self-heal to a
+// lighter transport.
+
+const HOST = "127.0.0.1";
+const MAX_BODY_BYTES = 8 * 1024 * 1024; // hook payloads (incl. large tool_input) cap
+const CLAUDE_HOOK_EVENT_PATH = "/api/hooks/event";
+const CODEX_HOOK_EVENT_PATH = "/api/hooks/codex/event";
+const PROVIDER_HINT_FIELD = "__provider";
+type HookHarness = "claude" | "codex";
+
+/** The `{ hook_type, data }` envelope every hook handler POSTs. */
+const HookEnvelopeSchema = z.object({
+  hook_type: z.string(),
+  data: z.record(z.string(), z.unknown()).optional(),
+});
+
+export interface AgentHookListenerOptions {
+  /** The lifecycle processor that owns all DB writes. */
+  lifecycle: ReturnType<typeof createLifecycle>;
+  /** FEA-1407 sandbox base directory (empty string ⇒ capture nothing). */
+  getSandboxBaseDirectory: () => string;
+  /** Key-free diagnostic sink (gatewayLog). */
+  log?: (message: string) => void;
+  /**
+   * Called when the listener cannot bind its port (e.g. EADDRINUSE from a stale
+   * process). Lets the host surface a degraded indicator; capture stays off for
+   * the session rather than crashing boot.
+   */
+  onBindError?: (reason: string) => void;
+  /** Override for tests; defaults to AGENT_MONITOR_PORT (4820). */
+  port?: number;
+}
+
+/**
+ * First-party in-process replacement for the vendor agent-monitor sidecar's
+ * HTTP receiver. Binds `127.0.0.1:4820` and accepts the unchanged hook payload
+ * contract:
+ *   - `GET  /api/health`            → 200 `{ ok: true }`
+ *   - `POST /api/hooks/event`       → Claude `{ hook_type, data }`
+ *   - `POST /api/hooks/codex/event` → Codex `{ hook_type, data }`
+ *
+ * Every request responds 200 fail-soft so a hook never blocks an agent turn.
+ * FEA-1407 sandbox gating is enforced BEFORE any DB write — with no sandbox
+ * configured, nothing is captured (fail-closed; do not ungate — defense in
+ * depth so out-of-sandbox sessions never enter the local DB). Provider
+ * attribution is route-owned; payload-level provider hints are rejected as
+ * spoofable data before lifecycle writes or live DB-change emits.
+ */
+export class AgentHookListener {
+  private readonly options: AgentHookListenerOptions;
+  private readonly port: number;
+  private boundPort: number | null = null;
+  private server: http.Server | null = null;
+  private ready = false;
+
+  constructor(options: AgentHookListenerOptions) {
+    this.options = options;
+    this.port = options.port ?? AGENT_MONITOR_PORT;
+  }
+
+  isReady(): boolean {
+    return this.ready;
+  }
+
+  getUrl(): string | null {
+    return this.ready && this.boundPort != null
+      ? `http://${HOST}:${this.boundPort}`
+      : null;
+  }
+
+  /**
+   * Start the listener. Fire-and-forget: a bind failure (e.g. EADDRINUSE from a
+   * stale process) is logged and degrades to "no listener" rather than blocking
+   * boot or throwing.
+   */
+  start(): Promise<void> {
+    if (this.server) {
+      return Promise.resolve();
+    }
+    return new Promise<void>((resolve) => {
+      const server = http.createServer((req, res) => {
+        this.handleRequest(req, res);
+      });
+      server.on("error", (error: NodeJS.ErrnoException) => {
+        this.ready = false;
+        const reason =
+          error.code === "EADDRINUSE"
+            ? `Agent capture port ${this.port} is already in use; agent monitoring is off this session.`
+            : `Agent hook listener error: ${error.message}`;
+        this.log(reason);
+        this.options.onBindError?.(reason);
+        resolve();
+      });
+      server.listen(this.port, HOST, () => {
+        const address = server.address() as AddressInfo | null;
+        this.boundPort = address?.port ?? this.port;
+        this.ready = true;
+        this.log(`agent hook listener ready on http://${HOST}:${this.boundPort}`);
+        resolve();
+      });
+      this.server = server;
+    });
+  }
+
+  stop(): Promise<void> {
+    const server = this.server;
+    this.server = null;
+    this.ready = false;
+    if (!server) {
+      return Promise.resolve();
+    }
+    return new Promise<void>((resolve) => {
+      server.close(() => resolve());
+    });
+  }
+
+  private log(message: string): void {
+    this.options.log?.(message);
+  }
+
+  private handleRequest(req: IncomingMessage, res: ServerResponse): void {
+    if (req.method === "GET" && req.url === "/api/health") {
+      this.json(res, 200, { ok: true });
+      return;
+    }
+    if (req.method === "POST" && req.url === CLAUDE_HOOK_EVENT_PATH) {
+      this.handleHookEvent(req, res, "claude");
+      return;
+    }
+    if (req.method === "POST" && req.url === CODEX_HOOK_EVENT_PATH) {
+      this.handleHookEvent(req, res, "codex");
+      return;
+    }
+    this.json(res, 404, { ok: false, error: "not found" });
+  }
+
+  private handleHookEvent(
+    req: IncomingMessage,
+    res: ServerResponse,
+    harness: HookHarness,
+  ): void {
+    readBody(req, MAX_BODY_BYTES)
+      .then((body) => {
+        try {
+          const parsed = HookEnvelopeSchema.safeParse(JSON.parse(body));
+          if (!parsed.success) {
+            // Unknown shape: ack so the hook does not block, but do not write.
+            this.json(res, 200, { ok: true, skipped: "invalid" });
+            return;
+          }
+          const { hook_type: hookType, data: rawData } = parsed.data;
+          const data = (rawData ?? {}) as HookData;
+
+          // Provider selection must not be attacker-controlled hook JSON. Codex
+          // attribution comes from CODEX_HOOK_EVENT_PATH, so any payload-level
+          // provider hint is spoofable and rejected before lifecycle writes.
+          if (Object.prototype.hasOwnProperty.call(data, PROVIDER_HINT_FIELD)) {
+            this.json(res, 200, { ok: true, skipped: "invalid-provider-hint" });
+            return;
+          }
+
+          // FEA-1407: gate LOCAL capture on the sandbox BEFORE any write. Empty
+          // sandbox ⇒ isSessionInSandbox returns false ⇒ nothing is captured.
+          const sandboxBase = this.options.getSandboxBaseDirectory();
+          const cwd = typeof data.cwd === "string" ? data.cwd : null;
+          if (!isSessionInSandbox(cwd, sandboxBase)) {
+            this.json(res, 200, { ok: true, skipped: "out-of-sandbox" });
+            return;
+          }
+
+          this.options.lifecycle.processEvent(hookType, data, harness);
+          this.json(res, 200, { ok: true });
+        } catch (error) {
+          // Malformed JSON or unexpected error: ack 200 (fail-soft) + log.
+          this.log(
+            `agent hook listener: failed to handle event: ${error instanceof Error ? error.message : String(error)}`,
+          );
+          this.json(res, 200, { ok: false });
+        }
+      })
+      .catch(() => {
+        this.json(res, 200, { ok: false });
+      });
+  }
+
+  private json(res: ServerResponse, status: number, payload: unknown): void {
+    const body = JSON.stringify(payload);
+    res.writeHead(status, { "Content-Type": "application/json" });
+    res.end(body);
+  }
+}
+
+/** Read a request body to a string, rejecting payloads over `maxBytes`. */
+function readBody(req: IncomingMessage, maxBytes: number): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const chunks: Buffer[] = [];
+    let size = 0;
+    let tooLarge = false;
+    req.on("data", (chunk: Buffer) => {
+      size += chunk.length;
+      if (size > maxBytes) {
+        tooLarge = true;
+        chunks.length = 0;
+        return;
+      }
+      if (!tooLarge) {
+        chunks.push(chunk);
+      }
+    });
+    req.on("end", () => {
+      if (tooLarge) {
+        reject(new Error("payload too large"));
+        return;
+      }
+      resolve(Buffer.concat(chunks).toString("utf-8"));
+    });
+    req.on("error", reject);
+  });
+}
diff --git a/apps/desktop/src/main/agent-monitor-path.ts b/apps/desktop/src/main/agent-monitor-path.ts
index 1008b6ab..045806da 100644
--- a/apps/desktop/src/main/agent-monitor-path.ts
+++ b/apps/desktop/src/main/agent-monitor-path.ts
@@ -9,17 +9,24 @@ const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const TAG = "agent-monitor-path";
 
 export interface AgentMonitorPaths {
-  // Directory containing server/, client/dist/, scripts/, package.json.
+  /** Directory containing server/, client/dist/, scripts/, package.json. */
   rootDir: string;
-  // The Node CLI entry to spawn (the Express server).
+  /** The Node CLI entry to spawn (the Express server). */
   entryFile: string;
-  // Directory holding install-hooks.js / hook-handler.js / uninstall-hooks.js.
+  /** Directory holding install-hooks.js / hook-handler.js / uninstall-hooks.js. */
   scriptsDir: string;
 }
 
-// Packaged builds read from the unpacked extraResources copy. Development
-// builds read from the generated runtime tree that build-agent-monitor.mjs
-// materializes from the pnpm-managed upstream packages.
+export interface AgentMonitorHookPaths {
+  /** Directory holding the first-party hook-handler.js + codex-hook-handler.js. */
+  hooksDir: string;
+}
+
+/**
+ * Resolve the generated legacy sidecar runtime tree. Packaged builds read the
+ * unpacked `extraResources/agent-monitor` copy; development builds read the
+ * tree materialized by scripts/build-agent-monitor.mjs.
+ */
 export function resolveAgentMonitorPaths(): AgentMonitorPaths {
   const rootDir = resolveRootDir();
   return {
@@ -29,6 +36,17 @@ export function resolveAgentMonitorPaths(): AgentMonitorPaths {
   };
 }
 
+/**
+ * Resolve the directory holding the first-party hook handler scripts (FEA-1503).
+ * Packaged builds read the unpacked `extraResources/hooks` copy; development
+ * builds read them from `apps/desktop/resources/hooks`. The handlers are copied
+ * into userData at install time by `agent-monitor-hooks.ts`, so the installed hook
+ * command is independent of the .app location.
+ */
+export function resolveAgentMonitorHookPaths(): AgentMonitorHookPaths {
+  return { hooksDir: resolveHooksDir() };
+}
+
 function resolveRootDir(): string {
   if (app.isPackaged) {
     // electron-builder.yml extraResources: `to: agent-monitor`.
@@ -52,3 +70,27 @@ function resolveRootDir(): string {
   );
   return candidates[0];
 }
+
+function resolveHooksDir(): string {
+  if (app.isPackaged) {
+    // electron-builder.yml extraResources: `to: hooks`.
+    return path.join(process.resourcesPath, "hooks");
+  }
+
+  const cwd = process.cwd();
+  const candidates = [
+    path.join(cwd, "resources", "hooks"), // launched from apps/desktop
+    path.join(cwd, "apps", "desktop", "resources", "hooks"), // repo root
+    path.join(__dirname, "..", "..", "resources", "hooks"), // dist/main -> app
+  ];
+  for (const candidate of candidates) {
+    if (existsSync(path.join(candidate, "hook-handler.js"))) {
+      return candidate;
+    }
+  }
+  gatewayLog.warn(
+    TAG,
+    `unable to locate hook handler scripts; defaulting to ${candidates[0]}`,
+  );
+  return candidates[0];
+}
diff --git a/apps/desktop/src/main/agent-session-sync-service.ts b/apps/desktop/src/main/agent-session-sync-service.ts
index 752628a4..969fe3b4 100644
--- a/apps/desktop/src/main/agent-session-sync-service.ts
+++ b/apps/desktop/src/main/agent-session-sync-service.ts
@@ -133,6 +133,13 @@ export interface AgentSessionSyncServiceOptions {
   getSandboxBaseDirectory?: () => string;
   sendBatch: (batch: AgentSessionSyncBatch) => Promise<DesktopAgentSessionsAck>;
   getUserDataPath?: () => string;
+  /**
+   * The optional design-system in-process DB connection. When provided, the
+   * service reads through it (no per-cycle open/close, no path resolution, no
+   * existsSync guard). When omitted or null, the service falls back to the
+   * legacy sidecar dashboard.db path from getUserDataPath.
+   */
+  getConnection?: () => DatabaseSync | null;
   onBatchOutcome?: (event: AgentSessionSyncTelemetryEvent) => void;
 }
 
@@ -141,6 +148,8 @@ export class AgentSessionSyncService {
   private timer: NodeJS.Timeout | null = null;
   private started = false;
   private syncing = false;
+  private activeSyncToken: symbol | null = null;
+  private sourceStateGeneration = 0;
   private observedTopUpdatedAt: string | null = null;
   private observedIdsAtTopUpdatedAt = new Set<string>();
   private lastIncrementalBatchAttemptedAtMs = 0;
@@ -191,8 +200,37 @@ export class AgentSessionSyncService {
 
   stop(): void {
     this.started = false;
-    this.syncing = false;
     this.clearTimer();
+    this.resetSourceState();
+  }
+
+  /**
+   * Clear every cursor, queue, retry, dead-letter, pending chunk, and
+   * attribution cache that is derived from the currently selected dashboard
+   * source. Availability disable and source transitions must restart from the
+   * next selected source instead of replaying stale work from the prior one.
+   */
+  resetSourceState(): void {
+    this.sourceStateGeneration += 1;
+    this.activeSyncToken = null;
+    this.syncing = false;
+    this.observedTopUpdatedAt = null;
+    this.observedIdsAtTopUpdatedAt = new Set<string>();
+    this.lastIncrementalBatchAttemptedAtMs = 0;
+    this.featureDisabledForRelaySession = false;
+    this.firstAckReceived = false;
+    this.incrementalQueue = [];
+    this.incrementalQueuedIds.clear();
+    this.backfillQueue = [];
+    this.backfillQueuedIds.clear();
+    this.attributionCache.attributionByCwd.clear();
+    this.attributionCache.launchMetadataRootByCwd.clear();
+    this.attributionCache.repoFullNameByPath.clear();
+    this.timeoutCountById.clear();
+    this.rateLimitedCountById.clear();
+    this.nextRetryAfterMs.clear();
+    this.deadLetteredIds.clear();
+    this.pendingChunks = null;
   }
 
   refresh(): void {
@@ -243,13 +281,20 @@ export class AgentSessionSyncService {
     if (this.syncing || !this.shouldRun()) {
       return;
     }
+    const syncToken = Symbol("agent-session-sync");
+    const sourceStateGeneration = this.sourceStateGeneration;
+    this.activeSyncToken = syncToken;
     this.syncing = true;
 
     try {
-      const dbPath = resolveAgentMonitorDatabasePath(
-        this.options.getUserDataPath?.(),
-      );
-      if (!existsSync(dbPath)) {
+      // The caller owns the dashboard source by mode: design-system injects an
+      // in-process connection, legacy falls back to dashboard.db on disk, and
+      // disabled mode stops this service before it reaches the source lookup.
+      const sharedDb = this.options.getConnection?.() ?? null;
+      const dbPath = sharedDb
+        ? null
+        : resolveAgentMonitorDatabasePath(this.options.getUserDataPath?.());
+      if (dbPath && !existsSync(dbPath)) {
         return;
       }
 
@@ -284,9 +329,11 @@ export class AgentSessionSyncService {
         syncIds = [sessionId];
         // Skip DB access — go straight to send.
       } else {
-        const db = new DatabaseSync(dbPath);
+        const db = sharedDb ?? new DatabaseSync(dbPath!);
         try {
-          db.exec("PRAGMA busy_timeout = 5000");
+          if (!sharedDb) {
+            db.exec("PRAGMA busy_timeout = 5000");
+          }
           this.initializeBackfillQueueIfNeeded(db);
           this.enqueueIncrementalUpdates(db);
 
@@ -426,7 +473,9 @@ export class AgentSessionSyncService {
             sessions,
           };
         } finally {
-          db.close();
+          if (!sharedDb) {
+            db.close();
+          }
         }
       }
 
@@ -435,6 +484,17 @@ export class AgentSessionSyncService {
       }
 
       const ack = await this.options.sendBatch(batch);
+      if (
+        this.activeSyncToken !== syncToken ||
+        this.sourceStateGeneration !== sourceStateGeneration ||
+        !this.started
+      ) {
+        gatewayLog.debug(
+          TAG,
+          "ignoring agent-session batch ack from a stale dashboard source",
+        );
+        return;
+      }
       this.handleBatchAck(syncMode, syncIds, batch.sessionCount, accumulatedBytes, ack);
     } catch (error) {
       gatewayLog.warn(
@@ -442,7 +502,10 @@ export class AgentSessionSyncService {
         `sync failed: ${error instanceof Error ? error.message : String(error)}`,
       );
     } finally {
-      this.syncing = false;
+      if (this.activeSyncToken === syncToken) {
+        this.activeSyncToken = null;
+        this.syncing = false;
+      }
     }
   }
 
@@ -923,10 +986,10 @@ export function loadSyncedSessions(
       SELECT
         session_id,
         model,
-        input_tokens + baseline_input AS input_tokens,
-        output_tokens + baseline_output AS output_tokens,
-        cache_read_tokens + baseline_cache_read AS cache_read_tokens,
-        cache_write_tokens + baseline_cache_write AS cache_write_tokens
+        input_tokens AS input_tokens,
+        output_tokens AS output_tokens,
+        cache_read_tokens AS cache_read_tokens,
+        cache_write_tokens AS cache_write_tokens
       FROM token_usage
       WHERE session_id IN (__IDS__)
       ORDER BY session_id ASC, model ASC
diff --git a/apps/desktop/src/main/app.ts b/apps/desktop/src/main/app.ts
index 2500103a..8fbeba43 100644
--- a/apps/desktop/src/main/app.ts
+++ b/apps/desktop/src/main/app.ts
@@ -74,6 +74,11 @@ import {
 import { SettingsStore, shouldShowManagedKeyHint, type SavedConfigManagedPatch } from "./settings-store.js";
 import { DesktopTray } from "./tray.js";
 import { DesktopWindow } from "./window.js";
+import {
+  type AgentDashboardMode,
+  resolveAgentDashboardMode,
+} from "./agent-dashboard-mode.js";
+import type { AgentDashboardDesignSystemRuntime } from "./agent-dashboard-design-system-runtime.js";
 import { AgentMonitorSidecar } from "./agent-monitor-sidecar.js";
 import {
   AgentSessionSyncService,
@@ -91,12 +96,15 @@ import {
 import {
   loadMeteredUsageRowsFromDisk,
   reconciliationCutoffIso,
+  type MeteredUsageRow,
 } from "./reconciliation-worker.js";
 import { CostReconciliationService } from "./cost-reconciliation-service.js";
 import { ClaudeCodeAnalyticsService } from "./claude-code-analytics-service.js";
 import {
   isAgentMonitorHooksEnabled,
+  isAgentMonitorCodexHooksOptIn,
   setAgentMonitorHooksEnabled,
+  setAgentMonitorCodexHooksOptIn,
   syncAgentMonitorHooksOnBoot,
 } from "./agent-monitor-hooks.js";
 import { DesktopGatewayServer } from "../server/server.js";
@@ -296,7 +304,9 @@ export class DesktopApplication {
   private readonly server: DesktopGatewayServer;
   private readonly cloudSocket: CloudSocketService;
   private readonly commandExecutor: CloudCommandExecutor;
-  private readonly agentMonitor: AgentMonitorSidecar;
+  private readonly agentDashboardMode: AgentDashboardMode;
+  private readonly agentMonitor: AgentMonitorSidecar | null;
+  private agentDashboardDesignSystem: AgentDashboardDesignSystemRuntime | null = null;
   private readonly agentSessionSync: AgentSessionSyncService;
   private readonly costReconciliation: CostReconciliationService;
   private readonly claudeCodeAnalytics: ClaudeCodeAnalyticsService;
@@ -400,24 +410,30 @@ export class DesktopApplication {
     this.loopTokenStore = new LoopTokenStore();
     this.gatewaySigningKeyStore = new GatewaySigningKeyStore();
     this.tray = new DesktopTray();
-    this.desktopWindow = new DesktopWindow();
-    this.agentMonitor = new AgentMonitorSidecar({
-      onTerminalFailure: (reason: string) => {
-        const notification = new Notification({
-          title: "ClosedLoop Agent Monitor",
-          body: reason,
-        });
-        notification.show();
-        // Latch the failure and route through refreshTrayState() — the single
-        // owner of tray state — so the degraded indicator survives subsequent
-        // refreshes. A direct tray.setState here would be stomped by the next
-        // refreshTrayState() call (cloud heartbeat, gateway recheck).
-        this.agentMonitorFailed = true;
-        this.agentMonitorFailureReason = reason;
-        this.refreshTrayState();
-      },
-    });
-    this.agentMonitor.setSandboxBaseDirectory(
+    this.agentDashboardMode = resolveAgentDashboardMode(this.settingsStore);
+    this.desktopWindow = new DesktopWindow({
+      agentDashboardMode: this.agentDashboardMode,
+    });
+    this.agentMonitor =
+      this.agentDashboardMode === "legacy"
+        ? new AgentMonitorSidecar({
+            onTerminalFailure: (reason: string) => {
+              const notification = new Notification({
+                title: "ClosedLoop Agent Monitor",
+                body: reason,
+              });
+              notification.show();
+              // Latch the failure and route through refreshTrayState() — the
+              // single owner of tray state — so the degraded indicator survives
+              // subsequent refreshes. A direct tray.setState here would be
+              // stomped by the next refreshTrayState() call.
+              this.agentMonitorFailed = true;
+              this.agentMonitorFailureReason = reason;
+              this.refreshTrayState();
+            },
+          })
+        : null;
+    this.agentMonitor?.setSandboxBaseDirectory(
       this.settingsStore.getSandboxBaseDirectory(),
     );
     this.activityLog = new ActivityLogStore();
@@ -672,7 +688,7 @@ export class DesktopApplication {
       },
     });
     this.agentSessionSync = new AgentSessionSyncService({
-      isAgentMonitorEnabled: () => this.settingsStore.getAgentMonitorEnabled(),
+      isAgentMonitorEnabled: () => this.isAgentMonitorEnabled(),
       isRelayReady: () =>
         this.serverAgentSessionSyncSupported &&
         this.cloudStatus.state === "online",
@@ -681,16 +697,21 @@ export class DesktopApplication {
         this.settingsStore.getSandboxBaseDirectory(),
       sendBatch: (batch) => this.cloudSocket.sendAgentSessions(batch),
       getUserDataPath: () => app.getPath("userData"),
+      getConnection: () =>
+        this.agentDashboardMode === "design-system"
+          ? this.agentDashboardDesignSystem?.connection ?? null
+          : null,
       onBatchOutcome: (event) => {
         Observability.agentSessionSyncBatchFailed(event);
       },
     });
     // FEA-1435/1436: nightly cost reconciliation lives entirely in main. It owns
     // the org-level vendor Admin key stores (safeStorage, never exposed to the
-    // sidecar or renderer) and the reconciliation store, and reconciles the local
-    // genai-prices estimate (read from dashboard.db READ-ONLY) against what each
-    // vendor actually billed. loadUsageRows re-opens the live DB each run, scoped
-    // to the recent window, and returns [] when the sidecar has not created it.
+    // renderer) and the reconciliation store, and reconciles the local
+    // genai-prices estimate against what each vendor actually billed.
+    // Agent Dashboard usage rows are mode-owned: legacy reads dashboard.db from
+    // disk, design-system reads the in-process connection, and disabled returns
+    // no rows so the dashboard code path stays inert.
     // One Anthropic Admin key store, shared by reconciliation (compares the local
     // estimate against the billed cost_report) and Claude Code analytics (reads
     // Anthropic's own per-user usage estimate). Sharing the store means a key
@@ -700,11 +721,7 @@ export class DesktopApplication {
       anthropicKeyStore,
       openaiKeyStore: createOpenAiAdminKeyStore(),
       store: new ReconciliationStore(),
-      loadUsageRows: () =>
-        loadMeteredUsageRowsFromDisk(
-          resolveAgentMonitorDatabasePath(app.getPath("userData")),
-          reconciliationCutoffIso(new Date()),
-        ),
+      loadUsageRows: () => this.loadAgentDashboardMeteredUsageRows(),
       log: (message) => gatewayLog.info("cost-reconciliation", message),
     });
     // FEA-1436: Claude Code per-user usage view. Read-only, main-only, and uses
@@ -771,6 +788,9 @@ export class DesktopApplication {
     this.tray.setAgentMonitorEnabled(this.settingsStore.getAgentMonitorEnabled());
     this.tray.setPaused(this.cloudCommandsPaused);
     this.syncPendingApprovalsToTray();
+    if (this.agentDashboardMode === "design-system") {
+      await this.ensureAgentDashboardDesignSystemRuntime();
+    }
     this.desktopWindow.init();
     this.bootReadyForOnboarding = true;
     void this.drainQueuedOnboardingHandoffs();
@@ -797,21 +817,19 @@ export class DesktopApplication {
     loopSleepRecovery.init();
 
     // Independent of the gateway, but fully feature-gated. When enabled, start
-    // the sidecar fire-and-forget BEFORE the gateway try-block so a
-    // gateway-start failure never prevents it from running, and a sidecar
-    // failure never blocks or fails app boot. The relay sync service follows
-    // the same flag, so disabling Agent Monitor leaves only dormant wiring in
-    // the desktop shell and no background sync loop. Hook repair remains
-    // opt-in and self-healing.
-    if (this.settingsStore.getAgentMonitorEnabled()) {
-      void this.agentMonitor.start();
-      syncAgentMonitorHooksOnBoot();
-      this.agentSessionSync.start();
+    // the selected capture stack BEFORE the gateway try-block so gateway-start
+    // failures do not prevent it from running, and dashboard failures never
+    // block or fail app boot. The relay sync service follows the same flag, so
+    // disabling Agent Monitor leaves only dormant wiring in the desktop shell
+    // and no background sync loop. Hook repair remains opt-in and self-healing.
+    if (this.isAgentMonitorEnabled()) {
+      await this.startAgentCapture();
     }
 
     // FEA-1435/1436: schedule nightly cost reconciliation. Independent of the
     // Agent Monitor toggle — the scheduled tick no-ops unless a vendor Admin key
-    // is configured, and loadUsageRows returns [] when there is no dashboard.db.
+    // is configured, and loadUsageRows returns [] when the selected dashboard
+    // source is disabled or has no metered rows in the window.
     this.costReconciliation.start();
 
     try {
@@ -1409,13 +1427,131 @@ export class DesktopApplication {
     return this.settingsStore.getPlanExtractionEnabled();
   }
 
+  private getAgentMonitorUrl(): string | null {
+    if (this.agentDashboardMode === "legacy") {
+      return this.agentMonitor?.getUrl() ?? null;
+    }
+    if (this.agentDashboardMode === "design-system") {
+      return this.agentDashboardDesignSystem?.getUrl() ?? null;
+    }
+    return null;
+  }
+
+  private isAgentMonitorReady(): boolean {
+    if (this.agentDashboardMode === "legacy") {
+      return this.agentMonitor?.isReady() ?? false;
+    }
+    if (this.agentDashboardMode === "design-system") {
+      return this.agentDashboardDesignSystem?.isReady() ?? false;
+    }
+    return false;
+  }
+
+  private loadAgentDashboardMeteredUsageRows(): MeteredUsageRow[] {
+    if (!this.isAgentMonitorEnabled()) {
+      return [];
+    }
+
+    const cutoffIso = reconciliationCutoffIso(new Date());
+    if (this.agentDashboardMode === "design-system") {
+      return (
+        this.agentDashboardDesignSystem?.loadMeteredUsageRows(cutoffIso) ?? []
+      );
+    }
+
+    if (this.agentDashboardMode === "legacy") {
+      return loadMeteredUsageRowsFromDisk(
+        resolveAgentMonitorDatabasePath(app.getPath("userData")),
+        cutoffIso,
+      );
+    }
+
+    return [];
+  }
+
+  private async ensureAgentDashboardDesignSystemRuntime(): Promise<AgentDashboardDesignSystemRuntime | null> {
+    if (this.agentDashboardMode !== "design-system") {
+      return null;
+    }
+    if (!this.agentDashboardDesignSystem) {
+      const { createAgentDashboardDesignSystemRuntime } = await import(
+        "./agent-dashboard-design-system-runtime.js"
+      );
+      this.agentDashboardDesignSystem =
+        createAgentDashboardDesignSystemRuntime({
+          userDataPath: app.getPath("userData"),
+          getSandboxBaseDirectory: () =>
+            this.settingsStore.getSandboxBaseDirectory(),
+          getWindow: () => this.desktopWindow.getWindow(),
+          onTerminalFailure: (reason) => {
+            const notification = new Notification({
+              title: "ClosedLoop Agent Monitor",
+              body: reason,
+            });
+            notification.show();
+            this.agentMonitorFailed = true;
+            this.agentMonitorFailureReason = reason;
+            this.refreshTrayState();
+          },
+          log: (scope, message) => gatewayLog.info(scope, message),
+        });
+      this.agentDashboardDesignSystem.registerIpcHandlers();
+    }
+    return this.agentDashboardDesignSystem;
+  }
+
+  /**
+   * Start the selected Agent Dashboard capture stack. The in-process
+   * design-system runtime is dynamically imported only inside the flag-on mode.
+   */
+  private async startAgentCapture(): Promise<void> {
+    if (!this.isAgentMonitorEnabled()) {
+      return;
+    }
+
+    if (this.agentDashboardMode === "legacy") {
+      void this.agentMonitor?.start();
+      syncAgentMonitorHooksOnBoot();
+      this.agentSessionSync.start();
+      return;
+    }
+
+    const runtime = await this.ensureAgentDashboardDesignSystemRuntime();
+    if (!runtime) {
+      return;
+    }
+    runtime.start();
+    syncAgentMonitorHooksOnBoot();
+    this.agentSessionSync.start();
+  }
+
+  private async stopAgentCapture(
+    options: { closeDesignSystem?: boolean } = {},
+  ): Promise<void> {
+    if (this.agentDashboardMode === "legacy") {
+      await this.agentMonitor?.stop();
+    } else if (this.agentDashboardMode === "design-system") {
+      await this.agentDashboardDesignSystem?.stop();
+    }
+    this.agentSessionSync.stop();
+    if (
+      options.closeDesignSystem &&
+      this.agentDashboardMode === "design-system" &&
+      this.agentDashboardDesignSystem
+    ) {
+      this.agentDashboardDesignSystem.close();
+      this.agentDashboardDesignSystem = null;
+    }
+  }
+
   private async applyAgentMonitorSetting(enabled: boolean): Promise<void> {
     this.tray.setAgentMonitorEnabled(enabled);
 
     if (enabled) {
-      void this.agentMonitor.start();
-      syncAgentMonitorHooksOnBoot();
-      this.agentSessionSync.start();
+      if (this.agentDashboardMode === "design-system") {
+        this.desktopWindow.reloadForAgentDashboardMode("design-system");
+      }
+      await this.startAgentCapture();
       return;
     }
 
@@ -1429,8 +1565,10 @@ export class DesktopApplication {
       );
     }
 
-    await this.agentMonitor.stop();
-    this.agentSessionSync.stop();
+    await this.stopAgentCapture({ closeDesignSystem: true });
+    if (this.agentDashboardMode === "design-system") {
+      this.desktopWindow.reloadForAgentDashboardMode("disabled");
+    }
     this.desktopWindow
       .getWindow()
       ?.webContents.send("desktop:navigate-tab", "settings");
@@ -1452,7 +1590,12 @@ export class DesktopApplication {
     }
     this.desktopWindow
       .getWindow()
-      ?.webContents.send("desktop:navigate-tab", "claude-dashboard");
+      ?.webContents.send(
+        "desktop:navigate-tab",
+        this.agentDashboardMode === "design-system"
+          ? "dashboard"
+          : "claude-dashboard",
+      );
   }
 
   private notifyCommandKeysChanged(): void {
@@ -1893,8 +2036,9 @@ export class DesktopApplication {
     this.queueStatsTelemetryDebounce.cancel();
     this.clearActiveCommandKeyTargetContext("shutdown");
     this.commandKeyReconciler.stop();
-    this.agentSessionSync.stop();
+    await this.stopAgentCapture();
     this.costReconciliation.stop();
+    this.agentDashboardDesignSystem?.close();
     return runShutdownSequence({
       observability: Observability,
       updateCheckTimer: this.updateCheckTimer,
@@ -1906,7 +2050,7 @@ export class DesktopApplication {
       },
       cloudSocket: this.cloudSocket,
       commandExecutor: this.commandExecutor,
-      agentMonitor: this.agentMonitor,
+      agentMonitor: { stop: () => this.stopAgentCapture() },
       server: this.server,
       desktopWindow: this.desktopWindow,
       tray: this.tray,
@@ -2644,17 +2788,16 @@ export class DesktopApplication {
   private registerIpcHandlers(): void {
     ipcMain.handle("desktop:get-app-version", () => app.getVersion());
     ipcMain.handle("desktop:get-agent-monitor-url", () => ({
-      url: this.agentMonitor.getUrl(),
-      ready: this.agentMonitor.isReady(),
+      url: this.getAgentMonitorUrl(),
+      ready: this.isAgentMonitorReady(),
       enabled: this.isAgentMonitorEnabled(),
       planExtractionEnabled: this.isPlanExtractionEnabled(),
     }));
-    // FEA-1334: proxy the sidecar's cold-start ingest progress so the renderer
-    // can drive the floating progress card without a cross-origin fetch.
-    // Returns null whenever the sidecar is not reachable — the renderer treats
-    // that as "keep polling, nothing to show yet".
     ipcMain.handle("desktop:get-agent-monitor-ingest-progress", async () => {
-      const baseUrl = this.agentMonitor.getUrl();
+      if (this.agentDashboardMode !== "legacy") {
+        return null;
+      }
+      const baseUrl = this.agentMonitor?.getUrl();
       if (!baseUrl) {
         return null;
       }
@@ -2670,14 +2813,16 @@ export class DesktopApplication {
         return null;
       }
     });
-    // FEA-1334: clear the dashboard DB and restart the sidecar so it
-    // re-imports every agent session from scratch. The sidecar's empty-DB
-    // boot path clears the persisted ingest caches and re-runs the
-    // orchestrator, which the progress banner tracks.
     ipcMain.handle("desktop:reprocess-agent-logs", async () => {
       if (!this.isAgentMonitorEnabled()) {
         return { ok: false, error: "Agent Dashboard is disabled in Settings." };
       }
+      if (this.agentDashboardMode !== "legacy" || !this.agentMonitor) {
+        return {
+          ok: false,
+          error: "Reprocessing is not available in design-system dashboard mode.",
+        };
+      }
       try {
         await this.agentMonitor.stop();
         const agentMonitorDir = path.join(
@@ -2692,7 +2837,7 @@ export class DesktopApplication {
           try {
             rmSync(path.join(agentMonitorDir, name));
           } catch {
-            /* file may not exist — fine */
+            /* file may not exist */
           }
         }
         void this.agentMonitor.start();
@@ -2720,7 +2865,37 @@ export class DesktopApplication {
             error: "Agent Dashboard is disabled in Settings.",
           };
         }
-        return setAgentMonitorHooksEnabled(enabled === true);
+        const result = setAgentMonitorHooksEnabled(enabled === true);
+        if (result.ok && this.agentDashboardMode === "design-system") {
+          // Hooks own live Claude capture, so toggling them must re-evaluate
+          // the Claude file-watcher gating (`shouldWatchClaude`): hooks-on ⇒ no
+          // Claude watcher (avoid double-counting turns), hooks-off ⇒ Claude
+          // watcher resumes live capture. Restart the collectors so the frozen
+          // boot-time decision is recomputed; boot import is idempotent, so the
+          // restart is safe. (CLAUDE.md: toggles must update in-memory side
+          // effects together — no one-way restart guards.)
+          this.agentDashboardDesignSystem?.restartCollectors();
+        }
+        return result;
+      },
+    );
+    // FEA-1444 (carried into FEA-1497): opt-in Codex hook ingestion. Gated on
+    // the master Agent Dashboard toggle; the Codex hook handler uses a
+    // route-owned listener path so payload data cannot choose harness='codex'.
+    ipcMain.handle("desktop:get-agent-monitor-codex-hooks-opt-in", () =>
+      this.isAgentMonitorEnabled() && isAgentMonitorCodexHooksOptIn(),
+    );
+    ipcMain.handle(
+      "desktop:set-agent-monitor-codex-hooks-opt-in",
+      (_event, optIn: boolean) => {
+        if (!this.isAgentMonitorEnabled()) {
+          return {
+            ok: false,
+            enabled: false,
+            error: "Agent Dashboard is disabled in Settings.",
+          };
+        }
+        return setAgentMonitorCodexHooksOptIn(optIn === true);
       },
     );
     ipcMain.handle("desktop:get-logs", () => gatewayLog.getEntries());
@@ -2797,6 +2972,10 @@ export class DesktopApplication {
         if (typeof partial.agentMonitorEnabled === "boolean") {
           nextPartial.agentMonitorEnabled = partial.agentMonitorEnabled;
         }
+        if (typeof partial.agentDashboardDesignSystemEnabled === "boolean") {
+          nextPartial.agentDashboardDesignSystemEnabled =
+            partial.agentDashboardDesignSystemEnabled;
+        }
         if (typeof partial.planExtractionEnabled === "boolean") {
           nextPartial.planExtractionEnabled = partial.planExtractionEnabled;
         }
@@ -2867,11 +3046,15 @@ export class DesktopApplication {
             normalizeScopePath(currentSettings.sandboxBaseDirectory)
         ) {
           await seedReposConfig(selectedSandbox);
-          this.agentMonitor.setSandboxBaseDirectory(selectedSandbox);
-          if (this.settingsStore.getAgentMonitorEnabled()) {
-            await this.agentMonitor.stop();
-            void this.agentMonitor.start();
+          if (this.agentDashboardMode === "legacy" && this.agentMonitor) {
+            this.agentMonitor.setSandboxBaseDirectory(selectedSandbox);
+            if (this.isAgentMonitorEnabled()) {
+              await this.agentMonitor.stop();
+              void this.agentMonitor.start();
+            }
           }
+          // Design-system mode reads the sandbox directory through a live
+          // callback on every hook/collector event, so it needs no restart.
         }
 
         // Notify renderer of flag changes so the Feature Flags panel can refresh.
diff --git a/apps/desktop/src/main/collectors/catchup-cache.ts b/apps/desktop/src/main/collectors/catchup-cache.ts
new file mode 100644
index 00000000..215684b3
--- /dev/null
+++ b/apps/desktop/src/main/collectors/catchup-cache.ts
@@ -0,0 +1,133 @@
+/**
+ * @file catchup-cache.ts
+ * @description Per-file (mtime, size) cache shared by every harness importer
+ * (FEA-1503; ported from the vendor `catchup-cache.js`, logic preserved). The
+ * boot import + catchup poll re-list files cheaply: an unchanged file is skipped
+ * with one stat() call instead of a full parse. When constructed with a
+ * `persistPath` the cache survives process restarts (best-effort JSON file), so a
+ * cold-start boot import skips unchanged history with a single stat() each.
+ */
+import { mkdirSync, readFileSync, statSync, writeFileSync, type Stats } from "node:fs";
+import path from "node:path";
+
+const PERSIST_VERSION = 1;
+
+interface SeenEntry {
+  mtimeMs: number;
+  size: number;
+}
+
+export interface CatchupCache {
+  isUnchanged(filePath: string): { unchanged: boolean; stat: Stats | null };
+  markSeen(filePath: string): void;
+  markSeenWith(filePath: string, stat: Stats | null): void;
+  pruneTo(currentPaths: string[]): void;
+  flush(): void;
+  size(): number;
+  clear(): void;
+  readonly persisted: boolean;
+}
+
+export function createCatchupCache(options: { persistPath?: string } = {}): CatchupCache {
+  const persistPath =
+    typeof options.persistPath === "string" && options.persistPath.length > 0
+      ? options.persistPath
+      : null;
+
+  const seen = new Map<string, SeenEntry>();
+  let dirty = false;
+
+  if (persistPath) {
+    try {
+      const parsed = JSON.parse(readFileSync(persistPath, "utf8")) as {
+        entries?: Record<string, unknown>;
+      };
+      const entries = parsed && parsed.entries;
+      if (entries && typeof entries === "object") {
+        for (const [key, value] of Object.entries(entries)) {
+          const v = value as Partial<SeenEntry> | null;
+          if (v && typeof v.mtimeMs === "number" && typeof v.size === "number") {
+            seen.set(key, { mtimeMs: v.mtimeMs, size: v.size });
+          }
+        }
+      }
+    } catch {
+      /* missing or corrupt cache file — start empty, non-fatal */
+    }
+  }
+
+  function isUnchanged(filePath: string): { unchanged: boolean; stat: Stats | null } {
+    let stat: Stats;
+    try {
+      stat = statSync(filePath);
+    } catch {
+      return { unchanged: false, stat: null };
+    }
+    const cached = seen.get(filePath);
+    if (cached && cached.mtimeMs === stat.mtimeMs && cached.size === stat.size) {
+      return { unchanged: true, stat };
+    }
+    return { unchanged: false, stat };
+  }
+
+  function markSeenWith(filePath: string, stat: Stats | null): void {
+    if (stat) {
+      seen.set(filePath, { mtimeMs: stat.mtimeMs, size: stat.size });
+      dirty = true;
+    }
+  }
+
+  function markSeen(filePath: string): void {
+    let stat: Stats;
+    try {
+      stat = statSync(filePath);
+    } catch {
+      return;
+    }
+    seen.set(filePath, { mtimeMs: stat.mtimeMs, size: stat.size });
+    dirty = true;
+  }
+
+  function pruneTo(currentPaths: string[]): void {
+    const keep = new Set(currentPaths);
+    for (const key of seen.keys()) {
+      if (!keep.has(key)) {
+        seen.delete(key);
+        dirty = true;
+      }
+    }
+  }
+
+  function flush(): void {
+    if (!persistPath || !dirty) return;
+    dirty = false;
+    try {
+      mkdirSync(path.dirname(persistPath), { recursive: true });
+      const entries: Record<string, SeenEntry> = {};
+      for (const [key, value] of seen) entries[key] = value;
+      writeFileSync(persistPath, JSON.stringify({ version: PERSIST_VERSION, entries }));
+    } catch {
+      /* best-effort persistence — cache stays correct in memory */
+    }
+  }
+
+  function size(): number {
+    return seen.size;
+  }
+
+  function clear(): void {
+    if (seen.size > 0) dirty = true;
+    seen.clear();
+  }
+
+  return {
+    isUnchanged,
+    markSeen,
+    markSeenWith,
+    pruneTo,
+    flush,
+    size,
+    clear,
+    persisted: persistPath != null,
+  };
+}
diff --git a/apps/desktop/src/main/collectors/claude/claude-collector.ts b/apps/desktop/src/main/collectors/claude/claude-collector.ts
new file mode 100644
index 00000000..7566d2de
--- /dev/null
+++ b/apps/desktop/src/main/collectors/claude/claude-collector.ts
@@ -0,0 +1,25 @@
+/**
+ * @file claude-collector.ts
+ * @description Claude Code harness collector descriptor (FEA-1503). Claude is the
+ * one harness with a live hook path, so its live file watcher is gated OFF by the
+ * CollectorManager whenever hooks are installed (hooks own live capture; a
+ * concurrent watcher would double-count turns). Boot historical import always
+ * runs and is idempotent against any hook-written events.
+ */
+import type { HarnessCollector } from "../types.js";
+import { getProjectsDir, listAllTranscriptFiles } from "./claude-home.js";
+import { parseSessionFile } from "./claude-parser.js";
+
+export function createClaudeCollector(): HarnessCollector {
+  return {
+    key: "claude",
+    cacheName: "claude",
+    watchRoots: () => [getProjectsDir()],
+    watchMatch: (filename: string) => filename.endsWith(".jsonl"),
+    listSources: () => listAllTranscriptFiles(),
+    parse: async (filePath: string) => {
+      const session = await parseSessionFile(filePath);
+      return session ? [session] : [];
+    },
+  };
+}
diff --git a/apps/desktop/src/main/collectors/claude/claude-home.ts b/apps/desktop/src/main/collectors/claude/claude-home.ts
new file mode 100644
index 00000000..b18c27a1
--- /dev/null
+++ b/apps/desktop/src/main/collectors/claude/claude-home.ts
@@ -0,0 +1,54 @@
+/**
+ * @file claude-home.ts
+ * @description Claude Code home/transcript path resolution (FEA-1503; first-party
+ * port of the vendor `server/lib/claude-home.js`). Claude stores per-session
+ * transcripts as JSONL under `~/.claude/projects/<encoded-cwd>/<sessionId>.jsonl`
+ * (subagent transcripts live deeper under `<sessionId>/subagents/`). Honors the
+ * `CLAUDE_HOME` override (same resolution as agent-monitor-hooks.ts).
+ */
+import { readdirSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+export function getClaudeHome(): string {
+  return process.env.CLAUDE_HOME || path.join(os.homedir(), ".claude");
+}
+
+export function getProjectsDir(): string {
+  return path.join(getClaudeHome(), "projects");
+}
+
+/** The sessionId is the transcript filename without its `.jsonl` extension. */
+export function sessionIdFromTranscriptPath(filePath: string): string {
+  return path.basename(filePath, ".jsonl");
+}
+
+/**
+ * Enumerate the top-level session transcript files (one per session) across all
+ * project directories. Deliberately one level deep per project dir so subagent
+ * transcripts under `<sessionId>/subagents/` are NOT returned as sessions.
+ */
+export function listAllTranscriptFiles(): string[] {
+  const projectsDir = getProjectsDir();
+  const out: string[] = [];
+  let dirs: import("node:fs").Dirent[];
+  try {
+    dirs = readdirSync(projectsDir, { withFileTypes: true });
+  } catch {
+    return out;
+  }
+  for (const d of dirs) {
+    if (!d.isDirectory()) continue;
+    const projPath = path.join(projectsDir, d.name);
+    let files: string[];
+    try {
+      files = readdirSync(projPath);
+    } catch {
+      continue;
+    }
+    for (const f of files) {
+      if (f.endsWith(".jsonl")) out.push(path.join(projPath, f));
+    }
+  }
+  return out;
+}
diff --git a/apps/desktop/src/main/collectors/claude/claude-parser.ts b/apps/desktop/src/main/collectors/claude/claude-parser.ts
new file mode 100644
index 00000000..cf78272c
--- /dev/null
+++ b/apps/desktop/src/main/collectors/claude/claude-parser.ts
@@ -0,0 +1,251 @@
+/**
+ * @file claude-parser.ts
+ * @description First-party Claude Code transcript parser (FEA-1503; ported from
+ * the vendor `scripts/import-history.js` `parseSessionFile`, logic preserved). It
+ * streams a `~/.claude/projects/**​/<sessionId>.jsonl` transcript and produces the
+ * shared NormalizedSession. Token accumulation mirrors `database/transcript.ts`
+ * (cumulative per model, reasoning folded into output is NOT done here — Claude's
+ * usage block already separates the fields).
+ */
+import { createReadStream, statSync } from "node:fs";
+import path from "node:path";
+import readline from "node:readline";
+import type {
+  NormalizedApiError,
+  NormalizedSession,
+  NormalizedTokenCounts,
+  NormalizedToolResultError,
+  NormalizedToolUse,
+  NormalizedTurnDuration,
+} from "../types.js";
+
+/** Mirror the vendor's lenient timestamp handling: epoch number → ISO, string as-is. */
+function isoTs(ts: unknown): string | null {
+  if (ts == null) return null;
+  if (typeof ts === "number") return new Date(ts).toISOString();
+  if (typeof ts === "string") return ts;
+  return null;
+}
+
+function asRecord(value: unknown): Record<string, unknown> {
+  return value && typeof value === "object" ? (value as Record<string, unknown>) : {};
+}
+
+function num(value: unknown): number {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+
+/**
+ * Parse a Claude transcript file into a NormalizedSession. Returns null when the
+ * file has no usable timestamp (matching the vendor contract). Fail-silent on IO
+ * or parse errors (malformed lines are skipped).
+ */
+export async function parseSessionFile(filePath: string): Promise<NormalizedSession | null> {
+  const sessionId = path.basename(filePath, ".jsonl");
+
+  const rl = readline.createInterface({
+    input: createReadStream(filePath, { encoding: "utf8" }),
+    crlfDelay: Infinity,
+  });
+
+  let cwd: string | null = null;
+  let model: string | null = null;
+  let version: string | null = null;
+  let slug: string | null = null;
+  let gitBranch: string | null = null;
+  let firstTimestamp: string | null = null;
+  let lastTimestamp: string | null = null;
+  const teams = new Set<string>();
+  let userMessageCount = 0;
+  let assistantMessageCount = 0;
+  const tokensByModel: Record<string, NormalizedTokenCounts> = {};
+  const messageTimestamps: string[] = [];
+  const toolUses: NormalizedToolUse[] = [];
+  const compactions: Array<{ uuid: string | null; timestamp: string | null }> = [];
+  const apiErrors: NormalizedApiError[] = [];
+  const turnDurations: NormalizedTurnDuration[] = [];
+  let entrypoint: string | null = null;
+  let permissionMode: string | null = null;
+  let thinkingBlockCount = 0;
+  const toolResultErrors: NormalizedToolResultError[] = [];
+  const serviceTiers = new Set<string>();
+  const speeds = new Set<string>();
+  const inferenceGeos = new Set<string>();
+
+  try {
+    for await (const line of rl) {
+      if (!line.trim()) continue;
+      let entry: Record<string, unknown>;
+      try {
+        entry = JSON.parse(line) as Record<string, unknown>;
+      } catch {
+        continue;
+      }
+
+      if (entry.isCompactSummary) {
+        compactions.push({
+          uuid: (entry.uuid as string) || null,
+          timestamp: (entry.timestamp as string) || null,
+        });
+      }
+
+      if (entry.type === "system" && entry.subtype === "turn_duration" && entry.durationMs) {
+        turnDurations.push({
+          durationMs: num(entry.durationMs),
+          timestamp: isoTs(entry.timestamp),
+        });
+      }
+
+      // isApiErrorMessage entries (quota/rate limits, invalid_request).
+      if (entry.isApiErrorMessage) {
+        const message = asRecord(entry.message);
+        const errContent = Array.isArray(message.content) ? message.content : [];
+        const first = asRecord(errContent[0]);
+        const errText =
+          typeof first.text === "string" ? first.text.slice(0, 500) : "Unknown error";
+        apiErrors.push({
+          type: (entry.error as string) || "unknown_error",
+          message: errText,
+          timestamp: isoTs(entry.timestamp),
+        });
+      }
+      // Raw API error responses (type: "error" at message level).
+      const rawMsg = asRecord(entry.message ?? entry);
+      if (rawMsg.type === "error" && rawMsg.error) {
+        const err = asRecord(rawMsg.error);
+        apiErrors.push({
+          type: (err.type as string) || "unknown_error",
+          message: (err.message as string) || "Unknown API error",
+          timestamp: isoTs(entry.timestamp),
+        });
+      }
+
+      if (!cwd && typeof entry.cwd === "string") cwd = entry.cwd;
+      if (!slug && typeof entry.slug === "string") slug = entry.slug;
+      if (!gitBranch && typeof entry.gitBranch === "string") gitBranch = entry.gitBranch;
+      if (!version && typeof entry.version === "string") version = entry.version;
+      if (!entrypoint && typeof entry.entrypoint === "string") entrypoint = entry.entrypoint;
+      if (!permissionMode && typeof entry.permissionMode === "string") {
+        permissionMode = entry.permissionMode;
+      }
+
+      const ts = entry.timestamp;
+      if (ts) {
+        const iso = isoTs(ts);
+        if (iso) {
+          if (!firstTimestamp || iso < firstTimestamp) firstTimestamp = iso;
+          if (!lastTimestamp || iso > lastTimestamp) lastTimestamp = iso;
+        }
+      }
+
+      if (typeof entry.teamName === "string") teams.add(entry.teamName);
+
+      if (entry.type === "user") {
+        userMessageCount++;
+        const toolUseResult = entry.toolUseResult;
+        if (toolUseResult && typeof toolUseResult === "object") {
+          const tur = toolUseResult as Record<string, unknown>;
+          if (tur.is_error) {
+            const content =
+              typeof tur.content === "string"
+                ? tur.content.slice(0, 500)
+                : JSON.stringify(tur.content ?? "").slice(0, 500);
+            toolResultErrors.push({ content, timestamp: isoTs(entry.timestamp) });
+          }
+        }
+      }
+
+      if (entry.type === "assistant") {
+        assistantMessageCount++;
+        const iso = isoTs(ts);
+        if (iso) messageTimestamps.push(iso);
+        const msg = asRecord(entry.message);
+        const msgModel = typeof msg.model === "string" ? msg.model : null;
+        if (!model && msgModel && msgModel !== "<synthetic>") model = msgModel;
+        const usage = asRecord(msg.usage);
+        if (msgModel && msgModel !== "<synthetic>" && msg.usage) {
+          if (tokensByModel[msgModel] === undefined) {
+            tokensByModel[msgModel] = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+          }
+          tokensByModel[msgModel].input += num(usage.input_tokens);
+          tokensByModel[msgModel].output += num(usage.output_tokens);
+          tokensByModel[msgModel].cacheRead += num(usage.cache_read_input_tokens);
+          tokensByModel[msgModel].cacheWrite += num(usage.cache_creation_input_tokens);
+        }
+        if (msg.usage) {
+          if (typeof usage.service_tier === "string") serviceTiers.add(usage.service_tier);
+          if (typeof usage.speed === "string") speeds.add(usage.speed);
+          if (
+            typeof usage.inference_geo === "string" &&
+            usage.inference_geo !== "not_available"
+          ) {
+            inferenceGeos.add(usage.inference_geo);
+          }
+        }
+        const content = msg.content;
+        if (Array.isArray(content)) {
+          for (const raw of content) {
+            const block = asRecord(raw);
+            if (block.type === "tool_use" && typeof block.name === "string") {
+              toolUses.push({
+                name: block.name,
+                timestamp: iso || firstTimestamp,
+                input: block.input ?? null,
+              });
+            }
+            if (block.type === "thinking") thinkingBlockCount++;
+          }
+        }
+      }
+    }
+  } catch {
+    return null;
+  }
+
+  if (!firstTimestamp) return null;
+
+  const projectName = cwd
+    ? path.basename(cwd)
+    : slug || `Session ${sessionId.slice(0, 8)}`;
+  const sessionName = slug
+    ? `${projectName} (${slug})`
+    : `${projectName} - ${sessionId.slice(0, 8)}`;
+
+  let fileModifiedAt: number | null = null;
+  try {
+    fileModifiedAt = statSync(filePath).mtimeMs;
+  } catch {
+    /* non-fatal */
+  }
+
+  return {
+    sessionId,
+    name: sessionName,
+    cwd,
+    model,
+    version,
+    slug,
+    gitBranch,
+    startedAt: firstTimestamp,
+    endedAt: lastTimestamp,
+    teams: [...teams],
+    userMessages: userMessageCount,
+    assistantMessages: assistantMessageCount,
+    tokensByModel,
+    messageTimestamps,
+    toolUses,
+    compactions,
+    apiErrors,
+    fileModifiedAt,
+    turnDurations,
+    entrypoint: entrypoint ?? "claude",
+    permissionMode,
+    thinkingBlockCount,
+    toolResultErrors,
+    usageExtras: {
+      service_tiers: [...serviceTiers],
+      speeds: [...speeds],
+      inference_geos: [...inferenceGeos],
+    },
+  };
+}
diff --git a/apps/desktop/src/main/collectors/codex/codex-collector.ts b/apps/desktop/src/main/collectors/codex/codex-collector.ts
new file mode 100644
index 00000000..d3996b24
--- /dev/null
+++ b/apps/desktop/src/main/collectors/codex/codex-collector.ts
@@ -0,0 +1,32 @@
+/**
+ * @file codex-collector.ts
+ * @description The per-harness collector descriptor for OpenAI Codex (FEA-1503).
+ * The generic boot importer and the generic watcher drive Codex through this
+ * uniform `HarnessCollector` shape: path/env resolution lives in `codex-home`,
+ * format → NormalizedSession in `codex-parser`, and this descriptor wires them
+ * together for the collector manager.
+ */
+import type { HarnessCollector, NormalizedSession } from "../types.js";
+import { getCodexSessionsDir, listAllRolloutFiles } from "./codex-home.js";
+import { parseRolloutFile } from "./codex-parser.js";
+
+export function createCodexCollector(): HarnessCollector {
+  return {
+    key: "codex",
+    cacheName: "codex",
+    watchRoots(): string[] {
+      // Recursive watch handled by the caller; Codex nests by date under here.
+      return [getCodexSessionsDir()];
+    },
+    watchMatch(filename: string): boolean {
+      return filename.endsWith(".jsonl");
+    },
+    listSources(): string[] {
+      return listAllRolloutFiles();
+    },
+    async parse(filePath: string): Promise<NormalizedSession[]> {
+      const s = await parseRolloutFile(filePath);
+      return s ? [s] : [];
+    },
+  };
+}
diff --git a/apps/desktop/src/main/collectors/codex/codex-home.ts b/apps/desktop/src/main/collectors/codex/codex-home.ts
new file mode 100644
index 00000000..76baa512
--- /dev/null
+++ b/apps/desktop/src/main/collectors/codex/codex-home.ts
@@ -0,0 +1,96 @@
+/**
+ * @file codex-home.ts
+ * @description Centralized OpenAI Codex CLI home directory path management —
+ * the Codex analogue of claude-home. Resolves the sessions root, the rollout
+ * JSONL files (Codex writes one append-only `rollout-*.jsonl` per session under
+ * `sessions/YYYY/MM/DD/`), the aggregated history file, and the archived-sessions
+ * directory. Supports a custom root via the CODEX_HOME environment variable so
+ * non-default Codex installs are still discovered.
+ *
+ * Ported from `scripts/agent-monitor-codex/codex-home.js` (logic preserved).
+ */
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+export function getCodexHome(): string {
+  // Codex accepts a comma-separated CODEX_HOME in some setups; the first entry
+  // is the active root. Fall back to ~/.codex.
+  const raw = process.env.CODEX_HOME;
+  if (raw && raw.trim()) {
+    const first = raw.split(",")[0].trim();
+    if (first) return first.replace(/^~(?=\/)/, os.homedir());
+  }
+  return path.join(os.homedir(), ".codex");
+}
+
+export function getCodexSessionsDir(): string {
+  return path.join(getCodexHome(), "sessions");
+}
+
+export function getCodexArchivedDir(): string {
+  return path.join(getCodexHome(), "archived_sessions");
+}
+
+export function getCodexHistoryPath(): string {
+  return path.join(getCodexHome(), "history.jsonl");
+}
+
+/**
+ * Derive a stable session id from a rollout file path. Codex names rollout
+ * files `rollout-<ISO8601>-<uuid>.jsonl`; we want the uuid. If the name
+ * doesn't match, fall back to the basename sans extension so every file still
+ * maps to a deterministic id.
+ */
+export function sessionIdFromRolloutPath(filePath: string): string {
+  const base = path.basename(filePath, ".jsonl");
+  const uuid = base.match(
+    /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i,
+  );
+  if (uuid) return uuid[0];
+  return base.replace(/^rollout-/, "");
+}
+
+/**
+ * Recursively collect every `*.jsonl` rollout file under a root directory.
+ * Codex nests by date (`sessions/YYYY/MM/DD/`), but we walk generically so a
+ * flat layout or `archived_sessions/` also works. Depth-bounded and
+ * error-tolerant — a Codex dir is the user's own local data and a permission
+ * or IO error on one branch must not abort discovery.
+ */
+export function collectRolloutFiles(
+  root: string,
+  { maxDepth = 8 }: { maxDepth?: number } = {},
+): string[] {
+  const out: string[] = [];
+  if (!root || !fs.existsSync(root)) return out;
+  const walk = (dir: string, depth: number): void => {
+    if (depth > maxDepth) return;
+    let entries: fs.Dirent[];
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      const full = path.join(dir, e.name);
+      if (e.isDirectory()) {
+        walk(full, depth + 1);
+      } else if (e.isFile() && e.name.endsWith(".jsonl")) {
+        out.push(full);
+      }
+    }
+  };
+  walk(root, 0);
+  return out;
+}
+
+/**
+ * All Codex rollout files (active sessions + archived).
+ */
+export function listAllRolloutFiles(): string[] {
+  return [
+    ...collectRolloutFiles(getCodexSessionsDir()),
+    ...collectRolloutFiles(getCodexArchivedDir()),
+  ];
+}
diff --git a/apps/desktop/src/main/collectors/codex/codex-parser.ts b/apps/desktop/src/main/collectors/codex/codex-parser.ts
new file mode 100644
index 00000000..c6b54d3d
--- /dev/null
+++ b/apps/desktop/src/main/collectors/codex/codex-parser.ts
@@ -0,0 +1,443 @@
+/**
+ * @file codex-parser.ts
+ * @description Parse an OpenAI Codex CLI rollout JSONL file into the shared
+ * `NormalizedSession` shape so the Codex import path renders through the
+ * unchanged dashboard UI exactly like Claude sessions.
+ *
+ * Codex's rollout format has drifted across releases, so parsing is
+ * intentionally tolerant: it accepts the modern RolloutLine envelope
+ * (`{type:"session_meta"|"event_msg"|"response_item", payload, timestamp}`),
+ * older bare records (the item itself on the line), and auto-detects a typed
+ * `payload` under an unknown wrapper. Token usage in Codex `token_count`
+ * events is CUMULATIVE per session, so the final value is the session total
+ * (no delta math needed). Model attribution follows CodexBar's documented
+ * rule: `turn_context.model` is authoritative.
+ *
+ * Reference for the Codex format & token/model semantics: steipete/CodexBar
+ * `docs/codex.md` (MIT) — see THIRD_PARTY_NOTICES.md.
+ *
+ * Ported from `scripts/agent-monitor-codex/codex-parser.js` (logic preserved).
+ */
+import fs from "node:fs";
+import path from "node:path";
+import readline from "node:readline";
+
+import { pushTurnDuration, toIso, safeJson } from "../parser-utils.js";
+import type {
+  NormalizedApiError,
+  NormalizedPlan,
+  NormalizedSession,
+  NormalizedToolResultError,
+  NormalizedToolUse,
+  NormalizedTokenCounts,
+  NormalizedTurnDuration,
+} from "../types.js";
+import { sessionIdFromRolloutPath } from "./codex-home.js";
+
+const RESPONSE_ITEM_TYPES = new Set<string>([
+  "message",
+  "reasoning",
+  "function_call",
+  "function_call_output",
+  "local_shell_call",
+  "local_shell_call_output",
+  "custom_tool_call",
+  "custom_tool_call_output",
+]);
+
+// CLOSEDLOOP plan-extraction (FEA-1189): Codex emits implementation plans as a
+// structured `item_completed` event whose item.type === "Plan", and (fallback)
+// as a <proposed_plan> block inside an assistant message. We surface both into
+// session.plans[]; plan-extractor/plan-store handle normalization + versioning.
+const PROPOSED_PLAN_RE = /<proposed_plan>([\s\S]*?)<\/proposed_plan>/i;
+
+type Rec = Record<string, unknown>;
+
+type ClassifyKind =
+  | "session_meta"
+  | "turn_context"
+  | "event"
+  | "response_item"
+  | "auto"
+  | "other";
+
+interface Classified {
+  kind: ClassifyKind;
+  p: Rec;
+  ts: unknown;
+}
+
+/** Narrow an unknown value to a plain object record (excludes arrays/null). */
+function asRec(v: unknown): Rec | null {
+  return v && typeof v === "object" && !Array.isArray(v) ? (v as Rec) : null;
+}
+
+/** Read a string field from a record, returning null when not a string. */
+function asStr(v: unknown): string | null {
+  return typeof v === "string" ? v : null;
+}
+
+/**
+ * Classify a parsed JSONL record into a coarse kind plus its inner payload.
+ */
+export function classify(rec: unknown): Classified | null {
+  const r = asRec(rec);
+  if (!r) return null;
+  const payload = asRec(r.payload);
+  const ts =
+    r.timestamp ?? r.ts ?? (payload ? payload.timestamp : undefined) ?? null;
+  const t = r.type;
+
+  if (t === "session_meta" || t === "session.created")
+    return { kind: "session_meta", p: payload ?? r, ts };
+  if (t === "turn_context" || t === "turn.context")
+    return { kind: "turn_context", p: payload ?? r, ts };
+  if (t === "event_msg" || t === "event")
+    return { kind: "event", p: payload ?? r, ts };
+  if (t === "response_item" || t === "response.item")
+    return { kind: "response_item", p: payload ?? r, ts };
+
+  // Unknown wrapper but a typed payload — auto-detect from payload.type.
+  if (payload && payload.type) {
+    return { kind: "auto", p: payload, ts };
+  }
+  // Bare Responses-API item on the line.
+  if (typeof t === "string" && RESPONSE_ITEM_TYPES.has(t))
+    return { kind: "response_item", p: r, ts };
+  // Bare session meta (no `type`, but session-ish fields).
+  if (!t && (r.cwd || r.instructions || r.git || r.session_id || r.id)) {
+    return { kind: "session_meta", p: r, ts };
+  }
+  // Bare event-like record.
+  if (t) return { kind: "event", p: r, ts };
+  return { kind: "other", p: payload ?? r, ts };
+}
+
+function extractText(content: unknown): string {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  const parts: string[] = [];
+  for (const b of content) {
+    if (!b) continue;
+    if (typeof b === "string") {
+      parts.push(b);
+      continue;
+    }
+    const block = asRec(b);
+    if (!block) continue;
+    if (typeof block.text === "string") parts.push(block.text);
+    else if (
+      block.type === "input_text" ||
+      block.type === "output_text" ||
+      block.type === "text"
+    ) {
+      if (typeof block.text === "string") parts.push(block.text);
+    }
+  }
+  return parts.join("");
+}
+
+/** Read a numeric field from a record, returning 0 when absent/non-number. */
+function num(rec: Rec, key: string): number {
+  const v = rec[key];
+  return typeof v === "number" ? v : 0;
+}
+
+/**
+ * Parse a single Codex rollout JSONL file into the normalized session object.
+ * Returns null when the file carries no usable timestamp (mirrors
+ * parseSessionFile's contract so importSession can treat both identically).
+ */
+export async function parseRolloutFile(
+  filePath: string,
+): Promise<NormalizedSession | null> {
+  const sessionId = sessionIdFromRolloutPath(filePath);
+
+  const rl = readline.createInterface({
+    input: fs.createReadStream(filePath, { encoding: "utf8" }),
+    crlfDelay: Infinity,
+  });
+
+  let cwd: string | null = null;
+  let model: string | null = null;
+  let version: string | null = null;
+  let gitBranch: string | null = null;
+  let firstTimestamp: string | null = null;
+  let lastTimestamp: string | null = null;
+  let userMessageCount = 0;
+  let assistantMessageCount = 0;
+  const messageTimestamps: string[] = [];
+  const toolUses: NormalizedToolUse[] = [];
+  const turnDurations: NormalizedTurnDuration[] = [];
+  const plans: NormalizedPlan[] = []; // CLOSEDLOOP plan-extraction (FEA-1189)
+  const apiErrors: NormalizedApiError[] = [];
+  let thinkingBlockCount = 0;
+  const toolResultErrors: NormalizedToolResultError[] = [];
+  let latestTotals: Rec | null = null; // cumulative token_count totals (last wins)
+  let sawResponseItems = false;
+  let lastTs: string | null = null;
+  let pendingTurnStartedAt: string | null = null;
+
+  const noteTs = (raw: unknown): string | null => {
+    const iso = toIso(raw);
+    if (!iso) return null;
+    if (!firstTimestamp || iso < firstTimestamp) firstTimestamp = iso;
+    if (!lastTimestamp || iso > lastTimestamp) lastTimestamp = iso;
+    lastTs = iso;
+    return iso;
+  };
+
+  const handleResponseItem = (
+    p: Rec,
+    iso: string | null,
+    explicitIso: string | null,
+  ): void => {
+    sawResponseItems = true;
+    const itype = p.type;
+    if (itype === "message") {
+      const role = asStr(p.role) ?? asStr(p.author) ?? "assistant";
+      const text = extractText(p.content);
+      if (role === "user") {
+        userMessageCount++;
+        if (explicitIso) pendingTurnStartedAt = explicitIso;
+      } else {
+        assistantMessageCount++;
+        if (iso) messageTimestamps.push(iso);
+        pushTurnDuration(turnDurations, pendingTurnStartedAt, iso);
+        pendingTurnStartedAt = null;
+        // Fallback plan signal: <proposed_plan> block in an assistant message
+        // (medium confidence — flagged for user confirmation downstream).
+        const pm = PROPOSED_PLAN_RE.exec(text);
+        if (pm && pm[1] && pm[1].trim()) {
+          plans.push({
+            source: "codex-proposed-plan",
+            content: pm[1].trim(),
+            timestamp: iso || firstTimestamp,
+          });
+        }
+      }
+      void text;
+    } else if (itype === "reasoning") {
+      thinkingBlockCount++;
+    } else if (itype === "function_call" || itype === "custom_tool_call") {
+      toolUses.push({
+        name: asStr(p.name) ?? asStr(p.tool_name) ?? "function",
+        timestamp: iso || firstTimestamp,
+        input: safeJson(p.arguments != null ? p.arguments : p.input),
+      });
+    } else if (itype === "local_shell_call") {
+      const action = asRec(p.action) ?? {};
+      toolUses.push({
+        name: "shell",
+        timestamp: iso || firstTimestamp,
+        input: action.command || p.action || p.input || null,
+      });
+    } else if (
+      itype === "function_call_output" ||
+      itype === "custom_tool_call_output" ||
+      itype === "local_shell_call_output"
+    ) {
+      const out = p.output ?? p.result ?? {};
+      const outRec = asRec(out);
+      const isErr = outRec
+        ? outRec.success === false || outRec.is_error === true || !!outRec.error
+        : false;
+      if (isErr) {
+        const content =
+          typeof out === "string"
+            ? out.slice(0, 500)
+            : JSON.stringify(out).slice(0, 500);
+        toolResultErrors.push({ content, timestamp: iso });
+      }
+    }
+  };
+
+  const handleEvent = (
+    p: Rec,
+    iso: string | null,
+    explicitIso: string | null,
+  ): void => {
+    const et = p.type;
+    if (!et) return;
+    // CLOSEDLOOP plan-extraction (FEA-1189): the strongest Codex plan signal —
+    // a structured item_completed event carrying item.type === "Plan".
+    const item = asRec(p.item);
+    if (
+      et === "item_completed" &&
+      item &&
+      item.type === "Plan" &&
+      typeof item.text === "string" &&
+      item.text.trim()
+    ) {
+      plans.push({
+        source: "codex-plan-item",
+        content: item.text,
+        timestamp: iso || firstTimestamp,
+      });
+      return;
+    }
+    if (et === "user_message") {
+      userMessageCount++;
+      if (explicitIso) pendingTurnStartedAt = explicitIso;
+    } else if (et === "agent_message" || et === "agent_message_delta") {
+      if (et === "agent_message") {
+        assistantMessageCount++;
+        if (iso) messageTimestamps.push(iso);
+        pushTurnDuration(turnDurations, pendingTurnStartedAt, iso);
+        pendingTurnStartedAt = null;
+      }
+    } else if (
+      et === "agent_reasoning" ||
+      et === "agent_reasoning_section_break"
+    ) {
+      if (et === "agent_reasoning") thinkingBlockCount++;
+    } else if (et === "token_count") {
+      const info = asRec(p.info) ?? asRec(p.token_count_info) ?? p;
+      const totals =
+        asRec(info.total_token_usage) ??
+        asRec(info.totalTokenUsage) ??
+        asRec(info.total);
+      if (totals) latestTotals = totals;
+      const turnCtx = asRec(p.turn_context);
+      const m =
+        (turnCtx && asStr(turnCtx.model)) || asStr(info.model) || asStr(p.model);
+      if (m) model = m;
+    } else if (et === "error" || et === "stream_error") {
+      apiErrors.push({
+        type: et,
+        message:
+          (typeof p.message === "string" && p.message) ||
+          asStr(p.error) ||
+          "Codex error",
+        timestamp: iso,
+      });
+    } else if (
+      !sawResponseItems &&
+      (et === "exec_command_begin" ||
+        et === "patch_apply_begin" ||
+        et === "mcp_tool_call_begin")
+    ) {
+      // Fallback only for older event-only logs with no response_item items.
+      const name =
+        et === "exec_command_begin"
+          ? "shell"
+          : et === "patch_apply_begin"
+            ? "apply_patch"
+            : asStr(p.tool) ?? asStr(p.server) ?? "mcp_tool";
+      toolUses.push({
+        name,
+        timestamp: iso || firstTimestamp,
+        input: p.command ?? p.changes ?? p.arguments ?? null,
+      });
+    }
+  };
+
+  for await (const line of rl) {
+    if (!line.trim()) continue;
+    let rec: unknown;
+    try {
+      rec = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const c = classify(rec);
+    if (!c) continue;
+    const explicitIso = noteTs(c.ts);
+    const iso = explicitIso || lastTs;
+
+    if (c.kind === "session_meta") {
+      const p = c.p;
+      if (!cwd && (p.cwd || p.workdir))
+        cwd = asStr(p.cwd) ?? asStr(p.workdir);
+      if (!version && (p.cli_version || p.version))
+        version = asStr(p.cli_version) ?? asStr(p.version);
+      if (!gitBranch) {
+        const git = asRec(p.git);
+        if (git) gitBranch = asStr(git.branch) ?? asStr(git.ref) ?? null;
+        else if (typeof p.git_branch === "string") gitBranch = p.git_branch;
+      }
+      if (!model && p.model) model = asStr(p.model);
+    } else if (c.kind === "turn_context") {
+      const p = c.p;
+      if (p.model) model = asStr(p.model); // authoritative
+      if (!cwd && p.cwd) cwd = asStr(p.cwd);
+    } else if (c.kind === "response_item") {
+      handleResponseItem(c.p, iso, explicitIso);
+    } else if (c.kind === "event") {
+      handleEvent(c.p, iso, explicitIso);
+    } else if (c.kind === "auto") {
+      const p = c.p;
+      if (typeof p.type === "string" && RESPONSE_ITEM_TYPES.has(p.type))
+        handleResponseItem(p, iso, explicitIso);
+      else handleEvent(p, iso, explicitIso);
+    }
+  }
+
+  if (!firstTimestamp) return null;
+
+  const tokensByModel: Record<string, NormalizedTokenCounts> = {};
+  if (latestTotals) {
+    const key = model || "gpt-codex";
+    const input = num(latestTotals, "input_tokens") || num(latestTotals, "inputTokens");
+    const cached =
+      num(latestTotals, "cached_input_tokens") ||
+      num(latestTotals, "cachedInputTokens");
+    const output =
+      num(latestTotals, "output_tokens") || num(latestTotals, "outputTokens");
+    const reasoning =
+      num(latestTotals, "reasoning_output_tokens") ||
+      num(latestTotals, "reasoningOutputTokens");
+    const cacheWrite =
+      num(latestTotals, "cache_write_tokens") ||
+      num(latestTotals, "cacheWriteTokens") ||
+      num(latestTotals, "cache_creation_input_tokens") ||
+      num(latestTotals, "cacheCreationInputTokens");
+    if (input || output || cached || reasoning || cacheWrite) {
+      tokensByModel[key] = {
+        input,
+        output: output + reasoning,
+        cacheRead: cached,
+        cacheWrite,
+      };
+    }
+  }
+
+  let fileModifiedAt: number | null = null;
+  try {
+    fileModifiedAt = fs.statSync(filePath).mtimeMs;
+  } catch {
+    /* non-fatal */
+  }
+
+  const projectName = cwd
+    ? path.basename(cwd)
+    : `Codex Session ${sessionId.slice(0, 8)}`;
+
+  return {
+    sessionId,
+    name: projectName,
+    cwd,
+    model,
+    version,
+    slug: null,
+    gitBranch,
+    startedAt: firstTimestamp,
+    endedAt: lastTimestamp,
+    teams: [],
+    userMessages: userMessageCount,
+    assistantMessages: assistantMessageCount,
+    tokensByModel,
+    messageTimestamps,
+    toolUses,
+    plans,
+    compactions: [],
+    apiErrors,
+    fileModifiedAt,
+    turnDurations,
+    entrypoint: "codex",
+    permissionMode: null,
+    thinkingBlockCount,
+    toolResultErrors,
+    usageExtras: { service_tiers: [], speeds: [], inference_geos: [] },
+  };
+}
diff --git a/apps/desktop/src/main/collectors/collector-manager.ts b/apps/desktop/src/main/collectors/collector-manager.ts
new file mode 100644
index 00000000..ecbec10d
--- /dev/null
+++ b/apps/desktop/src/main/collectors/collector-manager.ts
@@ -0,0 +1,197 @@
+/**
+ * @file collector-manager.ts
+ * @description Owns the in-process multi-harness collection layer (FEA-1503):
+ * boot-time bulk import + live file watchers for all five agent CLIs (Claude,
+ * Codex, Cursor, Copilot, OpenCode), writing through the first-party
+ * `importSession` into the shared in-process DB. Started/stopped alongside the
+ * hook listener via the `agentMonitorEnabled` toggle.
+ *
+ * Gating (fail-closed, FEA-1407): every parsed session is checked against the
+ * sandbox base directory BEFORE any write — an out-of-sandbox `cwd` (or an empty
+ * sandbox) drops the session, exactly like the hook path. Do not ungate.
+ *
+ * Claude has a live hook path; its live watcher is therefore gated OFF when hooks
+ * are installed (hooks own live capture — a concurrent file watcher would
+ * double-count turns). Claude boot historical import still runs and is idempotent
+ * against any hook-written events.
+ */
+import type { AgentDatabase } from "../database/index.js";
+import { isSessionInSandbox } from "../agent-session-sync-service.js";
+import { createImporter, type Importer } from "./import-session.js";
+import { createCatchupCache, type CatchupCache } from "./catchup-cache.js";
+import { ingestCachePath, ingestOpencodeFingerprintPath } from "./ingest-paths.js";
+import { createHarnessWatcher, type HarnessWatcher } from "./watcher.js";
+import type { HarnessCollector, NormalizedSession } from "./types.js";
+import { createClaudeCollector } from "./claude/claude-collector.js";
+import { createCodexCollector } from "./codex/codex-collector.js";
+import { createCursorCollector } from "./cursor/cursor-collector.js";
+import { createCopilotCollector } from "./copilot/copilot-collector.js";
+import { createOpencodeCollector } from "./opencode/opencode-collector.js";
+
+export interface CollectorManagerOptions {
+  agentDatabase: AgentDatabase;
+  /** Resolve a billing mode for a harness at session creation (FEA-1434). */
+  detectBillingMode: (harness: string) => string;
+  /** FEA-1407 sandbox base directory (empty ⇒ capture nothing). Read live. */
+  getSandboxBaseDirectory: () => string;
+  /** Durable dir for persisted catchup caches (e.g. userData/agent-monitor). */
+  stateDir: string;
+  /** Push a renderer live-update after an import batch wrote rows. */
+  emit: (sessionId?: string) => void;
+  /**
+   * Whether Claude's live file watcher should run. False when hooks are
+   * installed (hooks own live Claude capture). Boot import runs regardless.
+   */
+  shouldWatchClaude: () => boolean;
+  /** Key-free diagnostic sink. */
+  log?: (message: string) => void;
+  /** Injectable clock (tests pin it). */
+  now?: () => string;
+  /** Injectable collectors (tests pass fakes). Defaults to the five real ones. */
+  collectors?: HarnessCollector[];
+}
+
+export class CollectorManager {
+  private readonly options: CollectorManagerOptions;
+  private readonly log: (message: string) => void;
+  private readonly importer: Importer;
+  private readonly collectors: HarnessCollector[];
+  private readonly caches = new Map<string, CatchupCache>();
+  private readonly watchers: HarnessWatcher[] = [];
+  private started = false;
+  private stopped = false;
+
+  constructor(options: CollectorManagerOptions) {
+    this.options = options;
+    this.log = options.log ?? (() => {});
+    this.importer = createImporter(options.agentDatabase.connection, {
+      tokenUsage: options.agentDatabase.tokenUsage,
+      detectBillingMode: options.detectBillingMode,
+      now: options.now,
+      log: this.log,
+    });
+    this.collectors = options.collectors ?? defaultCollectors(options.stateDir);
+    for (const collector of this.collectors) {
+      if (!collector.batch) {
+        this.caches.set(
+          collector.key,
+          createCatchupCache({
+            persistPath: ingestCachePath(options.stateDir, collector.cacheName),
+          }),
+        );
+      }
+    }
+  }
+
+  /** Start boot import + live watchers. Never blocks boot; never throws. */
+  start(): void {
+    if (this.started) return;
+    this.started = true;
+    this.stopped = false;
+    for (const collector of this.collectors) {
+      const watch =
+        collector.key === "claude" ? this.options.shouldWatchClaude() : true;
+      if (watch) {
+        const watcher = createHarnessWatcher({
+          roots: () => collector.watchRoots(),
+          match: (filename) => collector.watchMatch(filename),
+          runImport: () => this.runImportFor(collector),
+          log: this.log,
+        });
+        watcher.start(); // start() performs the initial (boot) catch-up import
+        this.watchers.push(watcher);
+      } else {
+        // Claude with hooks on: boot historical import only, no live watcher.
+        setImmediate(() => void this.runImportFor(collector));
+      }
+    }
+  }
+
+  /** Stop watchers, halt in-flight imports, flush caches. */
+  stop(): void {
+    this.stopped = true;
+    for (const watcher of this.watchers) {
+      try {
+        watcher.stop();
+      } catch {
+        /* ignore */
+      }
+    }
+    this.watchers.length = 0;
+    for (const cache of this.caches.values()) {
+      cache.flush();
+    }
+    this.started = false;
+  }
+
+  private gate(session: NormalizedSession): boolean {
+    return isSessionInSandbox(session.cwd, this.options.getSandboxBaseDirectory());
+  }
+
+  private async runImportFor(collector: HarnessCollector): Promise<void> {
+    if (this.stopped) return;
+    try {
+      const imported = await this.importHarness(collector);
+      if (imported > 0) {
+        this.options.emit();
+      }
+    } catch (error) {
+      this.log(
+        `collector ${collector.key} import failed: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+  }
+
+  /** Idempotent import of every current source for one harness. Returns the count written. */
+  private async importHarness(collector: HarnessCollector): Promise<number> {
+    const cache = this.caches.get(collector.key);
+    const sources = collector.listSources();
+    let imported = 0;
+
+    for (const source of sources) {
+      if (this.stopped) break;
+
+      let stat = null;
+      if (!collector.batch && cache) {
+        const status = cache.isUnchanged(source);
+        if (status.unchanged) continue;
+        stat = status.stat;
+      }
+
+      let sessions: NormalizedSession[];
+      try {
+        sessions = await collector.parse(source);
+      } catch {
+        continue; // a partially-written file mid-turn is normal
+      }
+
+      for (const session of sessions) {
+        if (this.stopped) break;
+        if (!this.gate(session)) continue; // FEA-1407 fail-closed
+        const result = this.importer.importSession(session, collector.key);
+        if (!(result.skipped && !result.reactivated)) imported++;
+      }
+
+      if (!collector.batch && cache) cache.markSeenWith(source, stat);
+    }
+
+    if (!collector.batch && cache) {
+      cache.pruneTo(sources);
+      cache.flush();
+    }
+    return imported;
+  }
+}
+
+/** The five real harness collectors, wired with their durable state paths. */
+function defaultCollectors(stateDir: string): HarnessCollector[] {
+  return [
+    createClaudeCollector(),
+    createCodexCollector(),
+    createCursorCollector(),
+    createCopilotCollector(),
+    createOpencodeCollector({
+      fingerprintPath: ingestOpencodeFingerprintPath(stateDir),
+    }),
+  ];
+}
diff --git a/apps/desktop/src/main/collectors/copilot/copilot-collector.ts b/apps/desktop/src/main/collectors/copilot/copilot-collector.ts
new file mode 100644
index 00000000..c5b973c8
--- /dev/null
+++ b/apps/desktop/src/main/collectors/copilot/copilot-collector.ts
@@ -0,0 +1,104 @@
+/**
+ * @file copilot-collector.ts
+ * @description GitHub Copilot harness collector (FEA-1503). Copilot has TWO
+ * sources that both normalize to the same session shape:
+ *
+ * 1. Copilot Chat — VS Code extension JSON files under each workspace's
+ *    `chatSessions/` directory (parsed synchronously).
+ * 2. Copilot CLI — `events.jsonl` event logs under `~/.copilot/session-state/`
+ *    (parsed asynchronously, line by line).
+ *
+ * `parse(filePath)` dispatches by source: it builds lookup maps from the
+ * current `listChatSessionFiles()` / `listCliEventFiles()` listings to resolve
+ * the chat `workspacePath` or the cli `sessionId` for the given path. If the
+ * path is absent from the listings (e.g. a watcher fires before the next
+ * enumeration), it re-derives the context directly from the path so a fresh
+ * file still imports.
+ */
+import path from "node:path";
+import type { HarnessCollector, NormalizedSession } from "../types.js";
+import {
+  getVscodeWorkspaceStorageDir,
+  getCopilotCliSessionStateDir,
+  listChatSessionFiles,
+  listCliEventFiles,
+  readWorkspacePathFromHashDir,
+} from "./copilot-home.js";
+import { parseChatSessionFile, parseCliEventFile } from "./copilot-parser.js";
+
+/**
+ * Re-derive a chat session's workspacePath from its file path when the file is
+ * not present in the current listing. Chat files live at
+ * `<workspaceStorage>/<hash>/chatSessions/<file>.json`, so the hash dir (two
+ * levels up) holds the `workspace.json` we read.
+ */
+function workspacePathFromChatFilePath(filePath: string): string | null {
+  const chatDir = path.dirname(filePath);
+  const hashPath = path.dirname(chatDir);
+  return readWorkspacePathFromHashDir(hashPath);
+}
+
+/**
+ * Re-derive a CLI session id from its file path. CLI event files live at
+ * `<session-state>/<session-id>/events.jsonl`, so the parent directory name is
+ * the session id.
+ */
+function sessionIdFromCliFilePath(filePath: string): string {
+  return path.basename(path.dirname(filePath));
+}
+
+export function createCopilotCollector(): HarnessCollector {
+  return {
+    key: "copilot",
+    cacheName: "copilot",
+
+    watchRoots(): string[] {
+      return [getVscodeWorkspaceStorageDir(), getCopilotCliSessionStateDir()].filter(
+        (root) => root.length > 0,
+      );
+    },
+
+    watchMatch(filename: string): boolean {
+      return filename.endsWith(".json") || filename.endsWith(".jsonl");
+    },
+
+    listSources(): string[] {
+      const chat = listChatSessionFiles().map((f) => f.filePath);
+      const cli = listCliEventFiles().map((f) => f.filePath);
+      return [...chat, ...cli];
+    },
+
+    async parse(filePath: string): Promise<NormalizedSession[]> {
+      // Resolve chat workspacePath / cli sessionId from the current listings.
+      const chatFiles = listChatSessionFiles();
+      const cliFiles = listCliEventFiles();
+
+      const chatMatch = chatFiles.find((f) => f.filePath === filePath);
+      if (chatMatch) {
+        const session = parseChatSessionFile(filePath, chatMatch.workspacePath);
+        return session ? [session] : [];
+      }
+
+      const cliMatch = cliFiles.find((f) => f.filePath === filePath);
+      if (cliMatch) {
+        const session = await parseCliEventFile(filePath, cliMatch.sessionId);
+        return session ? [session] : [];
+      }
+
+      // Not in the listings — re-derive context from the path shape so a
+      // newly-written file still imports.
+      if (filePath.endsWith(".json")) {
+        const workspacePath = workspacePathFromChatFilePath(filePath);
+        const session = parseChatSessionFile(filePath, workspacePath);
+        return session ? [session] : [];
+      }
+      if (filePath.endsWith(".jsonl")) {
+        const sessionId = sessionIdFromCliFilePath(filePath);
+        const session = await parseCliEventFile(filePath, sessionId);
+        return session ? [session] : [];
+      }
+
+      return [];
+    },
+  };
+}
diff --git a/apps/desktop/src/main/collectors/copilot/copilot-home.ts b/apps/desktop/src/main/collectors/copilot/copilot-home.ts
new file mode 100644
index 00000000..abcf30da
--- /dev/null
+++ b/apps/desktop/src/main/collectors/copilot/copilot-home.ts
@@ -0,0 +1,129 @@
+/**
+ * @file copilot-home.ts
+ * @description Centralized GitHub Copilot session path management. Resolves
+ * paths for:
+ *
+ * 1. Copilot Chat (VS Code extension): JSON session files under
+ *    ~/Library/Application Support/Code/User/workspaceStorage/<hash>/chatSessions/
+ *
+ * 2. Copilot CLI (`gh copilot`): JSONL event logs under
+ *    ~/.copilot/session-state/<session-id>/events.jsonl
+ *
+ * Both locations are scanned opportunistically — if neither exists the tool
+ * is simply not installed or hasn't been used.
+ *
+ * Ported from `scripts/agent-monitor-copilot/copilot-home.js` (logic preserved).
+ */
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+export function getCopilotCliHome(): string {
+  const raw = process.env.COPILOT_HOME;
+  if (raw && raw.trim()) {
+    return raw.trim().replace(/^~(?=\/)/, os.homedir());
+  }
+  return path.join(os.homedir(), ".copilot");
+}
+
+export function getCopilotCliSessionStateDir(): string {
+  return path.join(getCopilotCliHome(), "session-state");
+}
+
+/**
+ * VS Code workspace storage root. Platform-dependent.
+ */
+export function getVscodeWorkspaceStorageDir(): string {
+  const home = os.homedir();
+  switch (process.platform) {
+    case "darwin":
+      return path.join(home, "Library", "Application Support", "Code", "User", "workspaceStorage");
+    case "win32":
+      return path.join(process.env.APPDATA || path.join(home, "AppData", "Roaming"),
+        "Code", "User", "workspaceStorage");
+    default: // linux
+      return path.join(home, ".config", "Code", "User", "workspaceStorage");
+  }
+}
+
+export function workspacePathFromUri(folder: unknown): string | null {
+  if (typeof folder !== "string" || folder.length === 0) return null;
+  if (!folder.startsWith("file:")) return folder;
+  try {
+    return fileURLToPath(folder);
+  } catch {
+    try {
+      return decodeURIComponent(folder.replace(/^file:\/\//, ""));
+    } catch {
+      return folder.replace(/^file:\/\//, "");
+    }
+  }
+}
+
+export function readWorkspacePathFromHashDir(hashPath: string): string | null {
+  try {
+    const wsJson = JSON.parse(
+      fs.readFileSync(path.join(hashPath, "workspace.json"), "utf8"),
+    ) as Record<string, unknown>;
+    return workspacePathFromUri(wsJson.folder || wsJson.workspace || "");
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Discover all chatSession JSON files across all VS Code workspaces.
+ * Returns array of { filePath, workspacePath } where workspacePath is resolved
+ * from the workspace.json in the hash directory.
+ */
+export function listChatSessionFiles(): { filePath: string; workspacePath: string | null }[] {
+  const wsRoot = getVscodeWorkspaceStorageDir();
+  if (!fs.existsSync(wsRoot)) return [];
+  const results: { filePath: string; workspacePath: string | null }[] = [];
+
+  let hashDirs: fs.Dirent[];
+  try { hashDirs = fs.readdirSync(wsRoot, { withFileTypes: true }); } catch { return []; }
+
+  for (const hashDir of hashDirs) {
+    if (!hashDir.isDirectory()) continue;
+    const hashPath = path.join(wsRoot, hashDir.name);
+    const chatDir = path.join(hashPath, "chatSessions");
+    if (!fs.existsSync(chatDir)) continue;
+
+    const workspacePath = readWorkspacePathFromHashDir(hashPath);
+
+    let files: fs.Dirent[];
+    try { files = fs.readdirSync(chatDir, { withFileTypes: true }); } catch { continue; }
+    for (const f of files) {
+      if (f.isFile() && f.name.endsWith(".json")) {
+        results.push({
+          filePath: path.join(chatDir, f.name),
+          workspacePath,
+        });
+      }
+    }
+  }
+  return results;
+}
+
+/**
+ * Collect all Copilot CLI event JSONL files under ~/.copilot/session-state/.
+ */
+export function listCliEventFiles(): { filePath: string; sessionId: string }[] {
+  const root = getCopilotCliSessionStateDir();
+  if (!fs.existsSync(root)) return [];
+  const results: { filePath: string; sessionId: string }[] = [];
+
+  let sessionDirs: fs.Dirent[];
+  try { sessionDirs = fs.readdirSync(root, { withFileTypes: true }); } catch { return []; }
+
+  for (const dir of sessionDirs) {
+    if (!dir.isDirectory()) continue;
+    const eventsFile = path.join(root, dir.name, "events.jsonl");
+    if (fs.existsSync(eventsFile)) {
+      results.push({ filePath: eventsFile, sessionId: dir.name });
+    }
+  }
+  return results;
+}
diff --git a/apps/desktop/src/main/collectors/copilot/copilot-parser.ts b/apps/desktop/src/main/collectors/copilot/copilot-parser.ts
new file mode 100644
index 00000000..75aa1936
--- /dev/null
+++ b/apps/desktop/src/main/collectors/copilot/copilot-parser.ts
@@ -0,0 +1,547 @@
+/**
+ * @file copilot-parser.ts
+ * @description Parse GitHub Copilot session data into the normalized session
+ * object consumed by the collection layer. Handles two formats:
+ *
+ * 1. Copilot Chat (VS Code extension): JSON files with conversation turns
+ * 2. Copilot CLI (`gh copilot`): JSONL event log files
+ *
+ * Both produce the same normalized shape so Copilot sessions render through
+ * the unchanged dashboard UI.
+ *
+ * Ported from `scripts/agent-monitor-copilot/copilot-parser.js` (logic
+ * preserved).
+ */
+import fs from "node:fs";
+import path from "node:path";
+import readline from "node:readline";
+import {
+  extractErrorMessage,
+  toIso,
+  safeJson,
+  pushTurnDuration,
+} from "../parser-utils.js";
+import type {
+  NormalizedSession,
+  NormalizedToolUse,
+  NormalizedApiError,
+  NormalizedTurnDuration,
+} from "../types.js";
+
+/** True when `value` is a non-null object (and not an array). */
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+/** Read a property off an unknown value without throwing. */
+function get(value: unknown, key: string): unknown {
+  if (isRecord(value)) return value[key];
+  return undefined;
+}
+
+function hasRenderableContent(value: unknown, depth = 0): boolean {
+  if (value == null || depth > 4) return false;
+  if (typeof value === "string") return value.trim().length > 0;
+  if (typeof value === "number" || typeof value === "boolean") return true;
+  if (Array.isArray(value)) return value.some((entry) => hasRenderableContent(entry, depth + 1));
+  if (typeof value === "object") {
+    return Object.values(value as Record<string, unknown>).some((entry) =>
+      hasRenderableContent(entry, depth + 1),
+    );
+  }
+  return false;
+}
+
+function collectToolCalls(value: unknown, depth = 0, out: unknown[] = []): unknown[] {
+  if (value == null || depth > 4) return out;
+  if (Array.isArray(value)) {
+    for (const entry of value) collectToolCalls(entry, depth + 1, out);
+    return out;
+  }
+  if (typeof value !== "object") return out;
+
+  const obj = value as Record<string, unknown>;
+  for (const key of ["toolCalls", "tool_calls", "functionCalls"]) {
+    const calls = obj[key];
+    if (Array.isArray(calls)) {
+      for (const call of calls) out.push(call);
+    }
+  }
+
+  for (const key of ["message", "request", "prompt", "input", "response", "result", "reply", "output"]) {
+    collectToolCalls(obj[key], depth + 1, out);
+  }
+  return out;
+}
+
+interface ChatEntry {
+  role: "user" | "assistant";
+  timestamp: unknown;
+  toolCalls?: unknown[];
+  thinking?: boolean;
+  error?: string | null;
+}
+
+function normalizeChatRequest(request: unknown, sessionData: Record<string, unknown>): ChatEntry[] {
+  if (!request || typeof request !== "object") return [];
+  const req = request as Record<string, unknown>;
+
+  const requestTimestamp =
+    req.timestamp ||
+    req.created_at ||
+    req.createdAt ||
+    req.requestDate ||
+    get(req.message, "timestamp") ||
+    get(req.message, "createdAt") ||
+    sessionData.creationDate ||
+    null;
+  const responseTimestamp =
+    req.responseTimestamp ||
+    req.responseDate ||
+    req.updatedAt ||
+    get(req.response, "timestamp") ||
+    get(req.result, "timestamp") ||
+    sessionData.lastMessageDate ||
+    requestTimestamp;
+  const userPayload =
+    req.message ??
+    req.request ??
+    req.prompt ??
+    req.input;
+  const assistantPayload =
+    req.response ??
+    req.result ??
+    req.reply ??
+    req.output;
+  const toolCalls = collectToolCalls(req);
+  const assistantError = extractErrorMessage(
+    req.responseError ??
+      req.error ??
+      get(req.result, "error") ??
+      get(req.response, "error"),
+  );
+
+  const entries: ChatEntry[] = [];
+  if (
+    hasRenderableContent(userPayload) ||
+    req.id != null ||
+    req.requestId != null
+  ) {
+    entries.push({
+      role: "user",
+      timestamp: requestTimestamp,
+    });
+  }
+
+  if (
+    hasRenderableContent(assistantPayload) ||
+    assistantError != null ||
+    toolCalls.length > 0 ||
+    req.response != null ||
+    req.result != null ||
+    req.reply != null ||
+    req.output != null
+  ) {
+    entries.push({
+      role: "assistant",
+      timestamp: responseTimestamp,
+      toolCalls,
+      thinking: Boolean(
+        req.thinking ||
+          req.reasoning ||
+          get(req.response, "thinking") ||
+          get(req.response, "reasoning") ||
+          get(req.result, "thinking") ||
+          get(req.result, "reasoning"),
+      ),
+      error: assistantError,
+    });
+  }
+
+  return entries;
+}
+
+function normalizeChatMessages(data: Record<string, unknown>): unknown[] {
+  for (const key of ["messages", "turns", "history"]) {
+    const value = data[key];
+    if (Array.isArray(value) && value.length > 0) return value;
+  }
+
+  const requests = Array.isArray(data.requests) ? data.requests : [];
+  return requests.flatMap((request) => normalizeChatRequest(request, data));
+}
+
+interface TokenFields {
+  input: number;
+  output: number;
+  cacheRead: number;
+  cacheWrite: number;
+}
+
+/**
+ * Parse a Copilot Chat JSON session file (VS Code extension).
+ * Recent VS Code builds persist these as top-level metadata plus `requests[]`,
+ * while older shapes may store direct `messages[]` / `turns[]` arrays.
+ */
+export function parseChatSessionFile(
+  filePath: string,
+  workspacePath: string | null,
+): NormalizedSession | null {
+  let data: unknown;
+  try {
+    data = JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } catch { return null; }
+
+  if (!data || typeof data !== "object") return null;
+  const dataObj = data as Record<string, unknown>;
+
+  const sessionId = String(
+    dataObj.sessionId || dataObj.id || path.basename(filePath, ".json"),
+  );
+
+  // P1 Fix: extract token usage from raw requests BEFORE normalization,
+  // since normalizeChatMessages reduces each request to {role, timestamp}
+  // and drops the original usage/response payloads.
+  const rawRequests = Array.isArray(dataObj.requests) ? dataObj.requests : [];
+  const requestTokenFields: TokenFields = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+  for (const req of rawRequests) {
+    if (!req || typeof req !== "object") continue;
+    const reqObj = req as Record<string, unknown>;
+    const usageInfo =
+      reqObj.usage || reqObj.tokenUsage || reqObj.token_count ||
+      get(reqObj.response, "usage") || get(reqObj.result, "usage") || null;
+    if (usageInfo && typeof usageInfo === "object") {
+      const u = usageInfo as Record<string, unknown>;
+      if (u.input_tokens != null) requestTokenFields.input += Number(u.input_tokens);
+      if (u.output_tokens != null) requestTokenFields.output += Number(u.output_tokens);
+      if (u.prompt_tokens != null) requestTokenFields.input += Number(u.prompt_tokens);
+      if (u.completion_tokens != null) requestTokenFields.output += Number(u.completion_tokens);
+      if (u.cache_read_tokens != null) requestTokenFields.cacheRead += Number(u.cache_read_tokens);
+      if (u.cached_input_tokens != null) requestTokenFields.cacheRead += Number(u.cached_input_tokens);
+      if (u.cache_write_tokens != null) requestTokenFields.cacheWrite += Number(u.cache_write_tokens);
+      if (u.cache_creation_input_tokens != null) requestTokenFields.cacheWrite += Number(u.cache_creation_input_tokens);
+    }
+  }
+
+  const messages = normalizeChatMessages(dataObj);
+  if (!Array.isArray(messages) || messages.length === 0) return null;
+
+  let firstTimestamp: string | null = null;
+  let lastTimestamp: string | null = null;
+  let userMessageCount = 0;
+  let assistantMessageCount = 0;
+  const messageTimestamps: string[] = [];
+  const toolUses: NormalizedToolUse[] = [];
+  const turnDurations: NormalizedTurnDuration[] = [];
+  const apiErrors: NormalizedApiError[] = [];
+  let thinkingBlockCount = 0;
+  const toolResultErrors: NormalizedSession["toolResultErrors"] = [];
+  const tokenFields: TokenFields = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+  let pendingTurnStartedAt: string | null = null;
+
+  const noteTs = (raw: unknown): string | null => {
+    const iso = toIso(raw);
+    if (!iso) return null;
+    if (!firstTimestamp || iso < firstTimestamp) firstTimestamp = iso;
+    if (!lastTimestamp || iso > lastTimestamp) lastTimestamp = iso;
+    return iso;
+  };
+
+  for (const msg of messages) {
+    if (!msg || typeof msg !== "object") continue;
+    const msgObj = msg as Record<string, unknown>;
+    const ts = msgObj.timestamp || msgObj.created_at || msgObj.createdAt || msgObj.date || null;
+    const iso = noteTs(ts);
+    const role = msgObj.role || msgObj.author || msgObj.type || "";
+
+    if (role === "user" || role === "human") {
+      userMessageCount++;
+      if (iso) pendingTurnStartedAt = iso;
+    } else if (role === "assistant" || role === "copilot" || role === "bot") {
+      assistantMessageCount++;
+      if (iso) messageTimestamps.push(iso);
+      pushTurnDuration(turnDurations, pendingTurnStartedAt, iso);
+      pendingTurnStartedAt = null;
+    }
+
+    // Tool uses embedded in messages
+    const calls =
+      msgObj.toolCalls ||
+      msgObj.tool_calls ||
+      msgObj.functionCalls ||
+      collectToolCalls(msgObj);
+    if (Array.isArray(calls)) {
+      for (const call of calls) {
+        if (!call) continue;
+        const callObj = call as Record<string, unknown>;
+        toolUses.push({
+          name: String(callObj.name || get(callObj.function, "name") || "copilot_tool"),
+          timestamp: iso || firstTimestamp,
+          input: safeJson(callObj.arguments || callObj.input || callObj.parameters),
+        });
+      }
+    }
+
+    // Thinking blocks
+    if (msgObj.thinking || msgObj.reasoning) thinkingBlockCount++;
+
+    const errorMessage = extractErrorMessage(msgObj.error);
+    if (errorMessage) {
+      apiErrors.push({
+        type: "error",
+        message: errorMessage,
+        timestamp: iso,
+      });
+    }
+
+    // Token usage embedded in messages/requests
+    const usageInfo =
+      msgObj.usage || msgObj.tokenUsage || msgObj.token_count ||
+      get(msgObj.response, "usage") || get(msgObj.result, "usage") || null;
+    if (usageInfo && typeof usageInfo === "object") {
+      const u = usageInfo as Record<string, unknown>;
+      if (u.input_tokens != null) tokenFields.input += Number(u.input_tokens);
+      if (u.output_tokens != null) tokenFields.output += Number(u.output_tokens);
+      if (u.prompt_tokens != null) tokenFields.input += Number(u.prompt_tokens);
+      if (u.completion_tokens != null) tokenFields.output += Number(u.completion_tokens);
+      if (u.cache_read_tokens != null) tokenFields.cacheRead += Number(u.cache_read_tokens);
+      if (u.cached_input_tokens != null) tokenFields.cacheRead += Number(u.cached_input_tokens);
+      if (u.cache_write_tokens != null) tokenFields.cacheWrite += Number(u.cache_write_tokens);
+      if (u.cache_creation_input_tokens != null) tokenFields.cacheWrite += Number(u.cache_creation_input_tokens);
+    }
+  }
+
+  // Merge request-level tokens (from raw requests before normalization)
+  // with message-level tokens. Use summation since each request is unique.
+  tokenFields.input += requestTokenFields.input;
+  tokenFields.output += requestTokenFields.output;
+  tokenFields.cacheRead += requestTokenFields.cacheRead;
+  tokenFields.cacheWrite += requestTokenFields.cacheWrite;
+
+  // Token usage from top-level session data
+  const topUsage = dataObj.usage || dataObj.tokenUsage || dataObj.token_count || null;
+  if (topUsage && typeof topUsage === "object") {
+    const u = topUsage as Record<string, unknown>;
+    if (u.input_tokens != null) tokenFields.input = Math.max(tokenFields.input, Number(u.input_tokens));
+    if (u.output_tokens != null) tokenFields.output = Math.max(tokenFields.output, Number(u.output_tokens));
+    if (u.prompt_tokens != null) tokenFields.input = Math.max(tokenFields.input, Number(u.prompt_tokens));
+    if (u.completion_tokens != null) tokenFields.output = Math.max(tokenFields.output, Number(u.completion_tokens));
+    if (u.cache_read_tokens != null) tokenFields.cacheRead = Math.max(tokenFields.cacheRead, Number(u.cache_read_tokens));
+    if (u.cached_input_tokens != null) tokenFields.cacheRead = Math.max(tokenFields.cacheRead, Number(u.cached_input_tokens));
+    if (u.cache_write_tokens != null) tokenFields.cacheWrite = Math.max(tokenFields.cacheWrite, Number(u.cache_write_tokens));
+    // P2 Fix: also map cache_creation_input_tokens to cacheWrite (alias)
+    if (u.cache_creation_input_tokens != null) tokenFields.cacheWrite = Math.max(tokenFields.cacheWrite, Number(u.cache_creation_input_tokens));
+  }
+
+  if (!firstTimestamp) {
+    // Fall back to file mtime
+    try {
+      const stat = fs.statSync(filePath);
+      firstTimestamp = stat.birthtime?.toISOString() || stat.mtime.toISOString();
+      lastTimestamp = stat.mtime.toISOString();
+    } catch { return null; }
+  }
+
+  const model = (dataObj.model || dataObj.modelId || null) as string | null;
+  const cwd = (workspacePath || dataObj.cwd || dataObj.workspaceFolder || null) as string | null;
+
+  let fileModifiedAt: number | null = null;
+  try { fileModifiedAt = fs.statSync(filePath).mtimeMs; } catch { /* non-fatal */ }
+
+  const projectName = cwd ? path.basename(cwd) : `Copilot Chat ${sessionId.slice(0, 8)}`;
+
+  const tokensByModel: NormalizedSession["tokensByModel"] = {};
+  if (tokenFields.input || tokenFields.output || tokenFields.cacheRead || tokenFields.cacheWrite) {
+    const key = model || "copilot-default";
+    tokensByModel[key] = {
+      input: tokenFields.input,
+      output: tokenFields.output,
+      cacheRead: tokenFields.cacheRead,
+      cacheWrite: tokenFields.cacheWrite,
+    };
+  }
+
+  return {
+    sessionId: `copilot-chat-${sessionId}`,
+    name: projectName,
+    cwd,
+    model,
+    version: null,
+    slug: null,
+    gitBranch: null,
+    startedAt: firstTimestamp,
+    endedAt: lastTimestamp,
+    teams: [],
+    userMessages: userMessageCount,
+    assistantMessages: assistantMessageCount,
+    tokensByModel,
+    messageTimestamps,
+    toolUses,
+    compactions: [],
+    apiErrors,
+    fileModifiedAt,
+    turnDurations,
+    entrypoint: "copilot",
+    permissionMode: null,
+    thinkingBlockCount,
+    toolResultErrors,
+    usageExtras: { service_tiers: [], speeds: [], inference_geos: [] },
+  };
+}
+
+/**
+ * Parse a Copilot CLI events.jsonl file.
+ */
+export async function parseCliEventFile(
+  filePath: string,
+  sessionId: string,
+): Promise<NormalizedSession | null> {
+  const rl = readline.createInterface({
+    input: fs.createReadStream(filePath, { encoding: "utf8" }),
+    crlfDelay: Infinity,
+  });
+
+  let cwd: string | null = null;
+  let model: string | null = null;
+  let version: string | null = null;
+  let firstTimestamp: string | null = null;
+  let lastTimestamp: string | null = null;
+  let userMessageCount = 0;
+  let assistantMessageCount = 0;
+  const messageTimestamps: string[] = [];
+  const toolUses: NormalizedToolUse[] = [];
+  const turnDurations: NormalizedTurnDuration[] = [];
+  const apiErrors: NormalizedApiError[] = [];
+  let thinkingBlockCount = 0;
+  const toolResultErrors: NormalizedSession["toolResultErrors"] = [];
+  let tokenInput = 0;
+  let tokenOutput = 0;
+  let tokenCacheRead = 0;
+  let tokenCacheWrite = 0;
+  let tokenReasoning = 0;
+  let pendingTurnStartedAt: string | null = null;
+
+  const noteTs = (raw: unknown): string | null => {
+    const iso = toIso(raw);
+    if (!iso) return null;
+    if (!firstTimestamp || iso < firstTimestamp) firstTimestamp = iso;
+    if (!lastTimestamp || iso > lastTimestamp) lastTimestamp = iso;
+    return iso;
+  };
+
+  for await (const line of rl) {
+    if (!line.trim()) continue;
+    let rec: unknown;
+    try { rec = JSON.parse(line); } catch { continue; }
+    if (!rec || typeof rec !== "object") continue;
+    const recObj = rec as Record<string, unknown>;
+
+    const ts = recObj.timestamp || recObj.ts || recObj.created_at || null;
+    const iso = noteTs(ts);
+    const type = recObj.type || recObj.event || "";
+    const payload = (recObj.payload || recObj.data || recObj) as Record<string, unknown>;
+
+    // Session metadata
+    if (type === "session_start" || type === "session_created" || type === "init") {
+      if (!cwd) cwd = (payload.cwd || payload.workdir || null) as string | null;
+      if (!version) version = (payload.version || payload.cli_version || null) as string | null;
+      if (!model) model = (payload.model || null) as string | null;
+    }
+
+    // Messages
+    if (type === "user_message" || type === "user_input" || type === "prompt") {
+      userMessageCount++;
+      if (iso) pendingTurnStartedAt = iso;
+    }
+    if (type === "assistant_message" || type === "response" || type === "completion") {
+      assistantMessageCount++;
+      if (iso) messageTimestamps.push(iso);
+      pushTurnDuration(turnDurations, pendingTurnStartedAt, iso);
+      pendingTurnStartedAt = null;
+    }
+
+    // Tool calls
+    if (type === "tool_call" || type === "function_call" || type === "command") {
+      toolUses.push({
+        name: String(payload.name || payload.tool || payload.command || "copilot_tool"),
+        timestamp: iso || firstTimestamp,
+        input: safeJson(payload.arguments || payload.input),
+      });
+    }
+
+    // Token usage
+    if (type === "usage" || type === "token_count" || type === "metrics") {
+      const info = (payload.usage || payload) as Record<string, unknown>;
+      if (info.input_tokens != null) tokenInput = Number(info.input_tokens);
+      if (info.output_tokens != null) tokenOutput = Number(info.output_tokens);
+      if (info.prompt_tokens != null) tokenInput = Number(info.prompt_tokens);
+      if (info.completion_tokens != null) tokenOutput = Number(info.completion_tokens);
+      if (info.cache_read_tokens != null) tokenCacheRead = Number(info.cache_read_tokens);
+      if (info.cached_input_tokens != null) tokenCacheRead = Number(info.cached_input_tokens);
+      if (info.cache_write_tokens != null) tokenCacheWrite = Number(info.cache_write_tokens);
+      if (info.cache_creation_input_tokens != null) tokenCacheWrite = Number(info.cache_creation_input_tokens);
+      if (info.reasoning_tokens != null) tokenReasoning = Number(info.reasoning_tokens);
+      if (info.reasoning_output_tokens != null) tokenReasoning = Number(info.reasoning_output_tokens);
+      if (payload.model) model = payload.model as string;
+    }
+
+    // Errors
+    if (type === "error" || type === "api_error") {
+      apiErrors.push({
+        type: String(type),
+        message: String(payload.message || payload.error || "Copilot CLI error"),
+        timestamp: iso,
+      });
+    }
+
+    // Thinking
+    if (type === "reasoning" || type === "thinking") {
+      thinkingBlockCount++;
+    }
+  }
+
+  if (!firstTimestamp) return null;
+
+  const tokensByModel: NormalizedSession["tokensByModel"] = {};
+  if (tokenInput || tokenOutput || tokenCacheRead || tokenCacheWrite || tokenReasoning) {
+    const key = model || "copilot-default";
+    tokensByModel[key] = {
+      input: tokenInput,
+      output: tokenOutput + tokenReasoning,
+      cacheRead: tokenCacheRead,
+      cacheWrite: tokenCacheWrite,
+    };
+  }
+
+  let fileModifiedAt: number | null = null;
+  try { fileModifiedAt = fs.statSync(filePath).mtimeMs; } catch { /* non-fatal */ }
+
+  const projectName = cwd ? path.basename(cwd) : `Copilot CLI ${sessionId.slice(0, 8)}`;
+
+  return {
+    sessionId: `copilot-cli-${sessionId}`,
+    name: projectName,
+    cwd,
+    model,
+    version,
+    slug: null,
+    gitBranch: null,
+    startedAt: firstTimestamp,
+    endedAt: lastTimestamp,
+    teams: [],
+    userMessages: userMessageCount,
+    assistantMessages: assistantMessageCount,
+    tokensByModel,
+    messageTimestamps,
+    toolUses,
+    compactions: [],
+    apiErrors,
+    fileModifiedAt,
+    turnDurations,
+    entrypoint: "copilot",
+    permissionMode: null,
+    thinkingBlockCount,
+    toolResultErrors,
+    usageExtras: { service_tiers: [], speeds: [], inference_geos: [] },
+  };
+}
diff --git a/apps/desktop/src/main/collectors/cursor/cursor-collector.ts b/apps/desktop/src/main/collectors/cursor/cursor-collector.ts
new file mode 100644
index 00000000..a8515334
--- /dev/null
+++ b/apps/desktop/src/main/collectors/cursor/cursor-collector.ts
@@ -0,0 +1,30 @@
+/**
+ * @file cursor-collector.ts
+ * @description Cursor harness collector descriptor (FEA-1503). Drives the
+ * generic boot importer / watcher through the uniform `HarnessCollector` shape:
+ * `home` (path/env resolution via cursor-home) + `parser` (transcript JSONL →
+ * NormalizedSession via cursor-parser) + this small descriptor.
+ */
+import type { HarnessCollector, NormalizedSession } from "../types.js";
+import { getCursorProjectsDir, listAllTranscriptFiles } from "./cursor-home.js";
+import { parseTranscriptFile } from "./cursor-parser.js";
+
+export function createCursorCollector(): HarnessCollector {
+  return {
+    key: "cursor",
+    cacheName: "cursor",
+    watchRoots(): string[] {
+      return [getCursorProjectsDir()];
+    },
+    watchMatch(filename: string): boolean {
+      return filename.endsWith(".jsonl");
+    },
+    listSources(): string[] {
+      return listAllTranscriptFiles();
+    },
+    async parse(filePath: string): Promise<NormalizedSession[]> {
+      const s = await parseTranscriptFile(filePath);
+      return s ? [s] : [];
+    },
+  };
+}
diff --git a/apps/desktop/src/main/collectors/cursor/cursor-home.ts b/apps/desktop/src/main/collectors/cursor/cursor-home.ts
new file mode 100644
index 00000000..7cc99455
--- /dev/null
+++ b/apps/desktop/src/main/collectors/cursor/cursor-home.ts
@@ -0,0 +1,79 @@
+/**
+ * @file cursor-home.ts
+ * @description Centralized Cursor session path management. Resolves paths for
+ * Cursor's background agent JSONL transcripts stored under
+ * `~/.cursor/projects/<project-id>/agent-transcripts/<session-id>/`.
+ *
+ * Cursor also stores standard chat sessions in a SQLite database
+ * (`state.vscdb`) under VS Code workspace storage, but those are opaque
+ * key-value blobs — this module focuses on the structured agent transcripts
+ * that yield the same telemetry the dashboard expects.
+ *
+ * Ported from the vendor `scripts/agent-monitor-cursor/cursor-home.js`; logic
+ * preserved exactly (env precedence, path resolution, depth-bounded walk).
+ */
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+export function getCursorHome(): string {
+  const raw = process.env.CURSOR_HOME;
+  if (raw && raw.trim()) {
+    return raw.trim().replace(/^~(?=\/)/, os.homedir());
+  }
+  return path.join(os.homedir(), ".cursor");
+}
+
+export function getCursorProjectsDir(): string {
+  return path.join(getCursorHome(), "projects");
+}
+
+/**
+ * Derive a stable session id from an agent transcript path.
+ * Cursor stores transcripts at:
+ *   ~/.cursor/projects/<project-id>/agent-transcripts/<session-id>/<session-id>.jsonl
+ * The session-id directory name is the canonical id.
+ */
+export function sessionIdFromTranscriptPath(filePath: string): string {
+  // The parent directory name is the session id
+  return path.basename(path.dirname(filePath));
+}
+
+/**
+ * Recursively collect every `*.jsonl` transcript file under the projects root.
+ * Cursor nests by project → agent-transcripts → session-id, but we walk
+ * generically. Depth-bounded and error-tolerant.
+ */
+export function collectTranscriptFiles(
+  root: string,
+  { maxDepth = 8 }: { maxDepth?: number } = {},
+): string[] {
+  const out: string[] = [];
+  if (!root || !fs.existsSync(root)) return out;
+  const walk = (dir: string, depth: number): void => {
+    if (depth > maxDepth) return;
+    let entries: fs.Dirent[];
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      const full = path.join(dir, e.name);
+      if (e.isDirectory()) {
+        walk(full, depth + 1);
+      } else if (e.isFile() && e.name.endsWith(".jsonl")) {
+        out.push(full);
+      }
+    }
+  };
+  walk(root, 0);
+  return out;
+}
+
+/**
+ * All Cursor agent transcript files.
+ */
+export function listAllTranscriptFiles(): string[] {
+  return collectTranscriptFiles(getCursorProjectsDir());
+}
diff --git a/apps/desktop/src/main/collectors/cursor/cursor-parser.ts b/apps/desktop/src/main/collectors/cursor/cursor-parser.ts
new file mode 100644
index 00000000..d4a16fa1
--- /dev/null
+++ b/apps/desktop/src/main/collectors/cursor/cursor-parser.ts
@@ -0,0 +1,284 @@
+/**
+ * @file cursor-parser.ts
+ * @description Parse a Cursor agent transcript JSONL file into the normalized
+ * session object consumed by importSession(). Cursor's background agent
+ * transcripts use a format similar to Codex rollouts — each line is a JSON
+ * record with a type, payload, and timestamp. The parser is intentionally
+ * tolerant of format drift across Cursor versions.
+ *
+ * Ported from the vendor `scripts/agent-monitor-cursor/cursor-parser.js`; all
+ * parsing/path logic, field names, token math (non-cumulative, last value
+ * wins), and timestamp handling preserved exactly.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import readline from "node:readline";
+
+import { toIso, safeJson, pushTurnDuration } from "../parser-utils.js";
+import type {
+  NormalizedApiError,
+  NormalizedSession,
+  NormalizedToolResultError,
+  NormalizedToolUse,
+  NormalizedTurnDuration,
+} from "../types.js";
+import { sessionIdFromTranscriptPath } from "./cursor-home.js";
+
+/** Coerce an unknown JSON value to a plain object bag for tolerant field access. */
+function asRecord(value: unknown): Record<string, unknown> {
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    return value as Record<string, unknown>;
+  }
+  return {};
+}
+
+/** Read a string-or-null field tolerantly (Cursor records are untyped JSON). */
+function asStringOrNull(value: unknown): string | null {
+  return typeof value === "string" ? value : null;
+}
+
+/** Read a numeric field tolerantly. */
+function asNumberOrNull(value: unknown): number | null {
+  return typeof value === "number" ? value : null;
+}
+
+/**
+ * Parse a single Cursor agent transcript JSONL file.
+ * Returns null when the file carries no usable timestamp.
+ */
+export async function parseTranscriptFile(filePath: string): Promise<NormalizedSession | null> {
+  const sessionId = sessionIdFromTranscriptPath(filePath);
+
+  const rl = readline.createInterface({
+    input: fs.createReadStream(filePath, { encoding: "utf8" }),
+    crlfDelay: Infinity,
+  });
+
+  let cwd: string | null = null;
+  let model: string | null = null;
+  let version: string | null = null;
+  let gitBranch: string | null = null;
+  let firstTimestamp: string | null = null;
+  let lastTimestamp: string | null = null;
+  let userMessageCount = 0;
+  let assistantMessageCount = 0;
+  const messageTimestamps: string[] = [];
+  const toolUses: NormalizedToolUse[] = [];
+  const turnDurations: NormalizedTurnDuration[] = [];
+  const apiErrors: NormalizedApiError[] = [];
+  let thinkingBlockCount = 0;
+  const toolResultErrors: NormalizedToolResultError[] = [];
+  let tokenInput = 0;
+  let tokenOutput = 0;
+  let tokenCacheRead = 0;
+  let tokenCacheWrite = 0;
+  let pendingTurnStartedAt: string | null = null;
+
+  const noteTs = (raw: unknown): string | null => {
+    const iso = toIso(raw);
+    if (!iso) return null;
+    if (!firstTimestamp || iso < firstTimestamp) firstTimestamp = iso;
+    if (!lastTimestamp || iso > lastTimestamp) lastTimestamp = iso;
+    return iso;
+  };
+
+  for await (const line of rl) {
+    if (!line.trim()) continue;
+    let rec: unknown;
+    try {
+      rec = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (!rec || typeof rec !== "object") continue;
+
+    const record = rec as Record<string, unknown>;
+    const ts = record.timestamp || record.ts || record.created_at || null;
+    const iso = noteTs(ts);
+    const type = typeof record.type === "string" ? record.type : "";
+    const payload = asRecord(record.payload ?? record.data ?? record);
+
+    // Session metadata
+    if (
+      type === "session_meta" ||
+      type === "session.created" ||
+      type === "session_start" ||
+      (!type && (payload.cwd || payload.workdir || payload.workspace))
+    ) {
+      if (!cwd) {
+        cwd =
+          asStringOrNull(payload.cwd) ??
+          asStringOrNull(payload.workdir) ??
+          asStringOrNull(payload.workspace);
+      }
+      if (!version) {
+        version =
+          asStringOrNull(payload.version) ??
+          asStringOrNull(payload.cli_version) ??
+          asStringOrNull(payload.cursor_version);
+      }
+      if (!model) model = asStringOrNull(payload.model);
+      if (!gitBranch) {
+        if (typeof payload.git === "object" && payload.git) {
+          const git = payload.git as Record<string, unknown>;
+          gitBranch = asStringOrNull(git.branch) ?? asStringOrNull(git.ref);
+        } else if (payload.git_branch) {
+          gitBranch = asStringOrNull(payload.git_branch);
+        }
+      }
+    }
+
+    // Model override (turn-level is authoritative)
+    if (type === "turn_context" || type === "turn.context" || type === "model_context") {
+      if (payload.model) model = asStringOrNull(payload.model);
+      if (!cwd && payload.cwd) cwd = asStringOrNull(payload.cwd);
+    }
+
+    // User messages
+    if (
+      type === "user_message" ||
+      type === "human_message" ||
+      (type === "message" && (payload.role === "user" || payload.author === "user"))
+    ) {
+      userMessageCount++;
+      if (iso) pendingTurnStartedAt = iso;
+    }
+
+    // Assistant messages
+    if (
+      type === "assistant_message" ||
+      type === "agent_message" ||
+      (type === "message" && (payload.role === "assistant" || payload.author === "assistant"))
+    ) {
+      assistantMessageCount++;
+      if (iso) messageTimestamps.push(iso);
+      pushTurnDuration(turnDurations, pendingTurnStartedAt, iso);
+      pendingTurnStartedAt = null;
+    }
+
+    // Thinking/reasoning
+    if (type === "reasoning" || type === "thinking" || type === "agent_reasoning") {
+      thinkingBlockCount++;
+    }
+
+    // Tool calls
+    if (
+      type === "tool_call" ||
+      type === "function_call" ||
+      type === "tool_use" ||
+      type === "command_execution" ||
+      type === "terminal_command"
+    ) {
+      toolUses.push({
+        name:
+          asStringOrNull(payload.name) ??
+          asStringOrNull(payload.tool_name) ??
+          asStringOrNull(payload.command_name) ??
+          "tool",
+        timestamp: iso || firstTimestamp,
+        input: safeJson(payload.arguments != null ? payload.arguments : payload.input),
+      });
+    }
+
+    // File edits (Cursor-specific)
+    if (type === "file_edit" || type === "apply_edit" || type === "code_edit") {
+      toolUses.push({
+        name: "file_edit",
+        timestamp: iso || firstTimestamp,
+        input: payload.file || payload.path || null,
+      });
+    }
+
+    // Tool results with errors
+    if (type === "tool_result" || type === "tool_output" || type === "command_output") {
+      const exitCode = asNumberOrNull(payload.exit_code);
+      const isErr =
+        payload.is_error === true ||
+        payload.success === false ||
+        (exitCode != null && exitCode > 0) ||
+        !!payload.error;
+      if (isErr) {
+        const content =
+          typeof payload.output === "string"
+            ? payload.output.slice(0, 500)
+            : JSON.stringify(payload.error || payload.output || payload).slice(0, 500);
+        toolResultErrors.push({ content, timestamp: iso });
+      }
+    }
+
+    // Token usage
+    if (type === "token_count" || type === "usage" || type === "token_usage") {
+      const info = asRecord(payload.usage ?? payload.token_count ?? payload);
+      if (info.input_tokens != null) tokenInput = info.input_tokens as number;
+      if (info.output_tokens != null) tokenOutput = info.output_tokens as number;
+      if (info.cache_read_tokens != null) tokenCacheRead = info.cache_read_tokens as number;
+      if (info.cached_input_tokens != null) tokenCacheRead = info.cached_input_tokens as number;
+      if (info.cache_write_tokens != null) tokenCacheWrite = info.cache_write_tokens as number;
+      if (info.cache_creation_input_tokens != null) {
+        tokenCacheWrite = info.cache_creation_input_tokens as number;
+      }
+      if (payload.model) model = asStringOrNull(payload.model);
+    }
+
+    // Errors
+    if (type === "error" || type === "api_error" || type === "stream_error") {
+      apiErrors.push({
+        type,
+        message:
+          (typeof payload.message === "string" && payload.message) ||
+          asStringOrNull(payload.error) ||
+          "Cursor error",
+        timestamp: iso,
+      });
+    }
+  }
+
+  if (!firstTimestamp) return null;
+
+  const tokensByModel: NormalizedSession["tokensByModel"] = {};
+  if (tokenInput || tokenOutput || tokenCacheRead || tokenCacheWrite) {
+    const key = model || "cursor-default";
+    tokensByModel[key] = {
+      input: tokenInput,
+      output: tokenOutput,
+      cacheRead: tokenCacheRead,
+      cacheWrite: tokenCacheWrite,
+    };
+  }
+
+  let fileModifiedAt: number | null = null;
+  try {
+    fileModifiedAt = fs.statSync(filePath).mtimeMs;
+  } catch {
+    /* non-fatal */
+  }
+
+  const projectName = cwd ? path.basename(cwd) : `Cursor Session ${sessionId.slice(0, 8)}`;
+
+  return {
+    sessionId,
+    name: projectName,
+    cwd,
+    model,
+    version,
+    slug: null,
+    gitBranch,
+    startedAt: firstTimestamp,
+    endedAt: lastTimestamp,
+    teams: [],
+    userMessages: userMessageCount,
+    assistantMessages: assistantMessageCount,
+    tokensByModel,
+    messageTimestamps,
+    toolUses,
+    compactions: [],
+    apiErrors,
+    fileModifiedAt,
+    turnDurations,
+    entrypoint: "cursor",
+    permissionMode: null,
+    thinkingBlockCount,
+    toolResultErrors,
+    usageExtras: { service_tiers: [], speeds: [], inference_geos: [] },
+  };
+}
diff --git a/apps/desktop/src/main/collectors/import-session.ts b/apps/desktop/src/main/collectors/import-session.ts
new file mode 100644
index 00000000..72175abe
--- /dev/null
+++ b/apps/desktop/src/main/collectors/import-session.ts
@@ -0,0 +1,349 @@
+import { randomUUID } from "node:crypto";
+import type { DatabaseSync } from "node:sqlite";
+import type { createTokenUsageStore } from "../database/token-usage.js";
+import type { Harness, NormalizedSession, NormalizedToolUse } from "./types.js";
+
+/**
+ * First-party session importer (FEA-1503). Replaces the vendor `import-history.js`
+ * `importSession` + the vendor `dbModule`: it writes a parsed `NormalizedSession`
+ * into the in-process node:sqlite repository (`sessions`/`agents`/`events`/
+ * `token_usage`) — the SAME tables and schema the hook lifecycle writes.
+ *
+ * Idempotency (FEA-1503 AC): re-import adds nothing new.
+ *  - session row: COALESCE-fill on conflict, never clobbers a live row.
+ *  - events: per-(session, event_type) high-water-mark on `created_at` — only
+ *    events with a transcript timestamp strictly greater than the stored max are
+ *    inserted (the exact vendor mechanism). Hook-written events carry
+ *    `created_at ≈ now`, so file events with past transcript timestamps fall under
+ *    the high-water-mark and are never double-counted against the live hook path.
+ *  - tokens: `tokenUsage.replace` nets zero when re-applying equal cumulatives.
+ *
+ * Each session is applied in one `BEGIN IMMEDIATE` transaction (mirrors
+ * lifecycle.ts); a malformed session rolls back without affecting others and
+ * never throws. Callers MUST NOT wrap this in their own transaction (node:sqlite
+ * has no nested transactions).
+ */
+
+/** A session whose source file changed within this window is treated as live. */
+const RECENT_ACTIVITY_MS = 10 * 60 * 1000;
+/** Cap an individual event's stored `data` blob so bulk import can't bloat the DB. */
+const MAX_EVENT_DATA_BYTES = 64 * 1024;
+
+export interface ImporterDeps {
+  tokenUsage: ReturnType<typeof createTokenUsageStore>;
+  /** Resolve a billing mode for a harness at session creation (FEA-1434). */
+  detectBillingMode: (harness: string) => string;
+  /** Injectable clock (tests pin it). Returns an ISO timestamp. */
+  now?: () => string;
+  /** Key-free diagnostic sink. */
+  log?: (message: string) => void;
+}
+
+export interface ImportResult {
+  /** True when the session already existed and nothing new was written. */
+  skipped: boolean;
+  /** True when a terminal session was revived because its file is recently active. */
+  reactivated: boolean;
+}
+
+interface SessionRowRaw {
+  id: string;
+  status: string;
+  ended_at: string | null;
+}
+
+export interface Importer {
+  importSession(session: NormalizedSession, harness: Harness): ImportResult;
+}
+
+export function createImporter(db: DatabaseSync, deps: ImporterDeps): Importer {
+  const nowFn = deps.now ?? (() => new Date().toISOString());
+  const log = deps.log ?? (() => {});
+
+  const getSessionStmt = db.prepare(
+    "SELECT id, status, ended_at FROM sessions WHERE id = ?",
+  );
+  const insertSessionStmt = db.prepare(`
+    INSERT INTO sessions (id, name, status, cwd, model, started_at, updated_at, ended_at, harness, billing_mode, metadata)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+  // Fill only missing fields on an existing row; never clobber a live status.
+  const coalesceSessionStmt = db.prepare(`
+    UPDATE sessions SET
+      name = COALESCE(name, ?),
+      model = COALESCE(model, ?),
+      cwd = COALESCE(cwd, ?),
+      harness = CASE WHEN COALESCE(harness, '') = '' THEN ? ELSE harness END,
+      billing_mode = CASE WHEN COALESCE(billing_mode, '') IN ('', 'unknown') THEN ? ELSE billing_mode END,
+      updated_at = ?
+    WHERE id = ?
+  `);
+  const reactivateSessionStmt = db.prepare(
+    "UPDATE sessions SET status = 'active', ended_at = NULL, updated_at = ? WHERE id = ?",
+  );
+
+  const getAgentStmt = db.prepare("SELECT id FROM agents WHERE id = ?");
+  const insertAgentStmt = db.prepare(`
+    INSERT INTO agents (id, session_id, name, type, subagent_type, status, task, current_tool, started_at, updated_at, ended_at, parent_agent_id, metadata)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+  const insertSubagentStmt = db.prepare(`
+    INSERT OR IGNORE INTO agents (id, session_id, name, type, subagent_type, status, task, started_at, updated_at, ended_at, parent_agent_id)
+    VALUES (?, ?, ?, 'subagent', ?, 'completed', ?, ?, ?, ?, ?)
+  `);
+  const reactivateMainAgentStmt = db.prepare(
+    "UPDATE agents SET status = 'waiting', ended_at = NULL, current_tool = NULL, awaiting_input_since = NULL, updated_at = ? WHERE id = ?",
+  );
+
+  const highWaterStmt = db.prepare(
+    "SELECT event_type, MAX(created_at) AS hwm FROM events WHERE session_id = ? GROUP BY event_type",
+  );
+  const insertEventStmt = db.prepare(`
+    INSERT INTO events (id, session_id, agent_id, event_type, tool_name, summary, data, created_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+
+  function mainAgentId(sessionId: string): string {
+    return `${sessionId}-main`;
+  }
+
+  function isRecentlyActive(session: NormalizedSession, nowMs: number): boolean {
+    return (
+      session.fileModifiedAt != null &&
+      Number.isFinite(session.fileModifiedAt) &&
+      nowMs - session.fileModifiedAt < RECENT_ACTIVITY_MS
+    );
+  }
+
+  function buildMetadata(session: NormalizedSession, harness: Harness): string {
+    return JSON.stringify({
+      version: session.version ?? null,
+      slug: session.slug ?? null,
+      gitBranch: session.gitBranch ?? null,
+      userMessages: session.userMessages ?? 0,
+      assistantMessages: session.assistantMessages ?? 0,
+      entrypoint: session.entrypoint ?? harness,
+      permissionMode: session.permissionMode ?? null,
+      thinkingBlockCount: session.thinkingBlockCount ?? 0,
+      teams: session.teams ?? [],
+      plans: session.plans ?? [],
+      usageExtras: session.usageExtras ?? {
+        service_tiers: [],
+        speeds: [],
+        inference_geos: [],
+      },
+    });
+  }
+
+  function eventData(input: unknown): string | null {
+    if (input == null) return null;
+    let text: string;
+    try {
+      text = JSON.stringify(input);
+    } catch {
+      return null;
+    }
+    if (text.length > MAX_EVENT_DATA_BYTES) {
+      return JSON.stringify({ truncated: true, bytes: text.length });
+    }
+    return text;
+  }
+
+  function subagentName(tu: NormalizedToolUse): string {
+    const input = (tu.input ?? {}) as Record<string, unknown>;
+    const description = strOf(input.description);
+    const subagentType = strOf(input.subagent_type);
+    const prompt = strOf(input.prompt);
+    return (
+      description ??
+      subagentType ??
+      (prompt ? prompt.split("\n")[0].slice(0, 60) : undefined) ??
+      "Subagent"
+    );
+  }
+
+  function importSession(session: NormalizedSession, harness: Harness): ImportResult {
+    if (typeof session.sessionId !== "string" || session.sessionId.length === 0) {
+      return { skipped: true, reactivated: false };
+    }
+    if (!session.startedAt) {
+      return { skipped: true, reactivated: false };
+    }
+
+    const now = nowFn();
+    const nowMs = Date.parse(now);
+    const recentlyActive = isRecentlyActive(
+      session,
+      Number.isNaN(nowMs) ? Date.now() : nowMs,
+    );
+    const mainId = mainAgentId(session.sessionId);
+
+    try {
+      db.exec("BEGIN IMMEDIATE");
+
+      const existing = getSessionStmt.get(session.sessionId) as SessionRowRaw | undefined;
+      let reactivated = false;
+
+      if (!existing) {
+        const status = recentlyActive ? "active" : "completed";
+        const billingMode = safe(() => deps.detectBillingMode(harness)) ?? "unknown";
+        insertSessionStmt.run(
+          session.sessionId,
+          session.name ?? null,
+          status,
+          session.cwd ?? null,
+          session.model ?? null,
+          session.startedAt,
+          session.endedAt ?? session.startedAt,
+          status === "completed" ? session.endedAt ?? null : null,
+          harness,
+          billingMode,
+          buildMetadata(session, harness),
+        );
+        insertAgentStmt.run(
+          mainId,
+          session.sessionId,
+          "main",
+          "main",
+          null,
+          status === "completed" ? "completed" : "waiting",
+          null,
+          null,
+          session.startedAt,
+          now,
+          status === "completed" ? session.endedAt ?? now : null,
+          null,
+          null,
+        );
+      } else {
+        const billingMode = safe(() => deps.detectBillingMode(harness)) ?? "unknown";
+        coalesceSessionStmt.run(
+          session.name ?? null,
+          session.model ?? null,
+          session.cwd ?? null,
+          harness,
+          billingMode,
+          now,
+          session.sessionId,
+        );
+        const isLive = existing.status === "active" && existing.ended_at == null;
+        if (recentlyActive && !isLive) {
+          reactivateSessionStmt.run(now, session.sessionId);
+          if (getAgentStmt.get(mainId)) {
+            reactivateMainAgentStmt.run(now, mainId);
+          }
+          reactivated = true;
+        }
+      }
+
+      // ── Idempotent event backfill via per-event-type high-water-mark ──────────
+      const highWater = new Map<string, string>();
+      for (const row of highWaterStmt.all(session.sessionId) as Array<{
+        event_type: string;
+        hwm: string | null;
+      }>) {
+        if (row.hwm) highWater.set(row.event_type, row.hwm);
+      }
+
+      let inserted = 0;
+      const addEvent = (
+        eventType: string,
+        agentId: string,
+        ts: string | null,
+        toolName: string | null,
+        summary: string | null,
+        data: string | null,
+      ): void => {
+        if (!ts) return;
+        const prev = highWater.get(eventType);
+        if (prev != null && ts <= prev) return;
+        insertEventStmt.run(
+          randomUUID(),
+          session.sessionId,
+          agentId,
+          eventType,
+          toolName,
+          summary,
+          data,
+          ts,
+        );
+        inserted++;
+      };
+
+      for (const ts of session.messageTimestamps ?? []) {
+        addEvent("Stop", mainId, ts, null, null, null);
+      }
+
+      (session.toolUses ?? []).forEach((tu, idx) => {
+        if (tu.name === "Agent" || tu.name === "Task") {
+          const subId = `${session.sessionId}-sub-${idx}`;
+          const input = (tu.input ?? {}) as Record<string, unknown>;
+          const prompt = strOf(input.prompt);
+          insertSubagentStmt.run(
+            subId,
+            session.sessionId,
+            subagentName(tu),
+            strOf(input.subagent_type) ?? null,
+            prompt ? prompt.slice(0, 500) : null,
+            tu.timestamp ?? session.startedAt,
+            now,
+            tu.timestamp ?? session.endedAt ?? now,
+            mainId,
+          );
+          addEvent("PreToolUse", subId, tu.timestamp, tu.name, "Spawned subagent", eventData(tu.input));
+        } else {
+          addEvent("PostToolUse", mainId, tu.timestamp, tu.name, null, eventData(tu.input));
+        }
+      });
+
+      for (const td of session.turnDurations ?? []) {
+        addEvent("TurnDuration", mainId, td.timestamp, null, String(td.durationMs), null);
+      }
+      for (const err of session.apiErrors ?? []) {
+        addEvent("APIError", mainId, err.timestamp, null, err.message ?? err.type ?? null, null);
+      }
+      for (const err of session.toolResultErrors ?? []) {
+        addEvent("ToolError", mainId, err.timestamp, null, truncate(err.content, 200), null);
+      }
+
+      // ── Tokens (store reconciles raw/effective; idempotent on equal counts) ───
+      for (const [model, counts] of Object.entries(session.tokensByModel ?? {})) {
+        deps.tokenUsage.replace(session.sessionId, model, counts, now);
+      }
+
+      db.exec("COMMIT");
+
+      const skipped = existing != null && inserted === 0 && !reactivated;
+      return { skipped, reactivated };
+    } catch (error) {
+      try {
+        db.exec("ROLLBACK");
+      } catch {
+        /* ignore rollback failure */
+      }
+      log(
+        `importSession failed for ${session.sessionId}: ${error instanceof Error ? error.message : String(error)}`,
+      );
+      return { skipped: true, reactivated: false };
+    }
+  }
+
+  return { importSession };
+}
+
+function strOf(value: unknown): string | undefined {
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
+function truncate(value: string | null | undefined, max: number): string | null {
+  if (typeof value !== "string" || value.length === 0) return null;
+  return value.length > max ? value.slice(0, max) : value;
+}
+
+function safe<T>(fn: () => T): T | undefined {
+  try {
+    return fn();
+  } catch {
+    return undefined;
+  }
+}
diff --git a/apps/desktop/src/main/collectors/ingest-paths.ts b/apps/desktop/src/main/collectors/ingest-paths.ts
new file mode 100644
index 00000000..d0ce0b1d
--- /dev/null
+++ b/apps/desktop/src/main/collectors/ingest-paths.ts
@@ -0,0 +1,22 @@
+/**
+ * @file ingest-paths.ts
+ * @description Pure path helpers for durable collector ingest state — the
+ * persisted per-source catchup caches and the OpenCode DB fingerprint
+ * (FEA-1503; ported from the vendor `ingest-paths.js`). Unlike the vendor module
+ * (which read `DASHBOARD_DB_PATH` from the now-removed sidecar env), these take
+ * the state directory explicitly; the CollectorManager derives it from
+ * `app.getPath("userData")/agent-monitor` so caches sit beside the in-process DB.
+ */
+import path from "node:path";
+
+export const INGEST_STATE_VERSION = 2;
+
+/** Absolute path to the persisted catchup cache for a named source. */
+export function ingestCachePath(stateDir: string, name: string): string {
+  return path.join(stateDir, `ingest-cache-${name}.json`);
+}
+
+/** Absolute path to the OpenCode DB fingerprint file (single-DB high-water-mark). */
+export function ingestOpencodeFingerprintPath(stateDir: string): string {
+  return path.join(stateDir, "ingest-opencode-fingerprint.txt");
+}
diff --git a/apps/desktop/src/main/collectors/opencode/opencode-collector.ts b/apps/desktop/src/main/collectors/opencode/opencode-collector.ts
new file mode 100644
index 00000000..838eddfe
--- /dev/null
+++ b/apps/desktop/src/main/collectors/opencode/opencode-collector.ts
@@ -0,0 +1,102 @@
+/**
+ * @file opencode-collector.ts
+ * @description The OpenCode HarnessCollector (FEA-1503). OpenCode is a BATCH
+ * harness: its canonical store is a single foreign SQLite DB (`opencode.db`),
+ * read in one load. To avoid re-loading the whole DB on every catchup tick, the
+ * collector self-fingerprints the DB + WAL/SHM siblings (name:mtimeMs:size) and
+ * skips the load when the fingerprint is unchanged.
+ *
+ * Fingerprint logic ported from `scripts/agent-monitor-opencode/opencode-import.js`
+ * (FEA-1316 / FEA-1334), logic preserved: the in-memory high-water-mark is
+ * seeded from a persisted file so a fresh process also skips the cold-start load
+ * when the DB is untouched. Only the fingerprint/idempotency concern is ported —
+ * the dbModule write path stays in the shared `importSession` write-sink.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import {
+  getOpenCodeDbPath,
+  getOpenCodeHome,
+  getOpenCodeDbWatchFiles,
+} from "./opencode-home.js";
+import { loadSessionsFromDb } from "./opencode-parser.js";
+import type { HarnessCollector, NormalizedSession } from "../types.js";
+
+export function createOpencodeCollector(
+  opts?: { fingerprintPath?: string },
+): HarnessCollector {
+  const fingerprintPath = opts?.fingerprintPath;
+  let lastFingerprint: string | null = null;
+  let seeded = false;
+
+  function loadPersistedFingerprint(): string | null {
+    if (!fingerprintPath) return null;
+    try {
+      return fs.readFileSync(fingerprintPath, "utf8");
+    } catch {
+      return null;
+    }
+  }
+
+  function persistFingerprint(fingerprint: string): void {
+    if (!fingerprintPath) return;
+    try {
+      fs.mkdirSync(path.dirname(fingerprintPath), { recursive: true });
+      fs.writeFileSync(fingerprintPath, fingerprint);
+    } catch {
+      /* best-effort — an unwritable state dir just costs one extra load */
+    }
+  }
+
+  function ensureSeeded(): void {
+    if (seeded) return;
+    seeded = true;
+    lastFingerprint = loadPersistedFingerprint();
+  }
+
+  function fingerprintDbFiles(): string {
+    const home = getOpenCodeHome();
+    const parts: string[] = [];
+    for (const name of getOpenCodeDbWatchFiles()) {
+      try {
+        const stat = fs.statSync(path.join(home, name));
+        parts.push(`${name}:${stat.mtimeMs}:${stat.size}`);
+      } catch {
+        parts.push(`${name}:missing`);
+      }
+    }
+    return parts.join("|");
+  }
+
+  return {
+    key: "opencode",
+    cacheName: "opencode",
+    batch: true,
+
+    watchRoots(): string[] {
+      return [getOpenCodeHome()];
+    },
+
+    watchMatch(filename: string): boolean {
+      return getOpenCodeDbWatchFiles().some(
+        (n) => filename === n || filename.endsWith("/" + n),
+      );
+    },
+
+    listSources(): string[] {
+      ensureSeeded();
+      const dbPath = getOpenCodeDbPath();
+      if (!fs.existsSync(dbPath)) return [];
+      const fingerprint = fingerprintDbFiles();
+      if (fingerprint === lastFingerprint) return [];
+      return [dbPath];
+    },
+
+    parse(dbPath: string): Promise<NormalizedSession[]> {
+      const sessions = loadSessionsFromDb(dbPath);
+      lastFingerprint = fingerprintDbFiles();
+      persistFingerprint(lastFingerprint);
+      return Promise.resolve(sessions);
+    },
+  };
+}
diff --git a/apps/desktop/src/main/collectors/opencode/opencode-home.ts b/apps/desktop/src/main/collectors/opencode/opencode-home.ts
new file mode 100644
index 00000000..ba717e0a
--- /dev/null
+++ b/apps/desktop/src/main/collectors/opencode/opencode-home.ts
@@ -0,0 +1,42 @@
+/**
+ * @file opencode-home.ts
+ * @description Centralized OpenCode data-path management. OpenCode's canonical
+ * session store is the SQLite database at `opencode.db`; the adjacent WAL/SHM
+ * files carry live updates while the app is running.
+ *
+ * Supports a custom root via the OPENCODE_DATA_DIR environment variable (`~`
+ * expanded). Default is `~/.local/share/opencode` on linux/mac and
+ * `%APPDATA%/opencode` on win32.
+ *
+ * Ported from `scripts/agent-monitor-opencode/opencode-home.js` (logic
+ * preserved exactly).
+ */
+import os from "node:os";
+import path from "node:path";
+
+export function getOpenCodeHome(): string {
+  const raw = process.env.OPENCODE_DATA_DIR;
+  if (raw && raw.trim()) {
+    return raw.trim().replace(/^~(?=\/)/, os.homedir());
+  }
+  const home = os.homedir();
+  if (process.platform === "win32") {
+    return path.join(
+      process.env.APPDATA || path.join(home, "AppData", "Roaming"),
+      "opencode",
+    );
+  }
+  return path.join(home, ".local", "share", "opencode");
+}
+
+export function getOpenCodeDbPath(): string {
+  return path.join(getOpenCodeHome(), "opencode.db");
+}
+
+export function getOpenCodeDbWatchDir(): string {
+  return getOpenCodeHome();
+}
+
+export function getOpenCodeDbWatchFiles(): string[] {
+  return ["opencode.db", "opencode.db-wal", "opencode.db-shm"];
+}
diff --git a/apps/desktop/src/main/collectors/opencode/opencode-parser.ts b/apps/desktop/src/main/collectors/opencode/opencode-parser.ts
new file mode 100644
index 00000000..2db39423
--- /dev/null
+++ b/apps/desktop/src/main/collectors/opencode/opencode-parser.ts
@@ -0,0 +1,322 @@
+/**
+ * @file opencode-parser.ts
+ * @description Parse OpenCode session data from `opencode.db` into the
+ * normalized session shape consumed by `importSession`. OpenCode persists its
+ * canonical session/message/part model in SQLite; `storage/` is auxiliary
+ * cache/snapshot state and is not authoritative for session history.
+ *
+ * OpenCode is a BATCH harness: this reads the whole foreign `opencode.db` in
+ * one load. Ported from `scripts/agent-monitor-opencode/opencode-parser.js`
+ * (logic preserved exactly); the foreign DB is opened with `node:sqlite`'s
+ * `DatabaseSync`.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { DatabaseSync, type StatementSync } from "node:sqlite";
+import { getOpenCodeDbPath } from "./opencode-home.js";
+import {
+  emptyUsageExtras,
+  type NormalizedApiError,
+  type NormalizedSession,
+  type NormalizedTokenCounts,
+  type NormalizedToolResultError,
+  type NormalizedToolUse,
+  type NormalizedTurnDuration,
+} from "../types.js";
+import {
+  extractErrorMessage,
+  pushTurnDuration,
+  safeJson,
+  toIso,
+} from "../parser-utils.js";
+
+type Row = Record<string, unknown>;
+
+function isObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+function parseJsonCell(value: unknown): unknown {
+  return typeof value === "string" ? safeJson(value) : value;
+}
+
+function modelIdFromValue(value: unknown): string | null {
+  const parsed = parseJsonCell(value);
+  if (isObject(parsed)) {
+    const modelID = parsed.modelID;
+    const id = parsed.id;
+    const name = parsed.name;
+    return (
+      (typeof modelID === "string" ? modelID : null) ||
+      (typeof id === "string" ? id : null) ||
+      (typeof name === "string" ? name : null) ||
+      null
+    );
+  }
+  return typeof parsed === "string" && parsed.length > 0 ? parsed : null;
+}
+
+function partTimestamp(partRow: Row, part: Record<string, unknown>): unknown {
+  const time = isObject(part.time) ? part.time : undefined;
+  return (
+    time?.created ??
+    time?.start ??
+    partRow.time_created ??
+    partRow.time_updated ??
+    null
+  );
+}
+
+function collectToolUse(
+  toolUses: NormalizedToolUse[],
+  toolResultErrors: NormalizedToolResultError[],
+  partRow: Row,
+  part: Record<string, unknown>,
+  firstTimestamp: string | null,
+): void {
+  const timestamp = toIso(partTimestamp(partRow, part)) || firstTimestamp;
+  const state = isObject(part.state) ? part.state : undefined;
+  const input = state?.input ?? part.input ?? part.parameters ?? null;
+  toolUses.push({
+    name:
+      (typeof part.tool === "string" ? part.tool : null) ||
+      (typeof part.name === "string" ? part.name : null) ||
+      "opencode_tool",
+    timestamp,
+    input: safeJson(input),
+  });
+
+  const status = state?.status;
+  const errorMessage = extractErrorMessage(state?.error ?? part.error);
+  if (status === "failed" || status === "error" || errorMessage) {
+    const stateOutput = state?.output;
+    const output =
+      typeof stateOutput === "string"
+        ? stateOutput
+        : JSON.stringify(stateOutput ?? part.state ?? part).slice(0, 500);
+    toolResultErrors.push({
+      content: (errorMessage || output || "OpenCode tool error").slice(0, 500),
+      timestamp,
+    });
+  }
+}
+
+function parseSessionRow(
+  sessionRow: Row,
+  getMessages: StatementSync,
+  getParts: StatementSync,
+): NormalizedSession | null {
+  const sessionId = sessionRow.id as string | number | bigint | null;
+  const messageRows = getMessages.all(sessionId) as Row[];
+  if (!Array.isArray(messageRows) || messageRows.length === 0) return null;
+
+  let cwd: string | null =
+    typeof sessionRow.directory === "string" ? sessionRow.directory : null;
+  const model = modelIdFromValue(sessionRow.model);
+  let firstTimestamp: string | null = null;
+  let lastTimestamp: string | null = null;
+  let userMessageCount = 0;
+  let assistantMessageCount = 0;
+  const messageTimestamps: string[] = [];
+  const toolUses: NormalizedToolUse[] = [];
+  const turnDurations: NormalizedTurnDuration[] = [];
+  const apiErrors: NormalizedApiError[] = [];
+  let thinkingBlockCount = 0;
+  const toolResultErrors: NormalizedToolResultError[] = [];
+  let pendingTurnStartedAt: string | null = null;
+
+  const noteTs = (raw: unknown): string | null => {
+    const iso = toIso(raw);
+    if (!iso) return null;
+    if (!firstTimestamp || iso < firstTimestamp) firstTimestamp = iso;
+    if (!lastTimestamp || iso > lastTimestamp) lastTimestamp = iso;
+    return iso;
+  };
+
+  noteTs(sessionRow.time_created);
+  noteTs(sessionRow.time_updated);
+
+  for (const row of messageRows) {
+    const data = parseJsonCell(row.data);
+    if (!isObject(data)) continue;
+
+    const dataTime = isObject(data.time) ? data.time : undefined;
+    const iso = noteTs(
+      dataTime?.created ?? row.time_created ?? row.time_updated,
+    );
+    const role =
+      (typeof data.role === "string" ? data.role : null) ||
+      (typeof data.type === "string" ? data.type : null) ||
+      "";
+
+    if (!cwd && isObject(data.path)) {
+      const dataPath = data.path;
+      const pathCwd =
+        typeof dataPath.cwd === "string" ? dataPath.cwd : null;
+      const pathRoot =
+        typeof dataPath.root === "string" ? dataPath.root : null;
+      cwd = pathCwd || pathRoot || cwd;
+    }
+
+    if (role === "user" || role === "human") {
+      userMessageCount++;
+      if (iso) pendingTurnStartedAt = iso;
+    } else if (role === "assistant" || role === "ai" || role === "model") {
+      assistantMessageCount++;
+      if (iso) messageTimestamps.push(iso);
+      pushTurnDuration(turnDurations, pendingTurnStartedAt, iso);
+      pendingTurnStartedAt = null;
+    }
+
+    const errorMessage = extractErrorMessage(data.error);
+    if (errorMessage) {
+      apiErrors.push({
+        type: "error",
+        message: errorMessage,
+        timestamp: iso,
+      });
+    }
+  }
+
+  const partRows = getParts.all(sessionId) as Row[];
+  for (const partRow of partRows) {
+    const part = parseJsonCell(partRow.data);
+    if (!isObject(part)) continue;
+
+    const iso = noteTs(partTimestamp(partRow, part));
+    if (part.type === "reasoning") {
+      thinkingBlockCount++;
+    } else if (part.type === "tool") {
+      collectToolUse(toolUses, toolResultErrors, partRow, part, firstTimestamp);
+    } else if (part.type === "error") {
+      const errorMessage = extractErrorMessage(part);
+      if (errorMessage) {
+        apiErrors.push({
+          type: "error",
+          message: errorMessage,
+          timestamp: iso,
+        });
+      }
+    }
+  }
+
+  if (!firstTimestamp) return null;
+
+  const tokensByModel: Record<string, NormalizedTokenCounts> = {};
+  const tokenInput = Number(sessionRow.tokens_input || 0);
+  const tokenOutput = Number(sessionRow.tokens_output || 0);
+  const tokenReasoning = Number(sessionRow.tokens_reasoning || 0);
+  const tokenCacheRead = Number(sessionRow.tokens_cache_read || 0);
+  const tokenCacheWrite = Number(sessionRow.tokens_cache_write || 0);
+  if (
+    tokenInput ||
+    tokenOutput ||
+    tokenReasoning ||
+    tokenCacheRead ||
+    tokenCacheWrite
+  ) {
+    const agent = typeof sessionRow.agent === "string" ? sessionRow.agent : null;
+    const key = model || agent || "opencode-default";
+    tokensByModel[key] = {
+      input: tokenInput,
+      output: tokenOutput + tokenReasoning,
+      cacheRead: tokenCacheRead,
+      cacheWrite: tokenCacheWrite,
+    };
+  }
+
+  const sessionIdStr = String(sessionId);
+  const title = typeof sessionRow.title === "string" ? sessionRow.title : null;
+  const projectName = cwd
+    ? path.basename(cwd)
+    : title || `OpenCode Session ${sessionIdStr.slice(0, 8)}`;
+
+  const version =
+    typeof sessionRow.version === "string" ? sessionRow.version : null;
+  const slug = typeof sessionRow.slug === "string" ? sessionRow.slug : null;
+  const permissionMode =
+    typeof sessionRow.permission === "string" ? sessionRow.permission : null;
+
+  return {
+    sessionId: `opencode-${sessionIdStr}`,
+    name: projectName,
+    cwd,
+    model,
+    version,
+    slug,
+    gitBranch: null,
+    startedAt: firstTimestamp,
+    endedAt: lastTimestamp || firstTimestamp,
+    teams: [],
+    userMessages: userMessageCount,
+    assistantMessages: assistantMessageCount,
+    tokensByModel,
+    messageTimestamps,
+    toolUses,
+    compactions: [],
+    apiErrors,
+    fileModifiedAt: Number(sessionRow.time_updated || 0) || null,
+    turnDurations,
+    entrypoint: "opencode",
+    permissionMode,
+    thinkingBlockCount,
+    toolResultErrors,
+    usageExtras: emptyUsageExtras(),
+  };
+}
+
+export function loadSessionsFromDb(
+  dbPath: string = getOpenCodeDbPath(),
+): NormalizedSession[] {
+  if (!dbPath || !fs.existsSync(dbPath)) return [];
+
+  const db = new DatabaseSync(dbPath);
+  try {
+    db.exec("PRAGMA busy_timeout = 1000");
+    const sessionRows = db
+      .prepare(
+        `
+        SELECT
+          id,
+          slug,
+          directory,
+          title,
+          version,
+          agent,
+          model,
+          permission,
+          time_created,
+          time_updated,
+          tokens_input,
+          tokens_output,
+          tokens_reasoning,
+          tokens_cache_read,
+          tokens_cache_write
+        FROM session
+        ORDER BY time_updated DESC, id DESC
+      `,
+      )
+      .all() as Row[];
+    const getMessages = db.prepare(`
+      SELECT id, time_created, time_updated, data
+      FROM message
+      WHERE session_id = ?
+      ORDER BY time_created ASC, id ASC
+    `);
+    const getParts = db.prepare(`
+      SELECT id, time_created, time_updated, data
+      FROM part
+      WHERE session_id = ?
+      ORDER BY time_created ASC, id ASC
+    `);
+
+    const out: NormalizedSession[] = [];
+    for (const row of sessionRows) {
+      const session = parseSessionRow(row, getMessages, getParts);
+      if (session) out.push(session);
+    }
+    return out;
+  } finally {
+    db.close();
+  }
+}
diff --git a/apps/desktop/src/main/collectors/parser-utils.ts b/apps/desktop/src/main/collectors/parser-utils.ts
new file mode 100644
index 00000000..2b8f16df
--- /dev/null
+++ b/apps/desktop/src/main/collectors/parser-utils.ts
@@ -0,0 +1,76 @@
+/**
+ * @file parser-utils.ts
+ * @description Shared utilities for the harness parsers (ported from the vendor
+ * `scripts/agent-monitor-shared/parser-utils.js`, logic preserved). Kept
+ * dependency-free so every parser can normalize timestamps and extract error
+ * text identically.
+ */
+import type { NormalizedTurnDuration } from "./types.js";
+
+/**
+ * Normalize a timestamp to an ISO 8601 string. Handles numeric epoch (seconds or
+ * milliseconds), strings, and nulls.
+ */
+export function toIso(ts: unknown): string | null {
+  if (ts == null) return null;
+  if (typeof ts === "number") {
+    const ms = ts < 1e12 ? ts * 1000 : ts;
+    const d = new Date(ms);
+    return isNaN(d.getTime()) ? null : d.toISOString();
+  }
+  if (typeof ts === "string") {
+    const d = new Date(ts);
+    return isNaN(d.getTime()) ? ts : d.toISOString();
+  }
+  return null;
+}
+
+/** Parse a value as JSON if it's a string, return objects as-is. */
+export function safeJson(v: unknown): unknown {
+  if (v == null) return null;
+  if (typeof v === "object") return v;
+  if (typeof v === "string") {
+    try {
+      return JSON.parse(v);
+    } catch {
+      return v;
+    }
+  }
+  return v;
+}
+
+/** Best-effort extraction of a human-readable error message from a nested value. */
+export function extractErrorMessage(value: unknown, depth = 0): string | null {
+  if (value == null || depth > 4) return null;
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+  }
+  if (Array.isArray(value)) {
+    for (const entry of value) {
+      const message = extractErrorMessage(entry, depth + 1);
+      if (message) return message;
+    }
+    return null;
+  }
+  if (typeof value === "object") {
+    const obj = value as Record<string, unknown>;
+    for (const key of ["message", "error", "details", "text", "content"]) {
+      const message = extractErrorMessage(obj[key], depth + 1);
+      if (message) return message;
+    }
+  }
+  return null;
+}
+
+/** Push a turn-duration entry when both timestamps are valid and duration ≥ 0. */
+export function pushTurnDuration(
+  turnDurations: NormalizedTurnDuration[],
+  startedAtIso: string | null,
+  endedAtIso: string | null,
+): void {
+  if (!startedAtIso || !endedAtIso) return;
+  const durationMs = new Date(endedAtIso).getTime() - new Date(startedAtIso).getTime();
+  if (!Number.isFinite(durationMs) || durationMs < 0) return;
+  turnDurations.push({ durationMs, timestamp: endedAtIso });
+}
diff --git a/apps/desktop/src/main/collectors/types.ts b/apps/desktop/src/main/collectors/types.ts
new file mode 100644
index 00000000..743e6e06
--- /dev/null
+++ b/apps/desktop/src/main/collectors/types.ts
@@ -0,0 +1,124 @@
+/**
+ * @file types.ts
+ * @description The collection-layer contract (FEA-1503). Every harness parser
+ * (Claude, Codex, Cursor, Copilot, OpenCode) emits this single `NormalizedSession`
+ * shape, and the first-party `importSession` write-sink consumes it. Ported from
+ * the vendor agent-monitor's normalized session shape so the unchanged dashboard
+ * renders all harnesses identically.
+ */
+
+/** The five agent CLIs we collect from. */
+export type Harness = "claude" | "codex" | "cursor" | "copilot" | "opencode";
+
+/** Cumulative per-model token counts (output already folds in reasoning tokens). */
+export interface NormalizedTokenCounts {
+  input: number;
+  output: number;
+  cacheRead: number;
+  cacheWrite: number;
+}
+
+/** A tool invocation parsed from a transcript → becomes a PostToolUse event. */
+export interface NormalizedToolUse {
+  name: string;
+  timestamp: string | null;
+  input?: unknown;
+}
+
+/** An API-level error parsed from a transcript → becomes an APIError event. */
+export interface NormalizedApiError {
+  type?: string | null;
+  message?: string | null;
+  timestamp: string | null;
+}
+
+/** A tool-result error parsed from a transcript → becomes a ToolError event. */
+export interface NormalizedToolResultError {
+  content?: string | null;
+  timestamp: string | null;
+}
+
+/** A measured turn duration → becomes a TurnDuration event. */
+export interface NormalizedTurnDuration {
+  durationMs: number;
+  timestamp: string | null;
+}
+
+/** A plan block (Codex only today). Stored on the session metadata. */
+export interface NormalizedPlan {
+  source?: string | null;
+  content?: string | null;
+  timestamp: string | null;
+}
+
+/**
+ * The normalized session every parser produces. `startedAt` falsy ⇒ the parser
+ * returns null (caller skips). All array fields default to `[]`, all token maps
+ * to `{}`.
+ */
+export interface NormalizedSession {
+  sessionId: string;
+  name: string;
+  cwd: string | null;
+  model: string | null;
+  version: string | null;
+  slug: string | null;
+  gitBranch: string | null;
+  startedAt: string | null;
+  endedAt: string | null;
+  teams: unknown[];
+  userMessages: number;
+  assistantMessages: number;
+  tokensByModel: Record<string, NormalizedTokenCounts>;
+  messageTimestamps: string[];
+  toolUses: NormalizedToolUse[];
+  plans?: NormalizedPlan[];
+  compactions: unknown[];
+  apiErrors: NormalizedApiError[];
+  /** mtimeMs of the source file; drives the "recently active (<10min)" decision. */
+  fileModifiedAt: number | null;
+  turnDurations: NormalizedTurnDuration[];
+  entrypoint: string;
+  permissionMode: string | null;
+  thinkingBlockCount: number;
+  toolResultErrors: NormalizedToolResultError[];
+  usageExtras: {
+    service_tiers: unknown[];
+    speeds: unknown[];
+    inference_geos: unknown[];
+  };
+}
+
+/** Empty `usageExtras` literal — parsers spread/override as needed. */
+export function emptyUsageExtras(): NormalizedSession["usageExtras"] {
+  return { service_tiers: [], speeds: [], inference_geos: [] };
+}
+
+/**
+ * A per-harness collector descriptor (FEA-1503). The generic boot importer and
+ * the generic watcher (`watcher.ts`, `collector-manager.ts`) drive every harness
+ * through this uniform shape, so the only per-harness code is `home` (path/env
+ * resolution) + `parser` (format → NormalizedSession) + a small descriptor.
+ *
+ *  - File harnesses (Claude/Codex/Cursor/Copilot): `listSources()` returns the
+ *    current source file paths; `parse(file)` returns `[session]` (or `[]`). The
+ *    per-file catchup cache skips unchanged files.
+ *  - Batch harnesses (OpenCode): set `batch: true`, self-fingerprint inside
+ *    `listSources()` (return `[]` when the store is unchanged, else a single
+ *    sentinel), and `parse(sentinel)` loads every session from the store.
+ */
+export interface HarnessCollector {
+  key: Harness;
+  /** Stable name for this collector's persisted catchup cache (file harnesses). */
+  cacheName: string;
+  /** When true the per-file catchup cache is bypassed (the harness self-fingerprints). */
+  batch?: boolean;
+  /** Directories to recursively fs.watch. Missing dirs self-heal when they appear. */
+  watchRoots(): string[];
+  /** Which changed filenames (basename or relative path) trigger a re-import. */
+  watchMatch(filename: string): boolean;
+  /** Enumerate the current source paths to import. */
+  listSources(): string[];
+  /** Parse one source into zero or more normalized sessions. */
+  parse(source: string): Promise<NormalizedSession[]>;
+}
diff --git a/apps/desktop/src/main/collectors/watcher.ts b/apps/desktop/src/main/collectors/watcher.ts
new file mode 100644
index 00000000..c6673b00
--- /dev/null
+++ b/apps/desktop/src/main/collectors/watcher.ts
@@ -0,0 +1,151 @@
+/**
+ * @file watcher.ts
+ * @description Generic live file watcher for a harness (FEA-1503; generalized
+ * from the per-tool vendor `*-watcher.js`). A single factory drives every
+ * harness: it debounces filesystem changes, self-heals when a watched root does
+ * not exist yet (the user runs their first-ever session with a tool after the
+ * app booted), and runs a periodic catch-up poll as an `fs.watch` miss-fallback.
+ * On every trigger it runs the supplied idempotent import for the harness; the
+ * caller decides what "import" means (parse changed files → importSession → emit).
+ *
+ * Best-effort and non-fatal: `fs.watch` is platform-quirky and a failure here
+ * must never crash the main process — the catch-up poll still keeps the dashboard
+ * current.
+ */
+import { existsSync, watch, type FSWatcher } from "node:fs";
+
+const DEBOUNCE_MS = 600;
+const RETRY_MS = 4000;
+const MAX_RETRY_ATTEMPTS = 75; // ~5 minutes at 4s intervals, then give up
+const CATCHUP_POLL_MS = 5000;
+
+export interface HarnessWatcherOptions {
+  /** Directories to recursively watch (re-evaluated on each self-heal attempt). */
+  roots: () => string[];
+  /** Which changed filenames trigger a re-import. */
+  match: (filename: string) => boolean;
+  /** Idempotent import for this harness. Called on boot, debounce, and poll. */
+  runImport: () => Promise<void>;
+  log?: (message: string) => void;
+}
+
+export interface HarnessWatcher {
+  start(): void;
+  stop(): void;
+}
+
+export function createHarnessWatcher(options: HarnessWatcherOptions): HarnessWatcher {
+  let started = false;
+  let running = false;
+  let debounceTimer: NodeJS.Timeout | null = null;
+  let retryTimer: NodeJS.Timeout | null = null;
+  let catchupTimer: NodeJS.Timeout | null = null;
+  const watchers: FSWatcher[] = [];
+  const attached = new Set<string>();
+
+  async function trigger(): Promise<void> {
+    if (running) return; // never overlap an in-flight import
+    running = true;
+    try {
+      await options.runImport();
+    } catch {
+      /* non-fatal — a partially-written file mid-turn is normal */
+    } finally {
+      running = false;
+    }
+  }
+
+  function scheduleImport(): void {
+    if (debounceTimer) return;
+    debounceTimer = setTimeout(() => {
+      debounceTimer = null;
+      void trigger();
+    }, DEBOUNCE_MS);
+  }
+
+  function attach(root: string): boolean {
+    if (attached.has(root)) return true;
+    try {
+      if (!existsSync(root)) return false;
+      const w = watch(root, { recursive: true }, (_event, filename) => {
+        if (!filename) return;
+        if (!options.match(String(filename))) return;
+        scheduleImport();
+      });
+      w.on("error", () => {
+        /* platform limitation — the catch-up poll still covers changes */
+      });
+      watchers.push(w);
+      attached.add(root);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /** Attach every root that exists; returns true once all roots are attached. */
+  function tryAttachAll(): boolean {
+    let all = true;
+    for (const root of options.roots()) {
+      if (!attach(root)) all = false;
+    }
+    return all;
+  }
+
+  function start(): void {
+    if (started) return;
+    started = true;
+
+    // Initial catch-up (the boot import for this harness). Deferred a tick so a
+    // synchronous batch parse cannot block the first window paint.
+    setImmediate(() => void trigger());
+
+    catchupTimer = setInterval(() => void trigger(), CATCHUP_POLL_MS);
+    catchupTimer.unref();
+
+    if (tryAttachAll()) return; // every root existed → fully attached
+
+    let retries = 0;
+    retryTimer = setInterval(() => {
+      if (++retries > MAX_RETRY_ATTEMPTS) {
+        if (retryTimer) clearInterval(retryTimer);
+        retryTimer = null;
+        return;
+      }
+      if (tryAttachAll()) {
+        if (retryTimer) clearInterval(retryTimer);
+        retryTimer = null;
+        // A root just appeared after boot — catch up the sessions fs.watch missed.
+        void trigger();
+      }
+    }, RETRY_MS);
+    retryTimer.unref();
+  }
+
+  function stop(): void {
+    if (debounceTimer) {
+      clearTimeout(debounceTimer);
+      debounceTimer = null;
+    }
+    if (retryTimer) {
+      clearInterval(retryTimer);
+      retryTimer = null;
+    }
+    if (catchupTimer) {
+      clearInterval(catchupTimer);
+      catchupTimer = null;
+    }
+    for (const w of watchers) {
+      try {
+        w.close();
+      } catch {
+        /* ignore */
+      }
+    }
+    watchers.length = 0;
+    attached.clear();
+    started = false;
+  }
+
+  return { start, stop };
+}
diff --git a/apps/desktop/src/main/database/agents.ts b/apps/desktop/src/main/database/agents.ts
new file mode 100644
index 00000000..c0058117
--- /dev/null
+++ b/apps/desktop/src/main/database/agents.ts
@@ -0,0 +1,104 @@
+import type { DatabaseSync } from "node:sqlite";
+import type { AgentRow, AgentHierarchyNode } from "../../shared/agent-db-contract.js";
+
+// Read-only agent store; writes are owned by `lifecycle.ts`.
+export function createAgentStore(db: DatabaseSync) {
+  const getBySessionStmt = db.prepare(
+    "SELECT * FROM agents WHERE session_id = ? ORDER BY started_at ASC",
+  );
+
+  const getBySessionWithChildrenStmt = db.prepare(`
+    SELECT a.*,
+      (SELECT COUNT(*) FROM agents child WHERE child.parent_agent_id = a.id) as children_count
+    FROM agents a WHERE a.session_id = ? ORDER BY a.started_at ASC
+  `);
+
+  function toRow(raw: Record<string, unknown> | undefined): AgentRow | undefined {
+    if (!raw) return undefined;
+    return {
+      id: raw.id as string,
+      sessionId: raw.session_id as string,
+      name: (raw.name as string) ?? null,
+      type: (raw.type as string) ?? null,
+      subagentType: (raw.subagent_type as string) ?? null,
+      status: raw.status as string,
+      task: (raw.task as string) ?? null,
+      currentTool: (raw.current_tool as string) ?? null,
+      startedAt: (raw.started_at as string) ?? null,
+      updatedAt: (raw.updated_at as string) ?? null,
+      endedAt: (raw.ended_at as string) ?? null,
+      awaitingInputSince: (raw.awaiting_input_since as string) ?? null,
+      parentAgentId: (raw.parent_agent_id as string) ?? null,
+      metadata: (raw.metadata as string) ?? null,
+    };
+  }
+
+  function rowsToList(raws: Record<string, unknown>[]): AgentRow[] {
+    return raws.map(toRow).filter(Boolean) as AgentRow[];
+  }
+
+  return {
+    getBySession(sessionId: string): AgentRow[] {
+      return rowsToList(getBySessionStmt.all(sessionId) as Record<string, unknown>[]);
+    },
+
+    getBySessionWithChildren(
+      sessionId: string,
+      eventStore: {
+        getBySession: (sid: string) => {
+          agentId: string | null;
+          eventType: string;
+          toolName: string | null;
+          summary: string | null;
+          createdAt: string | null;
+        }[];
+      },
+    ): AgentHierarchyNode[] {
+      const raws = getBySessionWithChildrenStmt.all(sessionId) as Record<string, unknown>[];
+      const allAgents = raws.map((r) => toRow(r)!);
+
+      // Fetch the session's events once, then bucket by agent id (the prior
+      // implementation re-queried events per agent).
+      const eventsByAgent = new Map<string, AgentHierarchyNode["events"]>();
+      for (const e of eventStore.getBySession(sessionId)) {
+        if (!e.agentId) continue;
+        const list = eventsByAgent.get(e.agentId) ?? [];
+        list.push({
+          eventType: e.eventType,
+          toolName: e.toolName,
+          summary: e.summary,
+          createdAt: e.createdAt,
+        });
+        eventsByAgent.set(e.agentId, list);
+      }
+
+      const agentMap = new Map<string, AgentHierarchyNode>();
+      const roots: AgentHierarchyNode[] = [];
+
+      for (const agent of allAgents) {
+        agentMap.set(agent.id, {
+          agentId: agent.id,
+          name: agent.name,
+          type: agent.type,
+          subagentType: agent.subagentType,
+          status: agent.status,
+          task: agent.task,
+          currentTool: agent.currentTool,
+          children: [],
+          events: eventsByAgent.get(agent.id) ?? [],
+        });
+      }
+
+      for (const agent of allAgents) {
+        const node = agentMap.get(agent.id)!;
+        if (agent.parentAgentId && agentMap.has(agent.parentAgentId)) {
+          agentMap.get(agent.parentAgentId)!.children.push(node);
+        } else {
+          roots.push(node);
+        }
+      }
+
+      return roots;
+    },
+  };
+}
diff --git a/apps/desktop/src/main/database/dashboard.ts b/apps/desktop/src/main/database/dashboard.ts
new file mode 100644
index 00000000..877bb9d4
--- /dev/null
+++ b/apps/desktop/src/main/database/dashboard.ts
@@ -0,0 +1,255 @@
+import type { DatabaseSync } from "node:sqlite";
+import type { DashboardSummary, TokenAnalytics, AnalyticsData, WorkflowQueryData } from "../../shared/agent-db-contract.js";
+
+export function createDashboardQueries(db: DatabaseSync) {
+  const totalSessionsStmt = db.prepare("SELECT COUNT(*) as count FROM sessions");
+  const activeSessionsStmt = db.prepare(
+    "SELECT COUNT(*) as count FROM sessions WHERE status NOT IN ('completed', 'abandoned', 'error')",
+  );
+  const totalAgentsStmt = db.prepare("SELECT COUNT(*) as count FROM agents");
+  const totalEventsStmt = db.prepare("SELECT COUNT(*) as count FROM events");
+  const eventTypeCountStmt = db.prepare(
+    "SELECT COUNT(DISTINCT event_type) as count FROM events",
+  );
+  const totalTokensStmt = db.prepare(`
+    SELECT COALESCE(SUM(input_tokens + output_tokens), 0) as total
+    FROM token_usage
+  `);
+  const recentSessionsStmt = db.prepare(
+    "SELECT id, name, status, model, cwd, started_at FROM sessions ORDER BY started_at DESC LIMIT 10",
+  );
+
+  const tokenAnalyticsStmt = db.prepare(`
+    SELECT COALESCE(SUM(input_tokens), 0) as totalInput,
+      COALESCE(SUM(output_tokens), 0) as totalOutput,
+      COALESCE(SUM(cache_read_tokens), 0) as totalCacheRead,
+      COALESCE(SUM(cache_write_tokens), 0) as totalCacheWrite
+    FROM token_usage
+  `);
+
+  const tokenByModelStmt = db.prepare(`
+    SELECT model,
+      SUM(input_tokens) as inputTokens,
+      SUM(output_tokens) as outputTokens,
+      COUNT(DISTINCT session_id) as sessions
+    FROM token_usage
+    WHERE model IS NOT NULL
+    GROUP BY model
+    ORDER BY SUM(input_tokens + output_tokens) DESC
+  `);
+
+  const tokenByDayStmt = db.prepare(`
+    SELECT DATE(t.created_at) as day,
+      SUM(t.input_tokens) as inputTokens,
+      SUM(t.output_tokens) as outputTokens
+    FROM token_usage t
+    WHERE t.created_at IS NOT NULL
+    GROUP BY DATE(t.created_at)
+    ORDER BY day DESC
+    LIMIT 30
+  `);
+
+  // Analytics prepared statements
+  const analyticsEventsByTypeStmt = db.prepare(
+    "SELECT event_type as eventType, COUNT(*) as count FROM events GROUP BY event_type ORDER BY count DESC",
+  );
+  const analyticsToolUsageStmt = db.prepare(
+    "SELECT tool_name as toolName, COUNT(*) as count FROM events WHERE created_at > datetime('now', '-30 days') AND tool_name IS NOT NULL GROUP BY tool_name ORDER BY count DESC LIMIT 20",
+  );
+  const analyticsDailyEventsStmt = db.prepare(
+    "SELECT DATE(created_at) as date, COUNT(*) as count FROM events WHERE created_at > datetime('now', '-365 days') GROUP BY DATE(created_at) ORDER BY date ASC",
+  );
+  const analyticsSessionsByStatusStmt = db.prepare(
+    "SELECT status, COUNT(*) as count FROM sessions GROUP BY status",
+  );
+  const analyticsAgentsByStatusStmt = db.prepare(
+    "SELECT status, COUNT(*) as count FROM agents GROUP BY status",
+  );
+  const analyticsAgentsByTypeStmt = db.prepare(
+    "SELECT COALESCE(type, 'unknown') as type, COUNT(*) as count FROM agents GROUP BY type ORDER BY count DESC",
+  );
+
+  // Workflow prepared statements
+  const wfTotalSubagentsStmt = db.prepare(
+    "SELECT COUNT(*) as count FROM agents WHERE type = 'subagent' OR parent_agent_id IS NOT NULL",
+  );
+  const wfCompletedAgentsStmt = db.prepare(
+    "SELECT COUNT(*) as count FROM agents WHERE status = 'completed'",
+  );
+  const wfErrorAgentsStmt = db.prepare(
+    "SELECT COUNT(*) as count FROM agents WHERE status = 'failed' OR status = 'error'",
+  );
+  const wfDepthStmt = db.prepare(`
+    WITH RECURSIVE agent_depth(id, session_id, depth) AS (
+      SELECT id, session_id, 0 FROM agents WHERE parent_agent_id IS NULL
+      UNION ALL
+      SELECT a.id, a.session_id, ad.depth + 1
+      FROM agents a JOIN agent_depth ad ON a.parent_agent_id = ad.id
+    )
+    SELECT session_id, MAX(depth) as maxDepth FROM agent_depth GROUP BY session_id
+  `);
+  const wfDurationStmt = db.prepare(`
+    SELECT AVG(CAST((julianday(COALESCE(ended_at, updated_at)) - julianday(started_at)) * 86400 AS REAL)) as avg
+    FROM sessions WHERE started_at IS NOT NULL
+  `);
+  const wfSubagentTypesStmt = db.prepare(`
+    SELECT COALESCE(subagent_type, COALESCE(name, 'unknown')) as subagentType,
+      COUNT(*) as count,
+      SUM(CASE WHEN status = 'completed' THEN 1 ELSE 0 END) as completed,
+      SUM(CASE WHEN status IN ('failed', 'error') THEN 1 ELSE 0 END) as errors
+    FROM agents WHERE parent_agent_id IS NOT NULL OR type = 'subagent'
+    GROUP BY subagentType ORDER BY count DESC
+  `);
+  const wfMainCountStmt = db.prepare(
+    "SELECT COUNT(*) as count FROM agents WHERE parent_agent_id IS NULL AND (type IS NULL OR type != 'subagent')",
+  );
+  const wfEdgesStmt = db.prepare(`
+    SELECT COALESCE(p.subagent_type, COALESCE(p.name, 'main')) as source,
+      COALESCE(c.subagent_type, COALESCE(c.name, 'unknown')) as target,
+      COUNT(*) as weight
+    FROM agents c JOIN agents p ON c.parent_agent_id = p.id
+    GROUP BY source, target ORDER BY weight DESC LIMIT 50
+  `);
+  const wfToolTransitionsStmt = db.prepare(`
+    WITH recent_tools AS (
+      SELECT tool_name, session_id, rowid
+      FROM events
+      WHERE tool_name IS NOT NULL
+        AND created_at > datetime('now', '-7 days')
+    ),
+    tool_seq AS (
+      SELECT tool_name,
+        LEAD(tool_name) OVER (PARTITION BY session_id ORDER BY rowid) as next_tool
+      FROM recent_tools
+    )
+    SELECT tool_name as source, next_tool as target, COUNT(*) as value
+    FROM tool_seq
+    WHERE next_tool IS NOT NULL
+    GROUP BY source, target ORDER BY value DESC LIMIT 30
+  `);
+  const wfCooccurrenceStmt = db.prepare(`
+    SELECT COALESCE(a1.subagent_type, COALESCE(a1.name, 'unknown')) as source,
+      COALESCE(a2.subagent_type, COALESCE(a2.name, 'unknown')) as target,
+      COUNT(DISTINCT a1.session_id) as weight
+    FROM agents a1 JOIN agents a2 ON a1.session_id = a2.session_id AND a1.id < a2.id
+    GROUP BY source, target ORDER BY weight DESC LIMIT 30
+  `);
+
+  return {
+    getSummary(): DashboardSummary {
+      const totalSessions = (totalSessionsStmt.get() as { count: number }).count;
+      const activeSessions = (activeSessionsStmt.get() as { count: number }).count;
+      const totalAgents = (totalAgentsStmt.get() as { count: number }).count;
+      const totalEvents = (totalEventsStmt.get() as { count: number }).count;
+      const eventTypeCount = (eventTypeCountStmt.get() as { count: number }).count;
+      const totalTokens = (totalTokensStmt.get() as { total: number }).total;
+      const recentSessions = recentSessionsStmt.all() as Array<{
+        id: string;
+        name: string | null;
+        status: string;
+        model: string | null;
+        cwd: string | null;
+        started_at: string | null;
+      }>;
+
+      return {
+        totalSessions,
+        activeSessions,
+        totalAgents,
+        totalEvents,
+        eventTypeCount,
+        totalTokens,
+        recentSessions: recentSessions.map((s) => ({
+          id: s.id,
+          name: s.name,
+          status: s.status,
+          model: s.model,
+          cwd: s.cwd,
+          startedAt: s.started_at,
+        })),
+      };
+    },
+
+    getTokenAnalytics(): TokenAnalytics {
+      const totals = tokenAnalyticsStmt.get() as { totalInput: number; totalOutput: number; totalCacheRead: number; totalCacheWrite: number };
+      const byModel = tokenByModelStmt.all() as Array<{ model: string; inputTokens: number; outputTokens: number; sessions: number }>;
+      const byDay = tokenByDayStmt.all() as Array<{ day: string; inputTokens: number; outputTokens: number }>;
+
+      return {
+        totalInputTokens: totals.totalInput,
+        totalOutputTokens: totals.totalOutput,
+        totalCacheReadTokens: totals.totalCacheRead,
+        totalCacheWriteTokens: totals.totalCacheWrite,
+        byModel,
+        byDay,
+      };
+    },
+
+    getAnalytics(): AnalyticsData {
+      const tokens = this.getTokenAnalytics();
+      const eventsByType = analyticsEventsByTypeStmt.all() as Array<{ eventType: string; count: number }>;
+      const toolUsage = analyticsToolUsageStmt.all() as Array<{ toolName: string; count: number }>;
+      const dailyEvents = analyticsDailyEventsStmt.all() as Array<{ date: string; count: number }>;
+      const sessionsByStatus = analyticsSessionsByStatusStmt.all() as Array<{ status: string; count: number }>;
+      const agentsByStatus = analyticsAgentsByStatusStmt.all() as Array<{ status: string; count: number }>;
+      const agentsByType = analyticsAgentsByTypeStmt.all() as Array<{ type: string; count: number }>;
+      const totalSessions = (totalSessionsStmt.get() as { count: number }).count;
+      const totalAgents = (totalAgentsStmt.get() as { count: number }).count;
+      const totalEvents = (totalEventsStmt.get() as { count: number }).count;
+
+      return { tokens, eventsByType, toolUsage, dailyEvents, sessionsByStatus, agentsByStatus, agentsByType, totalSessions, totalAgents, totalEvents };
+    },
+
+    getWorkflowData(): WorkflowQueryData {
+      const totalSessions = (totalSessionsStmt.get() as { count: number }).count;
+      const totalAgents = (totalAgentsStmt.get() as { count: number }).count;
+      const totalSubagents = (wfTotalSubagentsStmt.get() as { count: number }).count;
+      const avgSubagents = totalSessions > 0 ? totalSubagents / totalSessions : 0;
+
+      const completedAgents = (wfCompletedAgentsStmt.get() as { count: number }).count;
+      const errorAgents = (wfErrorAgentsStmt.get() as { count: number }).count;
+      const successRate = (completedAgents + errorAgents) > 0 ? (completedAgents / (completedAgents + errorAgents)) * 100 : 100;
+
+      const depthRows = wfDepthStmt.all() as Array<{ session_id: string; maxDepth: number }>;
+      const avgDepth = depthRows.length > 0 ? depthRows.reduce((s, r) => s + r.maxDepth, 0) / depthRows.length : 0;
+
+      const durationRow = wfDurationStmt.get() as { avg: number | null };
+      const avgDurationSec = durationRow.avg ?? 0;
+
+      const subagentTypes = wfSubagentTypesStmt.all() as Array<{ subagentType: string; count: number; completed: number; errors: number }>;
+      const mainCount = (wfMainCountStmt.get() as { count: number }).count;
+      const edges = wfEdgesStmt.all() as Array<{ source: string; target: string; weight: number }>;
+      const outcomes = analyticsSessionsByStatusStmt.all() as Array<{ status: string; count: number }>;
+      const toolTransitions = wfToolTransitionsStmt.all() as Array<{ source: string; target: string; value: number }>;
+      const toolCounts = analyticsToolUsageStmt.all() as Array<{ toolName: string; count: number }>;
+      const cooccurrence = wfCooccurrenceStmt.all() as Array<{ source: string; target: string; weight: number }>;
+
+      const effectiveness = subagentTypes.map((st) => ({
+        subagentType: st.subagentType,
+        total: st.count,
+        completed: st.completed,
+        errors: st.errors,
+        sessions: 0,
+        successRate: st.count > 0 ? (st.completed / st.count) * 100 : 0,
+        avgDuration: null as number | null,
+        trend: [] as number[],
+      }));
+
+      return {
+        stats: {
+          totalSessions, totalAgents, totalSubagents, avgSubagents,
+          successRate, avgDepth, avgDurationSec,
+          totalCompactions: 0, avgCompactions: 0,
+          topFlow: toolTransitions.length > 0 ? { source: toolTransitions[0].source, target: toolTransitions[0].target, count: toolTransitions[0].value } : null,
+        },
+        orchestration: {
+          sessionCount: totalSessions, mainCount, subagentTypes, edges, outcomes,
+          compactions: { total: 0, sessions: 0 },
+        },
+        toolFlow: { transitions: toolTransitions, toolCounts },
+        effectiveness,
+        cooccurrence,
+      };
+    },
+  };
+}
diff --git a/apps/desktop/src/main/database/events.ts b/apps/desktop/src/main/database/events.ts
new file mode 100644
index 00000000..68e0dad0
--- /dev/null
+++ b/apps/desktop/src/main/database/events.ts
@@ -0,0 +1,76 @@
+import type { DatabaseSync } from "node:sqlite";
+import type { EventRow, EventCountByType, EventWithSession } from "../../shared/agent-db-contract.js";
+
+// Read-only event store; event writes are owned by `lifecycle.ts`.
+export function createEventStore(db: DatabaseSync) {
+  const getBySessionStmt = db.prepare(
+    "SELECT * FROM events WHERE session_id = ? ORDER BY created_at ASC",
+  );
+
+  const getBySessionAndAgentStmt = db.prepare(
+    "SELECT * FROM events WHERE session_id = ? AND agent_id = ? ORDER BY created_at ASC",
+  );
+
+  const getAllStmt = db.prepare(
+    "SELECT e.*, s.name as session_name FROM events e LEFT JOIN sessions s ON s.id = e.session_id ORDER BY e.created_at DESC LIMIT 200",
+  );
+
+  const getEventsWithSessionStmt = db.prepare(
+    "SELECT e.*, s.name as session_name FROM events e LEFT JOIN sessions s ON s.id = e.session_id WHERE e.session_id = ? ORDER BY e.created_at ASC",
+  );
+
+  const getCountByTypeStmt = db.prepare(
+    "SELECT event_type, COUNT(*) as count FROM events GROUP BY event_type ORDER BY count DESC",
+  );
+
+  function toRow(raw: Record<string, unknown> | undefined): EventRow | undefined {
+    if (!raw) return undefined;
+    return {
+      id: raw.id as string,
+      sessionId: raw.session_id as string,
+      agentId: (raw.agent_id as string) ?? null,
+      eventType: raw.event_type as string,
+      toolName: (raw.tool_name as string) ?? null,
+      summary: (raw.summary as string) ?? null,
+      data: (raw.data as string) ?? null,
+      createdAt: (raw.created_at as string) ?? null,
+    };
+  }
+
+  function toEventWithSession(raw: Record<string, unknown> | undefined): EventWithSession | undefined {
+    if (!raw) return undefined;
+    const row = toRow(raw);
+    if (!row) return undefined;
+    return { ...row, sessionName: (raw.session_name as string) ?? null };
+  }
+
+  function eventsWithSessionToList(raws: Record<string, unknown>[]): EventWithSession[] {
+    return raws.map(toEventWithSession).filter(Boolean) as EventWithSession[];
+  }
+
+  function rowsToList(raws: Record<string, unknown>[]): EventRow[] {
+    return raws.map(toRow).filter(Boolean) as EventRow[];
+  }
+
+  return {
+    getBySession(sessionId: string): EventRow[] {
+      return rowsToList(getBySessionStmt.all(sessionId) as Record<string, unknown>[]);
+    },
+
+    getBySessionAndAgent(sessionId: string, agentId: string): EventRow[] {
+      return rowsToList(getBySessionAndAgentStmt.all(sessionId, agentId) as Record<string, unknown>[]);
+    },
+
+    getAll(): EventWithSession[] {
+      return eventsWithSessionToList(getAllStmt.all() as Record<string, unknown>[]);
+    },
+
+    getWithSession(sessionId: string): EventWithSession[] {
+      return eventsWithSessionToList(getEventsWithSessionStmt.all(sessionId) as Record<string, unknown>[]);
+    },
+
+    getCountByType(): EventCountByType[] {
+      return getCountByTypeStmt.all() as unknown as EventCountByType[];
+    },
+  };
+}
diff --git a/apps/desktop/src/main/database/index.ts b/apps/desktop/src/main/database/index.ts
new file mode 100644
index 00000000..aeb19cf5
--- /dev/null
+++ b/apps/desktop/src/main/database/index.ts
@@ -0,0 +1,91 @@
+import { DatabaseSync } from "node:sqlite";
+import { existsSync, mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import { CURRENT_SCHEMA_VERSION, MIGRATIONS } from "./schema.js";
+import { createSessionStore } from "./sessions.js";
+import { createAgentStore } from "./agents.js";
+import { createEventStore } from "./events.js";
+import { createTokenUsageStore } from "./token-usage.js";
+import { createDashboardQueries } from "./dashboard.js";
+import type { DashboardSummary } from "../../shared/agent-db-contract.js";
+
+export interface AgentDatabase {
+  /**
+   * The underlying single shared connection. All in-process access — hook
+   * writes (lifecycle), IPC reads, the cloud relay, and cost reconciliation —
+   * goes through this one connection. node:sqlite `DatabaseSync` is synchronous
+   * and the main process is single-threaded, so a single connection eliminates
+   * cross-connection contention by construction (FEA-1497 Phase 1).
+   */
+  connection: DatabaseSync;
+  sessions: ReturnType<typeof createSessionStore>;
+  agents: ReturnType<typeof createAgentStore>;
+  events: ReturnType<typeof createEventStore>;
+  tokenUsage: ReturnType<typeof createTokenUsageStore>;
+  dashboard: ReturnType<typeof createDashboardQueries>;
+  getSummary: () => DashboardSummary;
+  run: (sql: string, ...params: unknown[]) => void;
+  close: () => void;
+}
+
+function runMigrations(db: DatabaseSync): void {
+  const currentVersion = (db.prepare("PRAGMA user_version").get() as { user_version: number }).user_version;
+
+  for (let v = currentVersion; v < CURRENT_SCHEMA_VERSION; v++) {
+    const migration = MIGRATIONS[v];
+    if (!migration) {
+      throw new Error(`Missing migration for version ${v} → ${v + 1}`);
+    }
+    // Apply the migration DDL and the user_version bump atomically so a crash
+    // mid-migration rolls back both — the next boot then re-runs the step
+    // cleanly instead of finding a half-applied schema at the old version.
+    db.exec("BEGIN");
+    try {
+      db.exec(migration);
+      db.exec(`PRAGMA user_version = ${v + 1}`);
+      db.exec("COMMIT");
+    } catch (error) {
+      try {
+        db.exec("ROLLBACK");
+      } catch {
+        /* ignore rollback failure */
+      }
+      throw error;
+    }
+  }
+}
+
+export function openAgentDatabase(dbPath: string): AgentDatabase {
+  const dir = dirname(dbPath);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+
+  const db = new DatabaseSync(dbPath);
+  db.exec("PRAGMA journal_mode=WAL");
+  db.exec("PRAGMA foreign_keys=ON");
+  // Defensive: even though all access is single-connection + synchronous, a
+  // busy_timeout guards against any future second handle (e.g. a worker thread).
+  db.exec("PRAGMA busy_timeout=5000");
+  runMigrations(db);
+
+  const sessions = createSessionStore(db);
+  const agents = createAgentStore(db);
+  const events = createEventStore(db);
+  const tokenUsage = createTokenUsageStore(db);
+  const dashboard = createDashboardQueries(db);
+
+  return {
+    connection: db,
+    sessions,
+    agents,
+    events,
+    tokenUsage,
+    dashboard,
+    getSummary: () => dashboard.getSummary(),
+    run: (sql: string, ...params: unknown[]) => {
+      db.prepare(sql).run(...params as never[]);
+    },
+    close: () => db.close(),
+  };
+}
diff --git a/apps/desktop/src/main/database/ipc-validation.ts b/apps/desktop/src/main/database/ipc-validation.ts
new file mode 100644
index 00000000..05a2c9f4
--- /dev/null
+++ b/apps/desktop/src/main/database/ipc-validation.ts
@@ -0,0 +1,33 @@
+// Runtime validation for renderer-supplied identifiers that reach the
+// `desktop:db:*` IPC handlers. IPC is a runtime trust boundary: the TypeScript
+// annotations on the handler arguments are erased at runtime, so a malformed
+// `id` / `sessionId` / `agentId` (an object, number, null, or oversized string)
+// from a compromised or buggy renderer could otherwise reach `node:sqlite`
+// bindings and throw inside the query or alter its behavior. The DB IPC handlers
+// must coerce every identifier through these guards before it touches the store
+// layer. (CLAUDE.md: runtime-validate gateway, IPC, and persisted payloads.)
+
+/**
+ * Upper bound on identifier length. Session/agent ids are short UUID-ish
+ * strings; anything dramatically longer is malformed input, not a real id.
+ */
+export const MAX_DB_ID_LENGTH = 512;
+
+/**
+ * Validate a renderer-supplied database identifier.
+ *
+ * Returns the value unchanged when it is a usable id (a non-empty string within
+ * the length bound), or `null` when it is not. Callers treat `null` as "no such
+ * record" — they return the same empty/undefined result the handlers already
+ * return when the monitor is disabled, so a bad argument can never reach a
+ * SQLite binding.
+ */
+export function coerceDbId(value: unknown): string | null {
+  if (typeof value !== "string") {
+    return null;
+  }
+  if (value.length === 0 || value.length > MAX_DB_ID_LENGTH) {
+    return null;
+  }
+  return value;
+}
diff --git a/apps/desktop/src/main/database/lifecycle.ts b/apps/desktop/src/main/database/lifecycle.ts
new file mode 100644
index 00000000..03611004
--- /dev/null
+++ b/apps/desktop/src/main/database/lifecycle.ts
@@ -0,0 +1,500 @@
+import { randomUUID } from "node:crypto";
+import type { DatabaseSync } from "node:sqlite";
+import { extractTranscriptTokens, type TranscriptExtract } from "./transcript.js";
+import type { createTokenUsageStore } from "./token-usage.js";
+
+/**
+ * In-process hook lifecycle state machine (FEA-1497 Phase 1).
+ *
+ * Ports the vendor `server/routes/hooks.js` `processEvent` transaction onto the
+ * in-process node:sqlite repository: it owns ALL session/agent/event/token
+ * writes. Each hook event is applied in a single `BEGIN IMMEDIATE` transaction
+ * so a malformed event cannot leave half-written state, and node:sqlite being
+ * synchronous + single-threaded means concurrent hook POSTs serialize without
+ * SQLITE_BUSY.
+ *
+ * Status vocabulary (matches the vendor + canonical AgentSession*):
+ *   session: 'active' | 'completed' | 'abandoned' | 'error'
+ *   agent:   'working' | 'waiting'  | 'completed' | 'error'
+ * "Waiting for input" is also surfaced via the `awaiting_input_since` timestamp.
+ */
+
+/** Snake_case hook payload `data` block as delivered by the hook handlers. */
+export interface HookData {
+  session_id?: string;
+  cwd?: string;
+  model?: string;
+  transcript_path?: string;
+  tool_name?: string;
+  tool_input?: Record<string, unknown> | null;
+  source?: string;
+  stop_reason?: string;
+  message?: string;
+  agent_type?: string;
+  subagent_type?: string;
+  prompt?: string;
+  description?: string;
+  session_name?: string;
+  [key: string]: unknown;
+}
+
+export interface LifecycleDeps {
+  tokenUsage: ReturnType<typeof createTokenUsageStore>;
+  /** Resolve a billing mode for a harness at session creation (FEA-1434). */
+  detectBillingMode: (harness: string) => string;
+  /** Injectable transcript extractor (tests pass a stub; default reads the file). */
+  extractTranscript?: (path: string) => TranscriptExtract | null;
+  /** Notify the renderer a session changed (live updates). */
+  emit?: (sessionId: string) => void;
+  /** Injectable clock (tests pin it). Returns an ISO timestamp. */
+  now?: () => string;
+  /** Key-free diagnostic sink. */
+  log?: (message: string) => void;
+  /** Minutes of inactivity after which a still-active session is abandoned. */
+  staleMinutes?: number;
+}
+
+const COMPACTION_RE = /compact|compress|context.*(reduc|truncat|summar)/i;
+// Permission / waiting-for-input notifications (not idle "finished responding").
+const WAITING_INPUT_RE =
+  /needs your permission|waiting for your input|is waiting|requires approval|permission to use/i;
+
+interface SessionRowRaw {
+  id: string;
+  status: string;
+  harness: string | null;
+  billing_mode: string | null;
+  model: string | null;
+}
+
+interface AgentRowRaw {
+  id: string;
+  status: string;
+  type: string | null;
+  parent_agent_id: string | null;
+}
+
+export function createLifecycle(db: DatabaseSync, deps: LifecycleDeps) {
+  const nowFn = deps.now ?? (() => new Date().toISOString());
+  const log = deps.log ?? (() => {});
+  const staleMinutes = deps.staleMinutes ?? 180;
+  const extract = deps.extractTranscript ?? extractTranscriptTokens;
+
+  // ── Prepared statements ────────────────────────────────────────────────────
+  const getSessionStmt = db.prepare(
+    "SELECT id, status, harness, billing_mode, model FROM sessions WHERE id = ?",
+  );
+  const insertSessionStmt = db.prepare(`
+    INSERT INTO sessions (id, name, status, cwd, model, started_at, updated_at, harness, billing_mode)
+    VALUES (?, ?, 'active', ?, ?, ?, ?, ?, ?)
+  `);
+  const setSessionStatusStmt = db.prepare(
+    "UPDATE sessions SET status = ?, updated_at = ?, ended_at = ? WHERE id = ?",
+  );
+  const touchSessionStmt = db.prepare("UPDATE sessions SET updated_at = ? WHERE id = ?");
+  const setSessionModelStmt = db.prepare(
+    "UPDATE sessions SET model = ?, updated_at = ? WHERE id = ? AND COALESCE(model, '') != ?",
+  );
+  const setSessionAwaitingStmt = db.prepare(
+    "UPDATE sessions SET awaiting_input_since = ?, updated_at = ? WHERE id = ?",
+  );
+  const clearSessionAwaitingStmt = db.prepare(
+    "UPDATE sessions SET awaiting_input_since = NULL, updated_at = ? WHERE id = ?",
+  );
+
+  const getAgentStmt = db.prepare(
+    "SELECT id, status, type, parent_agent_id FROM agents WHERE id = ?",
+  );
+  const insertAgentStmt = db.prepare(`
+    INSERT INTO agents (id, session_id, name, type, subagent_type, status, task, current_tool, started_at, updated_at, parent_agent_id, metadata)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+  const setAgentStatusStmt = db.prepare(
+    "UPDATE agents SET status = ?, updated_at = ?, ended_at = ? WHERE id = ?",
+  );
+  const setAgentToolStmt = db.prepare(
+    "UPDATE agents SET current_tool = ?, status = 'working', updated_at = ? WHERE id = ?",
+  );
+  const setAgentAwaitingStmt = db.prepare(
+    "UPDATE agents SET awaiting_input_since = ?, status = ?, updated_at = ? WHERE id = ?",
+  );
+  const clearSessionAgentsAwaitingStmt = db.prepare(
+    "UPDATE agents SET awaiting_input_since = NULL, updated_at = ? WHERE session_id = ? AND awaiting_input_since IS NOT NULL",
+  );
+  const promoteMainStmt = db.prepare(
+    "UPDATE agents SET status = 'working', awaiting_input_since = NULL, updated_at = ? WHERE id = ? AND status != 'working'",
+  );
+  const completeNonTerminalAgentsStmt = db.prepare(
+    "UPDATE agents SET status = ?, ended_at = ?, updated_at = ? WHERE session_id = ? AND status NOT IN ('completed', 'error')",
+  );
+  // Deepest working subagent for parent inference (recursive depth over the tree).
+  const deepestWorkingStmt = db.prepare(`
+    WITH RECURSIVE chain(id, depth) AS (
+      SELECT id, 0 FROM agents WHERE session_id = ? AND parent_agent_id IS NULL
+      UNION ALL
+      SELECT a.id, c.depth + 1 FROM agents a JOIN chain c ON a.parent_agent_id = c.id
+    )
+    SELECT a.id AS id FROM chain c JOIN agents a ON a.id = c.id
+    WHERE a.status = 'working' AND a.type = 'subagent'
+    ORDER BY c.depth DESC, a.started_at DESC LIMIT 1
+  `);
+  const workingSubagentsStmt = db.prepare(
+    "SELECT id, name, subagent_type, task FROM agents WHERE session_id = ? AND type = 'subagent' AND status = 'working' ORDER BY started_at DESC",
+  );
+  const findStaleSessionsStmt = db.prepare(
+    "SELECT id FROM sessions WHERE status = 'active' AND id != ? AND updated_at < ?",
+  );
+
+  const insertEventStmt = db.prepare(`
+    INSERT INTO events (id, session_id, agent_id, event_type, tool_name, summary, data, created_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+
+  // ── Helpers ─────────────────────────────────────────────────────────────────
+  function mainAgentId(sessionId: string): string {
+    return `${sessionId}-main`;
+  }
+
+  function getSession(sessionId: string): SessionRowRaw | undefined {
+    return getSessionStmt.get(sessionId) as SessionRowRaw | undefined;
+  }
+
+  function getAgent(agentId: string): AgentRowRaw | undefined {
+    return getAgentStmt.get(agentId) as AgentRowRaw | undefined;
+  }
+
+  function ensureSession(sessionId: string, data: HookData, harness: string, now: string): SessionRowRaw {
+    const existing = getSession(sessionId);
+    if (existing) {
+      return existing;
+    }
+    const billingMode = safe(() => deps.detectBillingMode(harness)) ?? "unknown";
+    insertSessionStmt.run(
+      sessionId,
+      data.session_name ?? null,
+      data.cwd ?? null,
+      data.model ?? null,
+      now,
+      now,
+      harness,
+      billingMode,
+    );
+    // Every session has a synthetic main agent.
+    insertAgentStmt.run(
+      mainAgentId(sessionId),
+      sessionId,
+      "main",
+      "main",
+      null,
+      "working",
+      null,
+      null,
+      now,
+      now,
+      null,
+      null,
+    );
+    return getSession(sessionId)!;
+  }
+
+  function clearAwaitingInput(sessionId: string, now: string): void {
+    clearSessionAwaitingStmt.run(now, sessionId);
+    clearSessionAgentsAwaitingStmt.run(now, sessionId);
+  }
+
+  function setMainWaiting(sessionId: string, now: string): void {
+    setSessionAwaitingStmt.run(now, now, sessionId);
+    setAgentAwaitingStmt.run(now, "waiting", now, mainAgentId(sessionId));
+  }
+
+  function insertEvent(
+    sessionId: string,
+    agentId: string | null,
+    eventType: string,
+    data: HookData,
+    now: string,
+    summary?: string,
+  ): void {
+    insertEventStmt.run(
+      randomUUID(),
+      sessionId,
+      agentId,
+      eventType,
+      data.tool_name ?? null,
+      summary ?? null,
+      safe(() => JSON.stringify(data)) ?? null,
+      now,
+    );
+  }
+
+  /** Reactivate a non-active session per the vendor's gate. */
+  function maybeReactivate(session: SessionRowRaw, hookType: string, now: string): void {
+    if (session.status === "active" || hookType === "SessionEnd") {
+      return;
+    }
+    const isUserActivity = hookType === "UserPromptSubmit" || hookType === "PreToolUse";
+    const isStopLike = hookType === "Stop" || hookType === "SubagentStop";
+    const reactivate =
+      isUserActivity ||
+      (!isStopLike && session.status !== "error") ||
+      (isStopLike && (session.status === "completed" || session.status === "abandoned"));
+    if (reactivate) {
+      setSessionStatusStmt.run("active", now, null, session.id);
+      promoteMainStmt.run(now, mainAgentId(session.id));
+      session.status = "active";
+    }
+  }
+
+  function spawnSubagent(sessionId: string, data: HookData, now: string): string {
+    const input = (data.tool_input as Record<string, unknown> | undefined) ?? {};
+    const description = strOf(input.description) ?? strOf(data.description);
+    const subagentType = strOf(input.subagent_type) ?? strOf(data.subagent_type);
+    const prompt = strOf(input.prompt) ?? strOf(data.prompt);
+    const name =
+      description ??
+      subagentType ??
+      (prompt ? prompt.split("\n")[0].slice(0, 60) : undefined) ??
+      "Subagent";
+
+    // Parent inference: a working main agent is the parent; otherwise the
+    // deepest currently-working subagent; otherwise fall back to main.
+    const main = getAgent(mainAgentId(sessionId));
+    let parentId = mainAgentId(sessionId);
+    if (!main || main.status !== "working") {
+      const deepest = deepestWorkingStmt.get(sessionId) as { id: string } | undefined;
+      if (deepest) {
+        parentId = deepest.id;
+      }
+    }
+
+    const agentId = `${sessionId}-sub-${randomUUID().slice(0, 8)}`;
+    insertAgentStmt.run(
+      agentId,
+      sessionId,
+      name,
+      "subagent",
+      subagentType ?? null,
+      "working",
+      prompt ? prompt.slice(0, 500) : null,
+      null,
+      now,
+      now,
+      parentId,
+      null,
+    );
+    return agentId;
+  }
+
+  function matchSubagent(sessionId: string, data: HookData): string | null {
+    const candidates = workingSubagentsStmt.all(sessionId) as Array<{
+      id: string;
+      name: string | null;
+      subagent_type: string | null;
+      task: string | null;
+    }>;
+    if (candidates.length === 0) {
+      return null;
+    }
+    const prefix = strOf(data.description) ?? strOf(data.agent_type) ?? strOf(data.subagent_type);
+    if (prefix) {
+      const byName = candidates.find((a) => a.name != null && a.name.startsWith(prefix));
+      if (byName) {
+        return byName.id;
+      }
+    }
+    if (data.agent_type) {
+      const byType = candidates.find((a) => a.subagent_type === data.agent_type);
+      if (byType) {
+        return byType.id;
+      }
+    }
+    if (data.prompt) {
+      const task = String(data.prompt).slice(0, 500);
+      const byTask = candidates.find((a) => a.task === task);
+      if (byTask) {
+        return byTask.id;
+      }
+    }
+    return candidates[0].id; // fallback: oldest-started working subagent
+  }
+
+  function sweepStaleSessions(currentSessionId: string, now: string): void {
+    const cutoff = new Date(Date.now() - staleMinutes * 60_000).toISOString();
+    const stale = findStaleSessionsStmt.all(currentSessionId, cutoff) as Array<{ id: string }>;
+    for (const { id } of stale) {
+      completeNonTerminalAgentsStmt.run("completed", now, now, id);
+      setSessionStatusStmt.run("abandoned", now, now, id);
+    }
+  }
+
+  function applyTranscript(sessionId: string, extract: TranscriptExtract, now: string): void {
+    if (extract.latestModel) {
+      setSessionModelStmt.run(extract.latestModel, now, sessionId, extract.latestModel);
+    }
+    for (const [model, counts] of extract.tokensByModel) {
+      deps.tokenUsage.replace(sessionId, model, counts, now);
+    }
+  }
+
+  // ── Per-event handlers ───────────────────────────────────────────────────────
+  function handle(hookType: string, data: HookData, sessionId: string, harness: string, now: string): void {
+    ensureSession(sessionId, data, harness, now);
+    const session = getSession(sessionId)!;
+    maybeReactivate(session, hookType, now);
+    touchSessionStmt.run(now, sessionId);
+    const main = mainAgentId(sessionId);
+
+    switch (hookType) {
+      case "SessionStart": {
+        // A freshly started/resumed session sits at a prompt awaiting input.
+        setMainWaiting(sessionId, now);
+        sweepStaleSessions(sessionId, now);
+        insertEvent(sessionId, main, "SessionStart", data, now, data.source === "resume" ? "Resumed session" : "Started session");
+        break;
+      }
+      case "UserPromptSubmit": {
+        clearAwaitingInput(sessionId, now);
+        promoteMainStmt.run(now, main);
+        insertEvent(sessionId, main, "UserPromptSubmit", data, now);
+        break;
+      }
+      case "PreToolUse": {
+        clearAwaitingInput(sessionId, now);
+        if (data.tool_name === "Agent" || data.tool_name === "Task") {
+          const agentId = spawnSubagent(sessionId, data, now);
+          insertEvent(sessionId, agentId, "PreToolUse", data, now, "Spawned subagent");
+        } else {
+          setAgentToolStmt.run(data.tool_name ?? null, now, main);
+          insertEvent(sessionId, main, "PreToolUse", data, now);
+        }
+        break;
+      }
+      case "PostToolUse": {
+        clearAwaitingInput(sessionId, now);
+        const mainAgent = getAgent(main);
+        if (mainAgent && mainAgent.status === "working") {
+          setAgentToolStmt.run(null, now, main);
+        }
+        insertEvent(sessionId, main, "PostToolUse", data, now);
+        break;
+      }
+      case "Stop": {
+        if (data.stop_reason === "error") {
+          setAgentStatusStmt.run("error", now, now, main);
+          setSessionStatusStmt.run("error", now, now, sessionId);
+          clearAwaitingInput(sessionId, now);
+        } else {
+          // Turn ended; session stays active, main waits for the next prompt.
+          setMainWaiting(sessionId, now);
+        }
+        insertEvent(sessionId, main, "Stop", data, now);
+        break;
+      }
+      case "SubagentStop": {
+        const agentId = matchSubagent(sessionId, data);
+        if (agentId) {
+          setAgentStatusStmt.run("completed", now, now, agentId);
+        }
+        insertEvent(sessionId, agentId, "SubagentStop", data, now);
+        break;
+      }
+      case "Notification": {
+        const message = strOf(data.message) ?? "";
+        if (COMPACTION_RE.test(message)) {
+          insertEvent(sessionId, main, "Compaction", data, now, "Context compaction");
+        } else if (WAITING_INPUT_RE.test(message)) {
+          setMainWaiting(sessionId, now);
+          insertEvent(sessionId, main, "Notification", data, now, message.slice(0, 200));
+        } else {
+          insertEvent(sessionId, main, "Notification", data, now, message.slice(0, 200) || undefined);
+        }
+        break;
+      }
+      case "SessionEnd": {
+        clearAwaitingInput(sessionId, now);
+        const finalStatus = session.status === "error" ? "error" : "completed";
+        completeNonTerminalAgentsStmt.run(
+          finalStatus === "error" ? "error" : "completed",
+          now,
+          now,
+          sessionId,
+        );
+        setSessionStatusStmt.run(finalStatus, now, now, sessionId);
+        insertEvent(sessionId, main, "SessionEnd", data, now);
+        break;
+      }
+      default: {
+        insertEvent(sessionId, main, hookType, data, now);
+        break;
+      }
+    }
+  }
+
+  return {
+    /**
+     * Apply one hook event. `harness` is stamped at the listener boundary
+     * ("claude" | "codex"). Returns true if a write occurred, false if ignored.
+     * Never throws — a bad event is logged and rolled back, never propagated to
+     * the fail-silent hook handler.
+     */
+    processEvent(hookType: string, data: HookData, harness: string): boolean {
+      // `session_id` arrives as `unknown` through the listener's zod envelope
+      // (`data` is validated only as a string-keyed record), so its declared
+      // `string` type is not enforced at runtime. Guard the actual type before
+      // it becomes a SQLite primary-key binding: a non-string (e.g. an object)
+      // would otherwise be stringified to "[object Object]" and stored as a
+      // junk primary key. (CLAUDE.md: runtime-validate persisted payloads.)
+      const sessionId = data.session_id;
+      if (typeof sessionId !== "string" || sessionId.length === 0) {
+        return false;
+      }
+      // Read the transcript (file IO) BEFORE opening the write transaction.
+      let transcript: TranscriptExtract | null = null;
+      if (data.transcript_path) {
+        try {
+          transcript = extract(data.transcript_path);
+        } catch {
+          transcript = null;
+        }
+      }
+      const now = nowFn();
+      try {
+        // BEGIN is inside the try so that a stale open transaction (e.g. a prior
+        // ROLLBACK that itself failed) surfaces here and is rolled back below,
+        // letting the next event recover, rather than escaping processEvent.
+        db.exec("BEGIN IMMEDIATE");
+        handle(hookType, data, sessionId, harness, now);
+        if (transcript) {
+          applyTranscript(sessionId, transcript, now);
+        }
+        db.exec("COMMIT");
+      } catch (error) {
+        try {
+          db.exec("ROLLBACK");
+        } catch {
+          /* ignore rollback failure */
+        }
+        log(`lifecycle: failed to process ${hookType}: ${error instanceof Error ? error.message : String(error)}`);
+        return false;
+      }
+      try {
+        deps.emit?.(sessionId);
+      } catch {
+        /* live-update push is best-effort */
+      }
+      return true;
+    },
+  };
+}
+
+function strOf(value: unknown): string | undefined {
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
+function safe<T>(fn: () => T): T | undefined {
+  try {
+    return fn();
+  } catch {
+    return undefined;
+  }
+}
diff --git a/apps/desktop/src/main/database/schema.ts b/apps/desktop/src/main/database/schema.ts
new file mode 100644
index 00000000..a852bc2a
--- /dev/null
+++ b/apps/desktop/src/main/database/schema.ts
@@ -0,0 +1,125 @@
+export const CURRENT_SCHEMA_VERSION = 5;
+
+/**
+ * Each migration runs against the DB when user_version < CURRENT_SCHEMA_VERSION.
+ * Index 0 = migration from version 0 → 1 (initial schema), etc.
+ */
+export const MIGRATIONS: string[] = [
+  // Version 0 → 1: initial schema
+  `
+CREATE TABLE IF NOT EXISTS sessions (
+  id TEXT PRIMARY KEY,
+  name TEXT,
+  status TEXT NOT NULL DEFAULT 'running',
+  cwd TEXT,
+  model TEXT,
+  started_at TEXT,
+  updated_at TEXT,
+  ended_at TEXT,
+  awaiting_input_since TEXT,
+  metadata TEXT,
+  harness TEXT
+);
+
+CREATE TABLE IF NOT EXISTS agents (
+  id TEXT PRIMARY KEY,
+  session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+  name TEXT,
+  type TEXT,
+  subagent_type TEXT,
+  status TEXT NOT NULL DEFAULT 'running',
+  task TEXT,
+  current_tool TEXT,
+  started_at TEXT,
+  updated_at TEXT,
+  ended_at TEXT,
+  awaiting_input_since TEXT,
+  parent_agent_id TEXT,
+  metadata TEXT
+);
+
+CREATE INDEX IF NOT EXISTS idx_agents_session_id ON agents(session_id);
+
+CREATE TABLE IF NOT EXISTS events (
+  id TEXT PRIMARY KEY,
+  session_id TEXT NOT NULL,
+  agent_id TEXT,
+  event_type TEXT NOT NULL,
+  tool_name TEXT,
+  summary TEXT,
+  data TEXT,
+  created_at TEXT
+);
+
+CREATE INDEX IF NOT EXISTS idx_events_session_id ON events(session_id);
+CREATE INDEX IF NOT EXISTS idx_events_agent_id ON events(agent_id);
+CREATE INDEX IF NOT EXISTS idx_events_created_at ON events(created_at);
+
+CREATE TABLE IF NOT EXISTS token_usage (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  session_id TEXT NOT NULL,
+  model TEXT NOT NULL,
+  input_tokens INTEGER NOT NULL DEFAULT 0,
+  output_tokens INTEGER NOT NULL DEFAULT 0,
+  cache_read_tokens INTEGER NOT NULL DEFAULT 0,
+  cache_write_tokens INTEGER NOT NULL DEFAULT 0,
+  created_at TEXT DEFAULT (datetime('now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_token_usage_session ON token_usage(session_id);
+`,
+
+  // Version 1 → 2: add indexes for analytics query performance
+  `
+CREATE INDEX IF NOT EXISTS idx_events_tool_name ON events(tool_name) WHERE tool_name IS NOT NULL;
+CREATE INDEX IF NOT EXISTS idx_events_session_tool ON events(session_id, created_at) WHERE tool_name IS NOT NULL;
+`,
+
+  // Version 2 → 3: covering indexes for aggregate queries on large tables
+  `
+CREATE INDEX IF NOT EXISTS idx_events_type ON events(event_type);
+CREATE INDEX IF NOT EXISTS idx_events_tool_created ON events(created_at, tool_name) WHERE tool_name IS NOT NULL;
+CREATE INDEX IF NOT EXISTS idx_agents_status ON agents(status);
+CREATE INDEX IF NOT EXISTS idx_agents_type ON agents(type);
+CREATE INDEX IF NOT EXISTS idx_agents_parent ON agents(parent_agent_id) WHERE parent_agent_id IS NOT NULL;
+`,
+
+  // Version 3 → 4 (FEA-1497 Phase 1): make token_usage the in-process write target.
+  // Reshape token_usage to a (session_id, model) upsert target carrying the
+  // *effective* reconciled totals in the standard columns plus internal
+  // write-time raw_* accumulators (last transcript-segment cumulative) used only
+  // to detect compaction-driven token resets. Readers (dashboard + cloud relay)
+  // read the standard columns directly with NO baseline arithmetic. The table was
+  // never INSERTed prior to v4 and this branch is unreleased, so the reshape is a
+  // safe drop+recreate. Also add sessions.billing_mode (stamped at ingest from the
+  // shared billing-mode detector) so the relay can read it from the in-process DB.
+  `
+DROP TABLE IF EXISTS token_usage;
+
+CREATE TABLE IF NOT EXISTS token_usage (
+  session_id TEXT NOT NULL,
+  model TEXT NOT NULL,
+  input_tokens INTEGER NOT NULL DEFAULT 0,
+  output_tokens INTEGER NOT NULL DEFAULT 0,
+  cache_read_tokens INTEGER NOT NULL DEFAULT 0,
+  cache_write_tokens INTEGER NOT NULL DEFAULT 0,
+  raw_input INTEGER NOT NULL DEFAULT 0,
+  raw_output INTEGER NOT NULL DEFAULT 0,
+  raw_cache_read INTEGER NOT NULL DEFAULT 0,
+  raw_cache_write INTEGER NOT NULL DEFAULT 0,
+  created_at TEXT DEFAULT (datetime('now')),
+  updated_at TEXT,
+  PRIMARY KEY (session_id, model)
+);
+
+CREATE INDEX IF NOT EXISTS idx_token_usage_session ON token_usage(session_id);
+
+ALTER TABLE sessions ADD COLUMN billing_mode TEXT;
+`,
+
+  // Version 4 -> 5: index session ordering/filtering for the heavy explorer views.
+  `
+CREATE INDEX IF NOT EXISTS idx_sessions_started_at ON sessions(started_at DESC);
+CREATE INDEX IF NOT EXISTS idx_sessions_status_started_at ON sessions(status, started_at DESC);
+`,
+];
diff --git a/apps/desktop/src/main/database/sessions.ts b/apps/desktop/src/main/database/sessions.ts
new file mode 100644
index 00000000..e856d387
--- /dev/null
+++ b/apps/desktop/src/main/database/sessions.ts
@@ -0,0 +1,147 @@
+import type { DatabaseSync } from "node:sqlite";
+import type { SessionRow, SessionWithAgents } from "../../shared/agent-db-contract.js";
+
+// Terminal session statuses (vendor + canonical AgentSession vocabulary). A
+// session not in this set is treated as active. Writes are owned by
+// `lifecycle.ts`; this store is read-only.
+const TERMINAL_STATUSES = "('completed', 'abandoned', 'error')";
+const TERMINAL_STATUS_SET = new Set(["completed", "abandoned", "error"]);
+const SESSION_DETAILS_CTES = `
+  WITH agent_counts AS (
+    SELECT session_id, COUNT(*) as agent_count
+    FROM agents
+    GROUP BY session_id
+  ),
+  event_counts AS (
+    SELECT session_id, COUNT(*) as event_count
+    FROM events
+    GROUP BY session_id
+  ),
+  token_totals AS (
+    SELECT
+      session_id,
+      COALESCE(SUM(COALESCE(input_tokens, 0) + COALESCE(output_tokens, 0)), 0) as total_tokens
+    FROM token_usage
+    GROUP BY session_id
+  )
+`;
+
+export function createSessionStore(db: DatabaseSync) {
+  const getByIdStmt = db.prepare("SELECT * FROM sessions WHERE id = ?");
+  const getAllStmt = db.prepare("SELECT * FROM sessions ORDER BY started_at DESC");
+  const getActiveStmt = db.prepare(
+    `SELECT * FROM sessions WHERE status NOT IN ${TERMINAL_STATUSES} ORDER BY started_at DESC`,
+  );
+
+  const getActiveWithDetailsStmt = db.prepare(`
+    ${SESSION_DETAILS_CTES}
+    SELECT
+      s.*,
+      COALESCE(ac.agent_count, 0) as agent_count,
+      COALESCE(ec.event_count, 0) as event_count,
+      COALESCE(tt.total_tokens, 0) as total_tokens
+    FROM sessions s
+    LEFT JOIN agent_counts ac ON ac.session_id = s.id
+    LEFT JOIN event_counts ec ON ec.session_id = s.id
+    LEFT JOIN token_totals tt ON tt.session_id = s.id
+    WHERE s.status NOT IN ${TERMINAL_STATUSES}
+    ORDER BY s.started_at DESC
+  `);
+  const getHistoricalWithDetailsStmt = db.prepare(`
+    ${SESSION_DETAILS_CTES}
+    SELECT
+      s.*,
+      COALESCE(ac.agent_count, 0) as agent_count,
+      COALESCE(ec.event_count, 0) as event_count,
+      COALESCE(tt.total_tokens, 0) as total_tokens
+    FROM sessions s
+    LEFT JOIN agent_counts ac ON ac.session_id = s.id
+    LEFT JOIN event_counts ec ON ec.session_id = s.id
+    LEFT JOIN token_totals tt ON tt.session_id = s.id
+    WHERE s.status IN ${TERMINAL_STATUSES}
+    ORDER BY s.started_at DESC
+  `);
+  let historicalDetailsCache: SessionWithAgents[] | null = null;
+
+  function toRow(raw: Record<string, unknown> | undefined): SessionRow | undefined {
+    if (!raw) return undefined;
+    return {
+      id: raw.id as string,
+      name: (raw.name as string) ?? null,
+      status: raw.status as string,
+      cwd: (raw.cwd as string) ?? null,
+      model: (raw.model as string) ?? null,
+      startedAt: (raw.started_at as string) ?? null,
+      updatedAt: (raw.updated_at as string) ?? null,
+      endedAt: (raw.ended_at as string) ?? null,
+      awaitingInputSince: (raw.awaiting_input_since as string) ?? null,
+      metadata: (raw.metadata as string) ?? null,
+      harness: (raw.harness as string) ?? null,
+      billingMode: (raw.billing_mode as string) ?? null,
+    };
+  }
+
+  function rowsToList(raws: Record<string, unknown>[]): SessionRow[] {
+    return raws.map(toRow).filter(Boolean) as SessionRow[];
+  }
+
+  function detailRowsToList(raws: Record<string, unknown>[]): SessionWithAgents[] {
+    return raws.map((raw) => {
+      const base = toRow(raw)!;
+      return {
+        ...base,
+        agentCount: raw.agent_count as number,
+        eventCount: raw.event_count as number,
+        totalTokens: raw.total_tokens as number,
+      };
+    });
+  }
+
+  return {
+    getById(id: string): SessionRow | undefined {
+      return toRow(getByIdStmt.get(id) as Record<string, unknown> | undefined);
+    },
+
+    getAll(): SessionRow[] {
+      return rowsToList(getAllStmt.all() as Record<string, unknown>[]);
+    },
+
+    getActive(): SessionRow[] {
+      return rowsToList(getActiveStmt.all() as Record<string, unknown>[]);
+    },
+
+    getActiveWithDetails(): SessionWithAgents[] {
+      return detailRowsToList(
+        getActiveWithDetailsStmt.all() as Record<string, unknown>[],
+      );
+    },
+
+    getHistoricalWithDetails(): SessionWithAgents[] {
+      if (historicalDetailsCache) {
+        return historicalDetailsCache;
+      }
+      historicalDetailsCache = detailRowsToList(
+        getHistoricalWithDetailsStmt.all() as Record<string, unknown>[],
+      );
+      return historicalDetailsCache;
+    },
+
+    getAllWithDetails(): SessionWithAgents[] {
+      return [
+        ...this.getActiveWithDetails(),
+        ...this.getHistoricalWithDetails(),
+      ];
+    },
+
+    invalidateHistoricalDetails(): void {
+      historicalDetailsCache = null;
+    },
+
+    handleSessionMutation(sessionId: string): void {
+      const session = this.getById(sessionId);
+      if (!session || TERMINAL_STATUS_SET.has(session.status)) {
+        historicalDetailsCache = null;
+      }
+    },
+  };
+}
diff --git a/apps/desktop/src/main/database/token-usage.ts b/apps/desktop/src/main/database/token-usage.ts
new file mode 100644
index 00000000..9c875f08
--- /dev/null
+++ b/apps/desktop/src/main/database/token-usage.ts
@@ -0,0 +1,106 @@
+import type { DatabaseSync } from "node:sqlite";
+import type { TokenUsageRow } from "./types.js";
+
+/** Cumulative per-model token counts from the current transcript segment. */
+export interface TokenUsageCounts {
+  input: number;
+  output: number;
+  cacheRead: number;
+  cacheWrite: number;
+}
+
+/**
+ * Token-usage repository for the in-process DB (FEA-1497 Phase 1).
+ *
+ * The standard columns (`input_tokens` etc.) hold the **effective reconciled
+ * total** per (session, model) and are what every reader (dashboard analytics,
+ * the cloud relay, cost reconciliation) reads directly — with NO baseline
+ * arithmetic. The internal `raw_*` columns hold the last transcript-segment
+ * cumulative and exist ONLY to reconcile compaction: when a transcript is
+ * compaction-rewritten the cumulative counts drop, and we must add the new
+ * segment on top of the prior effective total rather than overwrite it.
+ *
+ * For a new cumulative R vs the previously-seen raw cumulative `raw`:
+ *   - R >= raw  → same segment grew; add the delta (R - raw).
+ *   - R <  raw  → transcript was compacted/rewritten; the prior segment is
+ *                 already fully counted, so add the whole new segment (R).
+ * Equivalent to the vendor's `baseline_*` scheme, but the effective total lives
+ * in the columns readers consume so they need no `+ baseline_*` math.
+ */
+export function createTokenUsageStore(db: DatabaseSync) {
+  const replaceStmt = db.prepare(`
+    INSERT INTO token_usage (
+      session_id, model,
+      input_tokens, output_tokens, cache_read_tokens, cache_write_tokens,
+      raw_input, raw_output, raw_cache_read, raw_cache_write,
+      created_at, updated_at
+    )
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT(session_id, model) DO UPDATE SET
+      input_tokens = input_tokens + (CASE WHEN excluded.raw_input < raw_input
+        THEN excluded.raw_input ELSE excluded.raw_input - raw_input END),
+      output_tokens = output_tokens + (CASE WHEN excluded.raw_output < raw_output
+        THEN excluded.raw_output ELSE excluded.raw_output - raw_output END),
+      cache_read_tokens = cache_read_tokens + (CASE WHEN excluded.raw_cache_read < raw_cache_read
+        THEN excluded.raw_cache_read ELSE excluded.raw_cache_read - raw_cache_read END),
+      cache_write_tokens = cache_write_tokens + (CASE WHEN excluded.raw_cache_write < raw_cache_write
+        THEN excluded.raw_cache_write ELSE excluded.raw_cache_write - raw_cache_write END),
+      raw_input = excluded.raw_input,
+      raw_output = excluded.raw_output,
+      raw_cache_read = excluded.raw_cache_read,
+      raw_cache_write = excluded.raw_cache_write,
+      updated_at = excluded.updated_at
+  `);
+
+  const getBySessionStmt = db.prepare(`
+    SELECT session_id, model, input_tokens, output_tokens, cache_read_tokens, cache_write_tokens
+    FROM token_usage WHERE session_id = ? ORDER BY model ASC
+  `);
+
+  function toRow(raw: Record<string, unknown>): TokenUsageRow {
+    return {
+      sessionId: raw.session_id as string,
+      model: raw.model as string,
+      inputTokens: (raw.input_tokens as number) ?? 0,
+      outputTokens: (raw.output_tokens as number) ?? 0,
+      cacheReadTokens: (raw.cache_read_tokens as number) ?? 0,
+      cacheWriteTokens: (raw.cache_write_tokens as number) ?? 0,
+    };
+  }
+
+  return {
+    /**
+     * Record the current cumulative per-model counts, reconciling against any
+     * prior segment. Skips no-op all-zero rows so an idle transcript never
+     * creates an empty (session, model) entry.
+     */
+    replace(sessionId: string, model: string, counts: TokenUsageCounts, now: string): void {
+      if (
+        counts.input === 0 &&
+        counts.output === 0 &&
+        counts.cacheRead === 0 &&
+        counts.cacheWrite === 0
+      ) {
+        return;
+      }
+      replaceStmt.run(
+        sessionId,
+        model,
+        counts.input,
+        counts.output,
+        counts.cacheRead,
+        counts.cacheWrite,
+        counts.input,
+        counts.output,
+        counts.cacheRead,
+        counts.cacheWrite,
+        now,
+        now,
+      );
+    },
+
+    getBySession(sessionId: string): TokenUsageRow[] {
+      return (getBySessionStmt.all(sessionId) as Record<string, unknown>[]).map(toRow);
+    },
+  };
+}
diff --git a/apps/desktop/src/main/database/transcript.ts b/apps/desktop/src/main/database/transcript.ts
new file mode 100644
index 00000000..5d116c11
--- /dev/null
+++ b/apps/desktop/src/main/database/transcript.ts
@@ -0,0 +1,109 @@
+import { readFileSync } from "node:fs";
+
+/**
+ * Per-model token totals extracted from a single Claude/Codex hook transcript
+ * file. Values are the CUMULATIVE sum across every usage-bearing line in the
+ * file as it exists right now — when a transcript is compaction-rewritten the
+ * file shrinks and these totals drop, which the token-usage store reconciles
+ * via its `raw_*` accumulators.
+ *
+ * This parses the absolute `transcript_path` supplied on a hook payload. It is
+ * intentionally separate from `src/main/token-usage.ts` `parseTokenUsage`,
+ * which resolves a symphony-loop run output directory (`claude-output*.jsonl`)
+ * rather than an arbitrary hook transcript path.
+ */
+export interface TranscriptTokenCounts {
+  input: number;
+  output: number;
+  cacheRead: number;
+  cacheWrite: number;
+}
+
+export interface TranscriptExtract {
+  /** model id -> summed token counts across the transcript. */
+  tokensByModel: Map<string, TranscriptTokenCounts>;
+  /** Most recent non-synthetic model id seen, for session model sync. */
+  latestModel: string | null;
+  /** Count of compaction-summary lines seen (drives compaction analytics later). */
+  compactionCount: number;
+}
+
+interface UsageRecord {
+  input_tokens?: number;
+  output_tokens?: number;
+  cache_read_input_tokens?: number;
+  cache_creation_input_tokens?: number;
+}
+
+function asUsage(value: unknown): UsageRecord | null {
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+  return value as UsageRecord;
+}
+
+/**
+ * Read and parse a transcript JSONL file, accumulating per-model token usage.
+ * Returns `null` when the file is missing/unreadable so callers can no-op.
+ * Malformed lines are skipped. A model id of `<synthetic>` (Claude's
+ * placeholder for non-API turns) is ignored.
+ */
+export function extractTranscriptTokens(
+  transcriptPath: string,
+): TranscriptExtract | null {
+  let content: string;
+  try {
+    content = readFileSync(transcriptPath, "utf-8");
+  } catch {
+    return null;
+  }
+
+  const tokensByModel = new Map<string, TranscriptTokenCounts>();
+  let latestModel: string | null = null;
+  let compactionCount = 0;
+
+  for (const line of content.split("\n")) {
+    if (!line.trim()) {
+      continue;
+    }
+    let entry: Record<string, unknown>;
+    try {
+      entry = JSON.parse(line) as Record<string, unknown>;
+    } catch {
+      continue;
+    }
+
+    if (entry.isCompactSummary === true) {
+      compactionCount += 1;
+    }
+
+    // The usage block lives on `message` for assistant turns; some shapes carry
+    // it on the entry directly. Mirror the vendor extractor's `message || entry`.
+    const message = (entry.message as Record<string, unknown> | undefined) ?? entry;
+    const model =
+      typeof message.model === "string" && message.model.length > 0
+        ? message.model
+        : undefined;
+    const usage = asUsage(message.usage);
+    if (!model || model === "<synthetic>" || !usage) {
+      continue;
+    }
+
+    latestModel = model;
+    const existing = tokensByModel.get(model);
+    const input = usage.input_tokens ?? 0;
+    const output = usage.output_tokens ?? 0;
+    const cacheRead = usage.cache_read_input_tokens ?? 0;
+    const cacheWrite = usage.cache_creation_input_tokens ?? 0;
+    if (existing) {
+      existing.input += input;
+      existing.output += output;
+      existing.cacheRead += cacheRead;
+      existing.cacheWrite += cacheWrite;
+    } else {
+      tokensByModel.set(model, { input, output, cacheRead, cacheWrite });
+    }
+  }
+
+  return { tokensByModel, latestModel, compactionCount };
+}
diff --git a/apps/desktop/src/main/database/types.ts b/apps/desktop/src/main/database/types.ts
new file mode 100644
index 00000000..d13b9f65
--- /dev/null
+++ b/apps/desktop/src/main/database/types.ts
@@ -0,0 +1,18 @@
+// Private persistence-row types for the in-process agent database.
+//
+// Renderer-facing IPC response DTOs (DashboardSummary, AnalyticsData, the
+// session/agent/event response shapes, etc.) live in
+// `src/shared/agent-db-contract.ts` so the renderer's compile-time contract is
+// decoupled from this private persistence layer. Each repository store maps raw
+// `node:sqlite` rows into those shared DTOs via its `toRow()` helper. Only row
+// types that never cross the IPC boundary belong here.
+
+/** Effective reconciled per-(session, model) token counts. Internal: never crosses IPC. */
+export interface TokenUsageRow {
+  sessionId: string;
+  model: string;
+  inputTokens: number;
+  outputTokens: number;
+  cacheReadTokens: number;
+  cacheWriteTokens: number;
+}
diff --git a/apps/desktop/src/main/index.ts b/apps/desktop/src/main/index.ts
index a23e5dbe..1c8a8818 100644
--- a/apps/desktop/src/main/index.ts
+++ b/apps/desktop/src/main/index.ts
@@ -1,9 +1,11 @@
-import { app, nativeTheme } from "electron";
+import { app, nativeTheme, protocol } from "electron";
+import { resolveAgentDashboardMode } from "./agent-dashboard-mode.js";
 import { DesktopApplication } from "./app.js";
 import { handleActivateEvent } from "./app-lifecycle.js";
 import { handleUncaughtException, handleUnhandledRejection } from "./error-handlers.js";
 import { gatewayLog } from "./gateway-logger.js";
 import { initializePersistentLogging } from "./persistent-log.js";
+import { SettingsStore } from "./settings-store.js";
 import { createBeforeQuitHandler } from "./shutdown-lifecycle.js";
 
 app.setName("ClosedLoop");
@@ -27,6 +29,15 @@ process.on("unhandledRejection", (reason) =>
   })
 );
 
+if (shouldRegisterDesignSystemScheme()) {
+  protocol.registerSchemesAsPrivileged([
+    {
+      scheme: "app",
+      privileges: { standard: true, secure: true, supportFetchAPI: true },
+    },
+  ]);
+}
+
 const desktopApplication = new DesktopApplication();
 
 app.on("ready", () => {
@@ -60,3 +71,16 @@ app.on("window-all-closed", () => {
     app.quit();
   }
 });
+
+function shouldRegisterDesignSystemScheme(): boolean {
+  try {
+    return resolveAgentDashboardMode(new SettingsStore()) === "design-system";
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    gatewayLog.warn(
+      "agent-dashboard",
+      `skipping app:// scheme registration after settings read failed: ${message}`,
+    );
+    return false;
+  }
+}
diff --git a/apps/desktop/src/main/preload-common.ts b/apps/desktop/src/main/preload-common.ts
new file mode 100644
index 00000000..09f27d6f
--- /dev/null
+++ b/apps/desktop/src/main/preload-common.ts
@@ -0,0 +1,259 @@
+import { contextBridge, ipcRenderer } from "electron";
+import type { ManagedKeyHintState } from "../shared/contracts.js";
+
+/**
+ * Optional preload-only desktopApi additions for renderer modes with extra IPC
+ * surfaces. Legacy and disabled modes pass no extensions, so the design-system
+ * database bridge is not exposed unless the design-system preload is selected.
+ */
+export type DesktopApiExtensions = Record<string, unknown>;
+
+const desktopApi = {
+  getSettings: () => ipcRenderer.invoke("desktop:get-settings") as Promise<unknown>,
+  updateSettings: (partial: unknown) =>
+    ipcRenderer.invoke("desktop:update-settings", partial) as Promise<unknown>,
+  getRuntimeStatus: () => ipcRenderer.invoke("desktop:get-runtime-status") as Promise<unknown>,
+  listCommandSigningKeys: () =>
+    ipcRenderer.invoke("desktop:list-command-signing-keys") as Promise<unknown>,
+  listAuthorizedKeys: () =>
+    ipcRenderer.invoke("desktop:list-authorized-keys") as Promise<unknown>,
+  authorizeKey: (payload: unknown) =>
+    ipcRenderer.invoke("desktop:authorize-key", payload) as Promise<unknown>,
+  removeAuthorizedKey: (fingerprint: string) =>
+    ipcRenderer.invoke("desktop:remove-authorized-key", fingerprint) as Promise<unknown>,
+  listOrgPublicKeys: () =>
+    ipcRenderer.invoke("desktop:list-org-public-keys") as Promise<unknown>,
+  approveOrgPublicKey: (fingerprint: string) =>
+    ipcRenderer.invoke("desktop:approve-org-public-key", fingerprint) as Promise<unknown>,
+  rejectOrgPublicKey: (fingerprint: string) =>
+    ipcRenderer.invoke("desktop:reject-org-public-key", fingerprint) as Promise<unknown>,
+  authorizeCommandSigningKey: (fingerprint: string) =>
+    ipcRenderer.invoke("desktop:authorize-command-signing-key", fingerprint) as Promise<unknown>,
+  revokeCommandSigningKey: (fingerprint: string) =>
+    ipcRenderer.invoke("desktop:revoke-command-signing-key", fingerprint) as Promise<unknown>,
+  getActivityEvents: () => ipcRenderer.invoke("desktop:get-activity-events") as Promise<unknown>,
+  clearActivityEvents: () =>
+    ipcRenderer.invoke("desktop:clear-activity-events") as Promise<unknown>,
+  getPendingApprovals: () =>
+    ipcRenderer.invoke("desktop:get-pending-approvals") as Promise<unknown>,
+  approveApproval: (approvalId: string) =>
+    ipcRenderer.invoke("desktop:approve-approval", approvalId) as Promise<unknown>,
+  denyApproval: (approvalId: string) =>
+    ipcRenderer.invoke("desktop:deny-approval", approvalId) as Promise<unknown>,
+  alwaysAllowApproval: (approvalId: string) =>
+    ipcRenderer.invoke("desktop:always-allow-approval", approvalId) as Promise<unknown>,
+  clearPendingApprovals: () =>
+    ipcRenderer.invoke("desktop:clear-pending-approvals") as Promise<unknown>,
+  getResolvedApprovals: () =>
+    ipcRenderer.invoke("desktop:get-resolved-approvals") as Promise<unknown>,
+  clearResolvedApprovals: () =>
+    ipcRenderer.invoke("desktop:clear-resolved-approvals") as Promise<unknown>,
+  getApiKeyStatus: () => ipcRenderer.invoke("desktop:get-api-key-status") as Promise<unknown>,
+  setApiKey: (apiKey: string) =>
+    ipcRenderer.invoke("desktop:set-api-key", apiKey) as Promise<unknown>,
+  clearApiKey: () => ipcRenderer.invoke("desktop:clear-api-key") as Promise<unknown>,
+  // FEA-1435/1436: vendor Admin key intake + cost reconciliation. The bridge only
+  // ever moves existence-only statuses, persisted drift rows, and key-free run
+  // summaries — never the Admin key material itself (main-process only).
+  getAdminKeyStatuses: () =>
+    ipcRenderer.invoke("desktop:get-admin-key-statuses") as Promise<unknown>,
+  setAdminKey: (vendor: string, key: string) =>
+    ipcRenderer.invoke("desktop:set-admin-key", { vendor, key }) as Promise<unknown>,
+  clearAdminKey: (vendor: string) =>
+    ipcRenderer.invoke("desktop:clear-admin-key", vendor) as Promise<unknown>,
+  runCostReconciliation: () =>
+    ipcRenderer.invoke("desktop:run-cost-reconciliation") as Promise<unknown>,
+  listCostReconciliation: (query?: unknown) =>
+    ipcRenderer.invoke("desktop:list-cost-reconciliation", query) as Promise<unknown>,
+  // FEA-1436: Claude Code per-user usage (Anthropic's own estimate). Returns
+  // per-actor usage rows only — never any Admin key material.
+  getClaudeCodeAnalytics: (query?: unknown) =>
+    ipcRenderer.invoke("desktop:get-claude-code-analytics", query) as Promise<unknown>,
+  getCloudCommandsPaused: () =>
+    ipcRenderer.invoke("desktop:get-cloud-commands-paused") as Promise<unknown>,
+  setCloudCommandsPaused: (paused: boolean) =>
+    ipcRenderer.invoke("desktop:set-cloud-commands-paused", paused) as Promise<unknown>,
+  getCloudConnectionEnabled: () =>
+    ipcRenderer.invoke("desktop:get-cloud-connection-enabled") as Promise<unknown>,
+  setCloudConnectionEnabled: (enabled: boolean) =>
+    ipcRenderer.invoke("desktop:set-cloud-connection-enabled", enabled) as Promise<unknown>,
+  getOnboardingState: () => ipcRenderer.invoke("desktop:get-onboarding-state") as Promise<unknown>,
+  completeOnboarding: (payload: unknown) =>
+    ipcRenderer.invoke("desktop:complete-onboarding", payload) as Promise<unknown>,
+  // FEA-1333: mark the one-time Agent Dashboard welcome as seen.
+  markDashboardWelcomeSeen: () =>
+    ipcRenderer.invoke("desktop:mark-dashboard-welcome-seen") as Promise<{
+      ok: boolean;
+    }>,
+  startDeviceOnboarding: (payload: unknown) =>
+    ipcRenderer.invoke("desktop:start-device-onboarding", payload) as Promise<unknown>,
+  dismissOnboardingPopup: (payload: { permanent: boolean }) =>
+    ipcRenderer.invoke("desktop:dismiss-onboarding-popup", payload) as Promise<unknown>,
+  onboardingPopupCta: () =>
+    ipcRenderer.invoke("desktop:onboarding-popup-cta") as Promise<unknown>,
+  pickSandboxDirectory: () =>
+    ipcRenderer.invoke("desktop:pick-sandbox-directory") as Promise<{
+      path: string;
+      isGitRepo: boolean;
+      suggestedPath: string | undefined;
+    } | null>,
+  inspectSandboxPath: (path: string) =>
+    ipcRenderer.invoke("desktop:inspect-sandbox-path", path) as Promise<{
+      path: string;
+      isGitRepo: boolean;
+      suggestedPath: string | undefined;
+    } | null>,
+  getDangerousAutoApprove: () =>
+    ipcRenderer.invoke("desktop:get-dangerous-auto-approve") as Promise<boolean>,
+  setDangerousAutoApprove: (enabled: boolean) =>
+    ipcRenderer.invoke("desktop:set-dangerous-auto-approve", enabled) as Promise<boolean>,
+  removeAlwaysAllowRule: (ruleId: string) =>
+    ipcRenderer.invoke("desktop:remove-always-allow-rule", ruleId) as Promise<unknown>,
+  checkForUpdate: () => ipcRenderer.invoke("desktop:check-for-update") as Promise<unknown>,
+  applyUpdate: () => ipcRenderer.invoke("desktop:apply-update") as Promise<unknown>,
+  isDebugAuthEnabled: () => ipcRenderer.invoke("desktop:is-debug-auth-enabled") as Promise<boolean>,
+  mintDebugToken: (origin?: string) =>
+    ipcRenderer.invoke("desktop:mint-debug-token", origin) as Promise<unknown>,
+  listRunningJobs: () => ipcRenderer.invoke("desktop:list-running-jobs") as Promise<unknown>,
+  listCompletedJobs: () => ipcRenderer.invoke("desktop:list-completed-jobs") as Promise<unknown>,
+  getJob: (jobId: string) => ipcRenderer.invoke("desktop:get-job", jobId) as Promise<unknown>,
+  getJobLogTail: (jobId: string, lines?: number) =>
+    ipcRenderer.invoke("desktop:get-job-log-tail", jobId, lines) as Promise<unknown>,
+  getLogs: () => ipcRenderer.invoke("desktop:get-logs") as Promise<unknown>,
+  clearLogs: () => ipcRenderer.invoke("desktop:clear-logs") as Promise<unknown>,
+  getLogFilePath: () =>
+    ipcRenderer.invoke("desktop:get-log-file-path") as Promise<string>,
+  openLogFile: () => ipcRenderer.invoke("desktop:open-log-file") as Promise<unknown>,
+  getAppVersion: () => ipcRenderer.invoke("desktop:get-app-version") as Promise<string>,
+  getBinaryPaths: () => ipcRenderer.invoke("desktop:get-binary-paths") as Promise<unknown>,
+  patchBinaryPaths: (patch: unknown) =>
+    ipcRenderer.invoke("desktop:patch-binary-paths", patch) as Promise<unknown>,
+  detectCliTools: () =>
+    ipcRenderer.invoke("desktop:detect-cli-tools") as Promise<unknown>,
+  saveConfig: (name: string) =>
+    ipcRenderer.invoke("desktop:save-config", { name }) as Promise<unknown>,
+  findMatchingConfig: () =>
+    ipcRenderer.invoke("desktop:find-matching-config") as Promise<unknown>,
+  listConfigs: () =>
+    ipcRenderer.invoke("desktop:list-configs") as Promise<unknown>,
+  deleteConfig: (id: string) =>
+    ipcRenderer.invoke("desktop:delete-config", { id }) as Promise<unknown>,
+  renameConfig: (id: string, name: string) =>
+    ipcRenderer.invoke("desktop:rename-config", { id, name }) as Promise<unknown>,
+  applyConfig: (id: string) =>
+    ipcRenderer.invoke("desktop:apply-config", { id }) as Promise<unknown>,
+  getAgentMonitorUrl: () =>
+    ipcRenderer.invoke("desktop:get-agent-monitor-url") as Promise<{
+      url: string | null;
+      ready: boolean;
+      enabled: boolean;
+      planExtractionEnabled: boolean;
+    }>,
+  openAgentMonitor: () =>
+    ipcRenderer.invoke("desktop:open-agent-monitor") as Promise<unknown>,
+  getAgentMonitorHooksEnabled: () =>
+    ipcRenderer.invoke(
+      "desktop:get-agent-monitor-hooks-enabled",
+    ) as Promise<boolean>,
+  setAgentMonitorHooksEnabled: (enabled: boolean) =>
+    ipcRenderer.invoke(
+      "desktop:set-agent-monitor-hooks-enabled",
+      enabled,
+    ) as Promise<{ ok: boolean; enabled: boolean; error?: string }>,
+  getAgentMonitorCodexHooksOptIn: () =>
+    ipcRenderer.invoke(
+      "desktop:get-agent-monitor-codex-hooks-opt-in",
+    ) as Promise<boolean>,
+  setAgentMonitorCodexHooksOptIn: (optIn: boolean) =>
+    ipcRenderer.invoke(
+      "desktop:set-agent-monitor-codex-hooks-opt-in",
+      optIn,
+    ) as Promise<{ ok: boolean; enabled: boolean; error?: string }>,
+  getAllFlags: () =>
+    ipcRenderer.invoke("desktop:get-all-flags") as Promise<unknown>,
+  onFlagsChanged: (callback: () => void) => {
+    ipcRenderer.on("desktop:flags-changed", callback);
+  },
+  // FEA-1334: cold-start ingest progress for the floating progress card.
+  // Resolves null when the sidecar is unreachable or has no progress yet.
+  getAgentMonitorIngestProgress: () =>
+    ipcRenderer.invoke(
+      "desktop:get-agent-monitor-ingest-progress",
+    ) as Promise<{
+      running: boolean;
+      startedAt: number | null;
+      updatedAt: number | null;
+      finishedAt: number | null;
+      total: number;
+      parsed: number;
+      imported: number;
+      byHarness: Record<
+        string,
+        { total: number; parsed: number; imported: number; complete: boolean }
+      >;
+    } | null>,
+  // FEA-1334: clear the dashboard DB and restart the sidecar so it re-imports
+  // every agent session from scratch. The progress banner tracks the re-import.
+  reprocessAgentLogs: () =>
+    ipcRenderer.invoke("desktop:reprocess-agent-logs") as Promise<{
+      ok: boolean;
+      error?: string;
+    }>,
+  /**
+   * Returns the current state of the managed-key revival limitation hint (D5).
+   * The main process reads provenance from apiKeyStore — renderer does not control
+   * what is returned.
+   */
+  getManagedKeyHintState: () =>
+    ipcRenderer.invoke("desktop:get-managed-key-hint-state") as Promise<ManagedKeyHintState>,
+  /**
+   * Dismisses the managed-key revival limitation hint (D5).
+   * The main process records the current provenance from apiKeyStore.
+   * The renderer does not supply any arguments — provenance is main-process-only.
+   */
+  dismissManagedKeyHint: () =>
+    ipcRenderer.invoke("desktop:dismiss-managed-key-hint") as Promise<{ success: boolean }>,
+};
+
+/**
+ * Expose the shared Electron desktop API to the renderer through Electron's
+ * contextBridge. Optional extensions are supplied only by trusted preload
+ * entrypoints selected by the main process; legacy and disabled modes pass no
+ * extensions, while design-system mode adds its gated DB bridge.
+ */
+export function exposeDesktopApi(
+  extensions: DesktopApiExtensions = {},
+): void {
+  contextBridge.exposeInMainWorld("desktopApi", {
+    ...desktopApi,
+    ...extensions,
+  });
+}
+
+ipcRenderer.on("desktop:navigate-tab", (_event, tab: string) => {
+  window.dispatchEvent(new CustomEvent("desktop:navigate-tab", { detail: tab }));
+});
+
+ipcRenderer.on("desktop:navigate-settings-tab", (_event, tab: string) => {
+  window.dispatchEvent(new CustomEvent("desktop:navigate-settings-tab", { detail: tab }));
+});
+
+ipcRenderer.on("desktop:command-keys-changed", () => {
+  window.dispatchEvent(new CustomEvent("desktop:command-keys-changed"));
+});
+
+ipcRenderer.on("desktop:update-available", (_event, result) => {
+  window.dispatchEvent(new CustomEvent("desktop:update-available", { detail: result }));
+});
+
+ipcRenderer.on("desktop:update-status", (_event, result) => {
+  window.dispatchEvent(new CustomEvent("desktop:update-status", { detail: result }));
+});
+
+ipcRenderer.on("desktop:onboarding-state-changed", () => {
+  window.dispatchEvent(new CustomEvent("desktop:onboarding-state-changed"));
+});
+
+ipcRenderer.on("desktop:show-onboarding-popup", () => {
+  window.dispatchEvent(new CustomEvent("desktop:show-onboarding-popup"));
+});
diff --git a/apps/desktop/src/main/preload-design-system.ts b/apps/desktop/src/main/preload-design-system.ts
new file mode 100644
index 00000000..ba412fbc
--- /dev/null
+++ b/apps/desktop/src/main/preload-design-system.ts
@@ -0,0 +1,44 @@
+import { ipcRenderer } from "electron";
+import type {
+  AgentHierarchyNode,
+  AgentRow,
+  AnalyticsData,
+  DashboardSummary,
+  EventCountByType,
+  EventRow,
+  EventWithSession,
+  SessionRow,
+  SessionWithAgents,
+  TokenAnalytics,
+  WorkflowQueryData,
+} from "../shared/agent-db-contract.js";
+import { exposeDesktopApi } from "./preload-common.js";
+
+const designSystemDashboardApi = {
+  db: {
+    getSessions: () => ipcRenderer.invoke("desktop:db:get-sessions") as Promise<SessionRow[]>,
+    getSession: (id: string) => ipcRenderer.invoke("desktop:db:get-session", id) as Promise<SessionRow | undefined>,
+    getAgents: (sessionId: string) => ipcRenderer.invoke("desktop:db:get-agents", sessionId) as Promise<AgentRow[]>,
+    getEvents: (sessionId: string, agentId?: string) => ipcRenderer.invoke("desktop:db:get-events", sessionId, agentId) as Promise<EventRow[]>,
+    getDashboardSummary: () => ipcRenderer.invoke("desktop:db:get-dashboard-summary") as Promise<DashboardSummary>,
+    getSessionsWithDetails: () => ipcRenderer.invoke("desktop:db:get-sessions-with-details") as Promise<SessionWithAgents[]>,
+    getEventFeed: () => ipcRenderer.invoke("desktop:db:get-event-feed") as Promise<EventWithSession[]>,
+    getEventsWithSession: (sessionId: string) => ipcRenderer.invoke("desktop:db:get-events-with-session", sessionId) as Promise<EventWithSession[]>,
+    getEventCountByType: () => ipcRenderer.invoke("desktop:db:get-event-count-by-type") as Promise<EventCountByType[]>,
+    getTokenAnalytics: () => ipcRenderer.invoke("desktop:db:get-token-analytics") as Promise<TokenAnalytics>,
+    getAgentHierarchy: (sessionId: string) => ipcRenderer.invoke("desktop:db:get-agent-hierarchy", sessionId) as Promise<AgentHierarchyNode[]>,
+    getAnalytics: () => ipcRenderer.invoke("desktop:db:get-analytics") as Promise<AnalyticsData>,
+    getWorkflowData: () => ipcRenderer.invoke("desktop:db:get-workflow-data") as Promise<WorkflowQueryData>,
+  },
+  /**
+   * Subscribe to in-process DB-change pushes. The design renderer listens for
+   * these events to refresh DB-backed query state without polling.
+   */
+  onDbChanged: (callback: (payload: { sessionId?: string }) => void) => {
+    const handler = (_event: unknown, payload: { sessionId?: string }) => callback(payload);
+    ipcRenderer.on("desktop:db:changed", handler);
+    return () => ipcRenderer.removeListener("desktop:db:changed", handler);
+  },
+};
+
+exposeDesktopApi(designSystemDashboardApi);
diff --git a/apps/desktop/src/main/preload.ts b/apps/desktop/src/main/preload.ts
index a844d692..9c386ff0 100644
--- a/apps/desktop/src/main/preload.ts
+++ b/apps/desktop/src/main/preload.ts
@@ -1,230 +1,3 @@
-import type { ManagedKeyHintState } from "../shared/contracts.js";
-import { contextBridge, ipcRenderer } from "electron";
+import { exposeDesktopApi } from "./preload-common.js";
 
-const desktopApi = {
-  getSettings: () => ipcRenderer.invoke("desktop:get-settings") as Promise<unknown>,
-  updateSettings: (partial: unknown) =>
-    ipcRenderer.invoke("desktop:update-settings", partial) as Promise<unknown>,
-  getRuntimeStatus: () => ipcRenderer.invoke("desktop:get-runtime-status") as Promise<unknown>,
-  listCommandSigningKeys: () =>
-    ipcRenderer.invoke("desktop:list-command-signing-keys") as Promise<unknown>,
-  listAuthorizedKeys: () =>
-    ipcRenderer.invoke("desktop:list-authorized-keys") as Promise<unknown>,
-  authorizeKey: (payload: unknown) =>
-    ipcRenderer.invoke("desktop:authorize-key", payload) as Promise<unknown>,
-  removeAuthorizedKey: (fingerprint: string) =>
-    ipcRenderer.invoke("desktop:remove-authorized-key", fingerprint) as Promise<unknown>,
-  listOrgPublicKeys: () =>
-    ipcRenderer.invoke("desktop:list-org-public-keys") as Promise<unknown>,
-  approveOrgPublicKey: (fingerprint: string) =>
-    ipcRenderer.invoke("desktop:approve-org-public-key", fingerprint) as Promise<unknown>,
-  rejectOrgPublicKey: (fingerprint: string) =>
-    ipcRenderer.invoke("desktop:reject-org-public-key", fingerprint) as Promise<unknown>,
-  authorizeCommandSigningKey: (fingerprint: string) =>
-    ipcRenderer.invoke("desktop:authorize-command-signing-key", fingerprint) as Promise<unknown>,
-  revokeCommandSigningKey: (fingerprint: string) =>
-    ipcRenderer.invoke("desktop:revoke-command-signing-key", fingerprint) as Promise<unknown>,
-  getActivityEvents: () => ipcRenderer.invoke("desktop:get-activity-events") as Promise<unknown>,
-  clearActivityEvents: () =>
-    ipcRenderer.invoke("desktop:clear-activity-events") as Promise<unknown>,
-  getPendingApprovals: () =>
-    ipcRenderer.invoke("desktop:get-pending-approvals") as Promise<unknown>,
-  approveApproval: (approvalId: string) =>
-    ipcRenderer.invoke("desktop:approve-approval", approvalId) as Promise<unknown>,
-  denyApproval: (approvalId: string) =>
-    ipcRenderer.invoke("desktop:deny-approval", approvalId) as Promise<unknown>,
-  alwaysAllowApproval: (approvalId: string) =>
-    ipcRenderer.invoke("desktop:always-allow-approval", approvalId) as Promise<unknown>,
-  clearPendingApprovals: () =>
-    ipcRenderer.invoke("desktop:clear-pending-approvals") as Promise<unknown>,
-  getResolvedApprovals: () =>
-    ipcRenderer.invoke("desktop:get-resolved-approvals") as Promise<unknown>,
-  clearResolvedApprovals: () =>
-    ipcRenderer.invoke("desktop:clear-resolved-approvals") as Promise<unknown>,
-  getApiKeyStatus: () => ipcRenderer.invoke("desktop:get-api-key-status") as Promise<unknown>,
-  setApiKey: (apiKey: string) =>
-    ipcRenderer.invoke("desktop:set-api-key", apiKey) as Promise<unknown>,
-  clearApiKey: () => ipcRenderer.invoke("desktop:clear-api-key") as Promise<unknown>,
-  // FEA-1435/1436: vendor Admin key intake + cost reconciliation. The bridge only
-  // ever moves existence-only statuses, persisted drift rows, and key-free run
-  // summaries — never the Admin key material itself (main-process only).
-  getAdminKeyStatuses: () =>
-    ipcRenderer.invoke("desktop:get-admin-key-statuses") as Promise<unknown>,
-  setAdminKey: (vendor: string, key: string) =>
-    ipcRenderer.invoke("desktop:set-admin-key", { vendor, key }) as Promise<unknown>,
-  clearAdminKey: (vendor: string) =>
-    ipcRenderer.invoke("desktop:clear-admin-key", vendor) as Promise<unknown>,
-  runCostReconciliation: () =>
-    ipcRenderer.invoke("desktop:run-cost-reconciliation") as Promise<unknown>,
-  listCostReconciliation: (query?: unknown) =>
-    ipcRenderer.invoke("desktop:list-cost-reconciliation", query) as Promise<unknown>,
-  // FEA-1436: Claude Code per-user usage (Anthropic's own estimate). Returns
-  // per-actor usage rows only — never any Admin key material.
-  getClaudeCodeAnalytics: (query?: unknown) =>
-    ipcRenderer.invoke("desktop:get-claude-code-analytics", query) as Promise<unknown>,
-  getCloudCommandsPaused: () =>
-    ipcRenderer.invoke("desktop:get-cloud-commands-paused") as Promise<unknown>,
-  setCloudCommandsPaused: (paused: boolean) =>
-    ipcRenderer.invoke("desktop:set-cloud-commands-paused", paused) as Promise<unknown>,
-  getCloudConnectionEnabled: () =>
-    ipcRenderer.invoke("desktop:get-cloud-connection-enabled") as Promise<unknown>,
-  setCloudConnectionEnabled: (enabled: boolean) =>
-    ipcRenderer.invoke("desktop:set-cloud-connection-enabled", enabled) as Promise<unknown>,
-  getOnboardingState: () => ipcRenderer.invoke("desktop:get-onboarding-state") as Promise<unknown>,
-  completeOnboarding: (payload: unknown) =>
-    ipcRenderer.invoke("desktop:complete-onboarding", payload) as Promise<unknown>,
-  // FEA-1333: mark the one-time Agent Dashboard welcome as seen.
-  markDashboardWelcomeSeen: () =>
-    ipcRenderer.invoke("desktop:mark-dashboard-welcome-seen") as Promise<{
-      ok: boolean;
-    }>,
-  startDeviceOnboarding: (payload: unknown) =>
-    ipcRenderer.invoke("desktop:start-device-onboarding", payload) as Promise<unknown>,
-  dismissOnboardingPopup: (payload: { permanent: boolean }) =>
-    ipcRenderer.invoke("desktop:dismiss-onboarding-popup", payload) as Promise<unknown>,
-  onboardingPopupCta: () =>
-    ipcRenderer.invoke("desktop:onboarding-popup-cta") as Promise<unknown>,
-  pickSandboxDirectory: () =>
-    ipcRenderer.invoke("desktop:pick-sandbox-directory") as Promise<{
-      path: string;
-      isGitRepo: boolean;
-      suggestedPath: string | undefined;
-    } | null>,
-  inspectSandboxPath: (path: string) =>
-    ipcRenderer.invoke("desktop:inspect-sandbox-path", path) as Promise<{
-      path: string;
-      isGitRepo: boolean;
-      suggestedPath: string | undefined;
-    } | null>,
-  getDangerousAutoApprove: () =>
-    ipcRenderer.invoke("desktop:get-dangerous-auto-approve") as Promise<boolean>,
-  setDangerousAutoApprove: (enabled: boolean) =>
-    ipcRenderer.invoke("desktop:set-dangerous-auto-approve", enabled) as Promise<boolean>,
-  removeAlwaysAllowRule: (ruleId: string) =>
-    ipcRenderer.invoke("desktop:remove-always-allow-rule", ruleId) as Promise<unknown>,
-  checkForUpdate: () => ipcRenderer.invoke("desktop:check-for-update") as Promise<unknown>,
-  applyUpdate: () => ipcRenderer.invoke("desktop:apply-update") as Promise<unknown>,
-  isDebugAuthEnabled: () => ipcRenderer.invoke("desktop:is-debug-auth-enabled") as Promise<boolean>,
-  mintDebugToken: (origin?: string) =>
-    ipcRenderer.invoke("desktop:mint-debug-token", origin) as Promise<unknown>,
-  listRunningJobs: () => ipcRenderer.invoke("desktop:list-running-jobs") as Promise<unknown>,
-  listCompletedJobs: () => ipcRenderer.invoke("desktop:list-completed-jobs") as Promise<unknown>,
-  getJob: (jobId: string) => ipcRenderer.invoke("desktop:get-job", jobId) as Promise<unknown>,
-  getJobLogTail: (jobId: string, lines?: number) =>
-    ipcRenderer.invoke("desktop:get-job-log-tail", jobId, lines) as Promise<unknown>,
-  getLogs: () => ipcRenderer.invoke("desktop:get-logs") as Promise<unknown>,
-  clearLogs: () => ipcRenderer.invoke("desktop:clear-logs") as Promise<unknown>,
-  getLogFilePath: () =>
-    ipcRenderer.invoke("desktop:get-log-file-path") as Promise<string>,
-  openLogFile: () => ipcRenderer.invoke("desktop:open-log-file") as Promise<unknown>,
-  getAppVersion: () => ipcRenderer.invoke("desktop:get-app-version") as Promise<string>,
-  getBinaryPaths: () => ipcRenderer.invoke("desktop:get-binary-paths") as Promise<unknown>,
-  patchBinaryPaths: (patch: unknown) =>
-    ipcRenderer.invoke("desktop:patch-binary-paths", patch) as Promise<unknown>,
-  detectCliTools: () =>
-    ipcRenderer.invoke("desktop:detect-cli-tools") as Promise<unknown>,
-  saveConfig: (name: string) =>
-    ipcRenderer.invoke("desktop:save-config", { name }) as Promise<unknown>,
-  findMatchingConfig: () =>
-    ipcRenderer.invoke("desktop:find-matching-config") as Promise<unknown>,
-  listConfigs: () =>
-    ipcRenderer.invoke("desktop:list-configs") as Promise<unknown>,
-  deleteConfig: (id: string) =>
-    ipcRenderer.invoke("desktop:delete-config", { id }) as Promise<unknown>,
-  renameConfig: (id: string, name: string) =>
-    ipcRenderer.invoke("desktop:rename-config", { id, name }) as Promise<unknown>,
-  applyConfig: (id: string) =>
-    ipcRenderer.invoke("desktop:apply-config", { id }) as Promise<unknown>,
-  getAgentMonitorUrl: () =>
-    ipcRenderer.invoke("desktop:get-agent-monitor-url") as Promise<{
-      url: string | null;
-      ready: boolean;
-      enabled: boolean;
-      planExtractionEnabled: boolean;
-    }>,
-  openAgentMonitor: () =>
-    ipcRenderer.invoke("desktop:open-agent-monitor") as Promise<unknown>,
-  getAgentMonitorHooksEnabled: () =>
-    ipcRenderer.invoke(
-      "desktop:get-agent-monitor-hooks-enabled",
-    ) as Promise<boolean>,
-  setAgentMonitorHooksEnabled: (enabled: boolean) =>
-    ipcRenderer.invoke(
-      "desktop:set-agent-monitor-hooks-enabled",
-      enabled,
-    ) as Promise<{ ok: boolean; enabled: boolean; error?: string }>,
-  getAllFlags: () =>
-    ipcRenderer.invoke("desktop:get-all-flags") as Promise<unknown>,
-  onFlagsChanged: (callback: () => void) => {
-    ipcRenderer.on("desktop:flags-changed", callback);
-  },
-  // FEA-1334: cold-start ingest progress for the floating progress card.
-  // Resolves null when the sidecar is unreachable or has no progress yet.
-  getAgentMonitorIngestProgress: () =>
-    ipcRenderer.invoke(
-      "desktop:get-agent-monitor-ingest-progress",
-    ) as Promise<{
-      running: boolean;
-      startedAt: number | null;
-      updatedAt: number | null;
-      finishedAt: number | null;
-      total: number;
-      parsed: number;
-      imported: number;
-      byHarness: Record<
-        string,
-        { total: number; parsed: number; imported: number; complete: boolean }
-      >;
-    } | null>,
-  // FEA-1334: clear the dashboard DB and restart the sidecar so it re-imports
-  // every agent session from scratch. The progress banner tracks the re-import.
-  reprocessAgentLogs: () =>
-    ipcRenderer.invoke("desktop:reprocess-agent-logs") as Promise<{
-      ok: boolean;
-      error?: string;
-    }>,
-  /**
-   * Returns the current state of the managed-key revival limitation hint (D5).
-   * The main process reads provenance from apiKeyStore — renderer does not control
-   * what is returned.
-   */
-  getManagedKeyHintState: () =>
-    ipcRenderer.invoke("desktop:get-managed-key-hint-state") as Promise<ManagedKeyHintState>,
-  /**
-   * Dismisses the managed-key revival limitation hint (D5).
-   * The main process records the current provenance from apiKeyStore.
-   * The renderer does not supply any arguments — provenance is main-process-only.
-   */
-  dismissManagedKeyHint: () =>
-    ipcRenderer.invoke("desktop:dismiss-managed-key-hint") as Promise<{ success: boolean }>
-};
-
-contextBridge.exposeInMainWorld("desktopApi", desktopApi);
-
-ipcRenderer.on("desktop:navigate-tab", (_event, tab: string) => {
-  window.dispatchEvent(new CustomEvent("desktop:navigate-tab", { detail: tab }));
-});
-
-ipcRenderer.on("desktop:navigate-settings-tab", (_event, tab: string) => {
-  window.dispatchEvent(new CustomEvent("desktop:navigate-settings-tab", { detail: tab }));
-});
-
-ipcRenderer.on("desktop:command-keys-changed", () => {
-  window.dispatchEvent(new CustomEvent("desktop:command-keys-changed"));
-});
-
-ipcRenderer.on("desktop:update-available", (_event, result) => {
-  window.dispatchEvent(new CustomEvent("desktop:update-available", { detail: result }));
-});
-
-ipcRenderer.on("desktop:update-status", (_event, result) => {
-  window.dispatchEvent(new CustomEvent("desktop:update-status", { detail: result }));
-});
-
-ipcRenderer.on("desktop:onboarding-state-changed", () => {
-  window.dispatchEvent(new CustomEvent("desktop:onboarding-state-changed"));
-});
-
-ipcRenderer.on("desktop:show-onboarding-popup", () => {
-  window.dispatchEvent(new CustomEvent("desktop:show-onboarding-popup"));
-});
+exposeDesktopApi();
diff --git a/apps/desktop/src/main/reconciliation-worker.ts b/apps/desktop/src/main/reconciliation-worker.ts
index 9f8d4ec6..6384882d 100644
Binary files a/apps/desktop/src/main/reconciliation-worker.ts and b/apps/desktop/src/main/reconciliation-worker.ts differ
diff --git a/apps/desktop/src/main/settings-store.ts b/apps/desktop/src/main/settings-store.ts
index 8b6d7fa2..e40b97f8 100644
--- a/apps/desktop/src/main/settings-store.ts
+++ b/apps/desktop/src/main/settings-store.ts
@@ -265,6 +265,10 @@ export class SettingsStore {
     return this.getFlag("agentMonitorEnabled");
   }
 
+  getAgentDashboardDesignSystemEnabled(): boolean {
+    return this.getFlag("agentDashboardDesignSystemEnabled");
+  }
+
   getPlanExtractionEnabled(): boolean {
     return this.getFlag("planExtractionEnabled");
   }
@@ -309,6 +313,10 @@ export class SettingsStore {
     this.setFlag("agentMonitorEnabled", agentMonitorEnabled);
   }
 
+  setAgentDashboardDesignSystemEnabled(enabled: boolean): void {
+    this.setFlag("agentDashboardDesignSystemEnabled", enabled);
+  }
+
   setPlanExtractionEnabled(planExtractionEnabled: boolean): void {
     this.setFlag("planExtractionEnabled", planExtractionEnabled);
   }
diff --git a/apps/desktop/src/main/window.ts b/apps/desktop/src/main/window.ts
index 7c75ca2e..d4b0e389 100644
--- a/apps/desktop/src/main/window.ts
+++ b/apps/desktop/src/main/window.ts
@@ -1,20 +1,158 @@
-import { app, BrowserWindow } from "electron";
-import { existsSync } from "node:fs";
-import { fileURLToPath } from "node:url";
+import { app, BrowserWindow, protocol, shell } from "electron";
+import { readFileSync, existsSync, realpathSync, statSync } from "node:fs";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import path from "node:path";
+import type { AgentDashboardMode } from "./agent-dashboard-mode.js";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
+const RENDERER_DIR = path.resolve(__dirname, "..", "renderer");
+const DESIGN_RENDERER_DIR = path.join(RENDERER_DIR, "design-system");
+const DESIGN_RENDERER_URL = "app://renderer/design-system/index.html";
+const APP_PROTOCOL = "app";
+const EXTERNAL_LINK_HOSTS = new Set([
+  "app.closedloop.ai",
+  "closedloop.ai",
+  "docs.closedloop.ai",
+  "github.com",
+]);
+
+let appProtocolRegistered = false;
+
+const MIME_TYPES: Record<string, string> = {
+  ".html": "text/html",
+  ".js": "text/javascript",
+  ".css": "text/css",
+  ".json": "application/json",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".png": "image/png",
+  ".webp": "image/webp",
+  ".svg": "image/svg+xml",
+  ".ico": "image/x-icon",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".map": "application/json",
+};
+
+const APP_PROTOCOL_EXTENSIONS = new Set(Object.keys(MIME_TYPES));
+
+function mimeType(ext: string): string {
+  return MIME_TYPES[ext] ?? "application/octet-stream";
+}
+
+function registerAppProtocol(): void {
+  if (appProtocolRegistered) {
+    return;
+  }
+
+  protocol.handle(APP_PROTOCOL, (request) => {
+    return serveAppProtocolAsset(request);
+  });
+  appProtocolRegistered = true;
+}
+
+function unregisterAppProtocol(): void {
+  if (!appProtocolRegistered) {
+    return;
+  }
+
+  const protocolWithUnhandle = protocol as typeof protocol & {
+    unhandle?: (scheme: string) => void;
+  };
+  if (typeof protocolWithUnhandle.unhandle === "function") {
+    protocolWithUnhandle.unhandle(APP_PROTOCOL);
+  }
+  appProtocolRegistered = false;
+}
+
+function serveAppProtocolAsset(request: Request): Response {
+  if (request.method !== "GET") {
+    return new Response("Method not allowed", { status: 405 });
+  }
+
+  let url: URL;
+  try {
+    url = new URL(request.url);
+  } catch {
+    return new Response("Bad request", { status: 400 });
+  }
+
+  if (url.protocol !== `${APP_PROTOCOL}:` || url.hostname !== "renderer") {
+    return new Response("Not found", { status: 404 });
+  }
+
+  let decodedPathname: string;
+  try {
+    decodedPathname = decodeURIComponent(url.pathname);
+  } catch {
+    return new Response("Bad request", { status: 400 });
+  }
+
+  if (
+    !decodedPathname.startsWith("/design-system/") ||
+    decodedPathname.includes("\0") ||
+    decodedPathname.includes("\\")
+  ) {
+    return new Response("Not found", { status: 404 });
+  }
+
+  const relativePath = decodedPathname.replace(/^\//, "");
+  const pathParts = relativePath.split("/");
+  if (pathParts.includes("..") || path.isAbsolute(relativePath)) {
+    return new Response("Forbidden", { status: 403 });
+  }
+
+  const filePath = path.resolve(RENDERER_DIR, relativePath);
+  if (!isPathInside(filePath, DESIGN_RENDERER_DIR)) {
+    return new Response("Forbidden", { status: 403 });
+  }
+
+  const ext = path.extname(filePath).toLowerCase();
+  if (!APP_PROTOCOL_EXTENSIONS.has(ext)) {
+    return new Response("Not found", { status: 404 });
+  }
+
+  if (!existsSync(filePath)) {
+    return new Response("Not found", { status: 404 });
+  }
+
+  let realRoot: string;
+  let realFile: string;
+  try {
+    realRoot = realpathSync(DESIGN_RENDERER_DIR);
+    realFile = realpathSync(filePath);
+    if (!statSync(realFile).isFile() || !isPathInside(realFile, realRoot)) {
+      return new Response("Forbidden", { status: 403 });
+    }
+  } catch {
+    return new Response("Not found", { status: 404 });
+  }
+
+  const data = readFileSync(realFile);
+  return new Response(data, {
+    status: 200,
+    headers: { "Content-Type": mimeType(ext) },
+  });
+}
+
 export class DesktopWindow {
   private browserWindow: BrowserWindow | null = null;
   private disposing = false;
   private quitting = false;
+  private allowedRendererUrl: string | null = null;
+  private agentDashboardMode: AgentDashboardMode;
+
+  constructor(options: { agentDashboardMode: AgentDashboardMode }) {
+    this.agentDashboardMode = options.agentDashboardMode;
+  }
 
   init(): void {
     if (this.browserWindow) {
       return;
     }
 
+    this.allowedRendererUrl = null;
     this.browserWindow = new BrowserWindow({
       width: 1280,
       height: 800,
@@ -23,8 +161,12 @@ export class DesktopWindow {
       webPreferences: {
         contextIsolation: true,
         sandbox: false,
-        preload: path.join(__dirname, "preload.js")
-      }
+        preload: this.resolvePreloadPath(),
+        additionalArguments:
+          this.agentDashboardMode === "design-system"
+            ? ["--closedloop-agent-dashboard-design-system"]
+            : [],
+      },
     });
     this.browserWindow.once("ready-to-show", () => {
       this.browserWindow?.show();
@@ -36,8 +178,86 @@ export class DesktopWindow {
       event.preventDefault();
       this.browserWindow?.hide();
     });
-    const htmlPath = resolveRendererPath();
-    void this.browserWindow.loadFile(htmlPath);
+    this.installNavigationGuards();
+
+    void this.loadContent();
+  }
+
+  /**
+   * Recreate the BrowserWindow with the preload and renderer target for the
+   * requested Agent Dashboard mode. Electron preloads are fixed at window
+   * creation time, so runtime availability disable must replace the window
+   * instead of only navigating the existing design-system renderer.
+   */
+  reloadForAgentDashboardMode(agentDashboardMode: AgentDashboardMode): void {
+    const wasVisible = this.browserWindow?.isVisible() ?? false;
+    this.agentDashboardMode = agentDashboardMode;
+
+    if (this.browserWindow) {
+      this.dispose();
+    }
+
+    this.init();
+    if (wasVisible) {
+      this.show();
+    }
+  }
+
+  private async loadContent(): Promise<void> {
+    if (this.agentDashboardMode !== "design-system") {
+      unregisterAppProtocol();
+      const rendererPath = resolveLegacyRendererPath();
+      this.allowRendererUrl(pathToFileURL(rendererPath).toString());
+      await this.browserWindow!.loadFile(rendererPath);
+      return;
+    }
+
+    registerAppProtocol();
+    this.allowRendererUrl(DESIGN_RENDERER_URL);
+    await this.browserWindow!.loadURL(DESIGN_RENDERER_URL);
+  }
+
+  private installNavigationGuards(): void {
+    if (!this.browserWindow) {
+      return;
+    }
+
+    this.browserWindow.webContents.setWindowOpenHandler(({ url }) => {
+      if (isAllowedExternalUrl(url)) {
+        void shell.openExternal(url);
+      }
+      return { action: "deny" };
+    });
+
+    this.browserWindow.webContents.on("will-navigate", (event, url) => {
+      if (!this.isAllowedNavigation(url)) {
+        event.preventDefault();
+      }
+    });
+  }
+
+  private isAllowedNavigation(url: string): boolean {
+    if (!this.allowedRendererUrl) {
+      return false;
+    }
+    try {
+      return new URL(url).href === this.allowedRendererUrl;
+    } catch {
+      return false;
+    }
+  }
+
+  private allowRendererUrl(url: string): void {
+    this.allowedRendererUrl = new URL(url).href;
+  }
+
+  private resolvePreloadPath(): string {
+    return path.join(
+      __dirname,
+      this.agentDashboardMode === "design-system"
+        ? "preload-design-system.js"
+        : "preload.js",
+    );
   }
 
   getWindow(): BrowserWindow | null {
@@ -61,11 +281,31 @@ export class DesktopWindow {
     this.disposing = true;
     this.browserWindow.close();
     this.browserWindow = null;
+    this.allowedRendererUrl = null;
     this.disposing = false;
   }
 }
 
-function resolveRendererPath(): string {
+function isAllowedExternalUrl(url: string): boolean {
+  try {
+    const parsed = new URL(url);
+    return (
+      parsed.protocol === "https:" &&
+      parsed.username === "" &&
+      parsed.password === "" &&
+      EXTERNAL_LINK_HOSTS.has(parsed.hostname)
+    );
+  } catch {
+    return false;
+  }
+}
+
+function isPathInside(candidate: string, root: string): boolean {
+  const relative = path.relative(root, candidate);
+  return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+
+function resolveLegacyRendererPath(): string {
   if (app.isPackaged) {
     return path.join(__dirname, "..", "..", "src", "renderer", "index.html");
   }
diff --git a/apps/desktop/src/renderer/App.tsx b/apps/desktop/src/renderer/App.tsx
new file mode 100644
index 00000000..7921bc5f
--- /dev/null
+++ b/apps/desktop/src/renderer/App.tsx
@@ -0,0 +1,222 @@
+import {
+  useState,
+  useCallback,
+  useEffect,
+  useMemo,
+  lazy,
+  Suspense,
+  startTransition,
+} from "react";
+import { Sidebar } from "./components/layout/Sidebar";
+import { Topbar } from "./components/layout/Topbar";
+import { UpdateBanner } from "./components/UpdateBanner";
+import { SessionNavContext } from "./components/sessions/session-nav";
+
+const DashboardPage = lazy(() => import("./components/dashboard/DashboardPage").then((m) => ({ default: m.DashboardPage })));
+const SettingsPanel = lazy(() => import("./components/settings/SettingsPanel").then((m) => ({ default: m.SettingsPanel })));
+const KanbanView = lazy(() => import("./components/kanban/KanbanView").then((m) => ({ default: m.KanbanView })));
+const ActivityFeedView = lazy(() => import("./components/feed/ActivityFeedView").then((m) => ({ default: m.ActivityFeedView })));
+const AnalyticsView = lazy(() => import("./components/analytics/AnalyticsView").then((m) => ({ default: m.AnalyticsView })));
+const WorkflowsView = lazy(() => import("./components/workflows/WorkflowsView").then((m) => ({ default: m.WorkflowsView })));
+const ApprovalsPanel = lazy(() => import("./components/approvals/ApprovalsPanel").then((m) => ({ default: m.ApprovalsPanel })));
+const ActivityPanel = lazy(() => import("./components/activity/ActivityPanel").then((m) => ({ default: m.ActivityPanel })));
+const LogsPanel = lazy(() => import("./components/logs/LogsPanel").then((m) => ({ default: m.LogsPanel })));
+const SessionDetailView = lazy(() => import("./components/sessions/SessionDetailView").then((m) => ({ default: m.SessionDetailView })));
+
+export type NavId =
+  | "dashboard"
+  | "kanban"
+  | "activity"
+  | "analytics"
+  | "workflows"
+  | "approvals"
+  | "requests"
+  | "diagnostics"
+  | "settings";
+
+const DEFAULT_NAV_ID: NavId = "dashboard";
+
+function isNavId(value: string | null): value is NavId {
+  return value === "dashboard"
+    || value === "kanban"
+    || value === "activity"
+    || value === "analytics"
+    || value === "workflows"
+    || value === "approvals"
+    || value === "requests"
+    || value === "diagnostics"
+    || value === "settings";
+}
+
+function readHashState(): { navId: NavId; detailSessionId: string | null } {
+  const params = new URLSearchParams(window.location.hash.slice(1));
+  const tab = params.get("tab");
+  const sessionId = params.get("sessionId");
+
+  return {
+    navId: isNavId(tab) ? tab : DEFAULT_NAV_ID,
+    detailSessionId: sessionId && sessionId.length > 0 ? sessionId : null,
+  };
+}
+
+function writeHashState(navId: NavId, detailSessionId: string | null): void {
+  const params = new URLSearchParams();
+  params.set("tab", navId);
+  if (detailSessionId) {
+    params.set("sessionId", detailSessionId);
+  }
+  window.location.hash = params.toString();
+}
+
+function PageFallback() {
+  return (
+    <div className="flex items-center justify-center h-full">
+      <p className="text-sm text-[var(--muted-foreground)]">Loading...</p>
+    </div>
+  );
+}
+
+export default function App() {
+  const initialHashState = readHashState();
+  const [navId, setNavId] = useState<NavId>(initialHashState.navId);
+  const [detailSessionId, setDetailSessionId] = useState<string | null>(
+    initialHashState.detailSessionId,
+  );
+  const [visitedNavIds, setVisitedNavIds] = useState<NavId[]>([initialHashState.navId]);
+  const [runtimeStatus, setRuntimeStatus] = useState<Record<string, unknown> | null>(null);
+
+  useEffect(() => {
+    window.desktopApi
+      .getRuntimeStatus()
+      .then((s) => setRuntimeStatus(s as Record<string, unknown>))
+      .catch(() => {});
+  }, []);
+
+  const navigate = useCallback((id: NavId) => {
+    startTransition(() => {
+      setNavId(id);
+      setDetailSessionId(null);
+      setVisitedNavIds((current) => (current.includes(id) ? current : [...current, id]));
+    });
+    writeHashState(id, null);
+  }, []);
+
+  const handleBack = useCallback(() => {
+    startTransition(() => {
+      setDetailSessionId(null);
+    });
+    writeHashState(navId, null);
+  }, [navId]);
+
+  useEffect(() => {
+    const syncFromHash = () => {
+      const nextState = readHashState();
+      startTransition(() => {
+        setNavId(nextState.navId);
+        setDetailSessionId(nextState.detailSessionId);
+        setVisitedNavIds((current) => (
+          current.includes(nextState.navId) ? current : [...current, nextState.navId]
+        ));
+      });
+    };
+
+    syncFromHash();
+    window.addEventListener("hashchange", syncFromHash);
+    return () => window.removeEventListener("hashchange", syncFromHash);
+  }, []);
+
+  useEffect(() => {
+    const handler = (e: CustomEvent<string>) => {
+      navigate(e.detail as NavId);
+    };
+    window.addEventListener("desktop:navigate-tab", handler as EventListener);
+    return () =>
+      window.removeEventListener("desktop:navigate-tab", handler as EventListener);
+  }, [navigate]);
+
+  const sessionNav = useMemo(
+    () => ({
+      openSession: (id: string) => {
+        startTransition(() => {
+          setDetailSessionId(id);
+        });
+        writeHashState(navId, id);
+      },
+    }),
+    [navId],
+  );
+
+  const [collapsed, setCollapsed] = useState(false);
+  const toggleSidebar = useCallback(() => setCollapsed((c) => !c), []);
+
+  const healthy = runtimeStatus?.gatewayHealthy === true;
+
+  const renderPage = useCallback((pageId: NavId) => {
+    switch (pageId) {
+      case "dashboard":
+        return <DashboardPage />;
+      case "kanban":
+        return <KanbanView />;
+      case "activity":
+        return <ActivityFeedView />;
+      case "analytics":
+        return <AnalyticsView />;
+      case "workflows":
+        return <WorkflowsView />;
+      case "approvals":
+        return <ApprovalsPanel />;
+      case "requests":
+        return <ActivityPanel />;
+      case "diagnostics":
+        return <LogsPanel />;
+      case "settings":
+        return <SettingsPanel />;
+      default:
+        return <DashboardPage />;
+    }
+  }, []);
+
+  const content = detailSessionId ? (
+    <SessionDetailView sessionId={detailSessionId} onBack={handleBack} />
+  ) : (
+    <Suspense fallback={<PageFallback />}>
+      {visitedNavIds.map((pageId) => {
+        const active = pageId === navId;
+        return (
+          <div
+            key={pageId}
+            aria-hidden={active ? undefined : true}
+            className={active ? "block h-full" : "hidden h-full"}
+          >
+            {renderPage(pageId)}
+          </div>
+        );
+      })}
+    </Suspense>
+  );
+
+  return (
+    <div className="flex h-screen overflow-hidden bg-[var(--background)] text-[var(--foreground)]">
+      <Sidebar
+        collapsed={collapsed}
+        activeNav={navId}
+        onNavigate={navigate}
+        runtimeHealthy={healthy}
+      />
+      <div className="flex flex-col flex-1 min-w-0">
+        <UpdateBanner />
+        <Topbar
+          collapsed={collapsed}
+          onToggleSidebar={toggleSidebar}
+          navId={navId}
+          runtimeStatus={runtimeStatus}
+        />
+        <main className="flex-1 overflow-auto">
+          <SessionNavContext.Provider value={sessionNav}>
+            {content}
+          </SessionNavContext.Provider>
+        </main>
+      </div>
+    </div>
+  );
+}
diff --git a/apps/desktop/src/renderer/components/UpdateBanner.tsx b/apps/desktop/src/renderer/components/UpdateBanner.tsx
new file mode 100644
index 00000000..10882b46
--- /dev/null
+++ b/apps/desktop/src/renderer/components/UpdateBanner.tsx
@@ -0,0 +1,80 @@
+import { useCallback, useState } from "react";
+import { Button } from "@closedloop-ai/design-system/components/ui/button";
+import { useDesktopEvent } from "../hooks/useDesktopApi";
+import {
+  INITIAL_UPDATE_BANNER_STATE,
+  isUpdateApplyEnabled,
+  isUpdateBannerVisible,
+  reduceUpdateAvailableEvent,
+  reduceUpdateStatusEvent,
+  updateBannerMessage,
+  type UpdateBannerState,
+} from "./update-banner-state";
+
+/**
+ * Self-contained auto-update banner. Subscribes to the IPC-bridged
+ * `desktop:update-status` / `desktop:update-available` window events (re-emitted
+ * by preload.ts) and offers an "Update & restart" action that calls
+ * applyUpdate() only once the update is downloaded. All visibility/apply gating
+ * is delegated to the pure helpers in update-banner-state.ts.
+ */
+export function UpdateBanner() {
+  const [state, setState] = useState<UpdateBannerState>(
+    INITIAL_UPDATE_BANNER_STATE,
+  );
+  const [applying, setApplying] = useState(false);
+
+  useDesktopEvent(
+    "desktop:update-status",
+    useCallback((detail) => {
+      setState((prev) => reduceUpdateStatusEvent(prev, detail));
+    }, []),
+  );
+
+  useDesktopEvent(
+    "desktop:update-available",
+    useCallback((detail) => {
+      setState((prev) => reduceUpdateAvailableEvent(prev, detail));
+    }, []),
+  );
+
+  const handleApply = useCallback(async () => {
+    setApplying(true);
+    try {
+      await window.desktopApi.applyUpdate();
+    } catch {
+      // The main process rejects an apply before the update is downloaded;
+      // re-enable the button so the user can retry once ready.
+      setApplying(false);
+    }
+  }, []);
+
+  if (!isUpdateBannerVisible(state)) {
+    return null;
+  }
+
+  const isError = state.status === "error";
+
+  return (
+    <div
+      role="status"
+      className={`flex items-center justify-between gap-3 px-4 py-2 text-sm border-b shrink-0 ${
+        isError
+          ? "bg-[var(--destructive)]/10 text-[var(--destructive)]"
+          : "bg-[var(--primary)]/10 text-[var(--foreground)]"
+      }`}
+    >
+      <span className="truncate">{updateBannerMessage(state)}</span>
+      {isUpdateApplyEnabled(state) && (
+        <Button
+          size="sm"
+          onClick={handleApply}
+          disabled={applying}
+          className="shrink-0"
+        >
+          {applying ? "Restarting..." : "Update & restart"}
+        </Button>
+      )}
+    </div>
+  );
+}
diff --git a/apps/desktop/src/renderer/components/activity/ActivityPanel.tsx b/apps/desktop/src/renderer/components/activity/ActivityPanel.tsx
new file mode 100644
index 00000000..d5a214a9
--- /dev/null
+++ b/apps/desktop/src/renderer/components/activity/ActivityPanel.tsx
@@ -0,0 +1,148 @@
+import { useState, useEffect, useCallback } from "react";
+import { Button } from "@closedloop-ai/design-system/components/ui/button";
+import { Card, CardContent, CardHeader, CardTitle } from "@closedloop-ai/design-system/components/ui/card";
+import { Badge } from "@closedloop-ai/design-system/components/ui/badge";
+
+interface ActivityEvent {
+  id: string;
+  type?: string;
+  summary?: string;
+  timestamp?: string;
+}
+
+interface Job {
+  id: string;
+  description?: string;
+  status?: string;
+  startedAt?: string;
+}
+
+export function ActivityPanel() {
+  const [events, setEvents] = useState<ActivityEvent[]>([]);
+  const [runningJobs, setRunningJobs] = useState<Job[]>([]);
+  const [completedJobs, setCompletedJobs] = useState<Job[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [showRegular, setShowRegular] = useState(true);
+  const [showSecurity, setShowSecurity] = useState(true);
+
+  const load = useCallback(async () => {
+    setLoading(true);
+    try {
+      const [evts, running, completed] = await Promise.all([
+        window.desktopApi.getActivityEvents(),
+        window.desktopApi.listRunningJobs(),
+        window.desktopApi.listCompletedJobs(),
+      ]);
+      setEvents((evts as ActivityEvent[]) ?? []);
+      setRunningJobs((running as Job[]) ?? []);
+      setCompletedJobs((completed as Job[]) ?? []);
+    } catch { /* ignore */ }
+    setLoading(false);
+  }, []);
+
+  useEffect(() => { load(); }, [load]);
+
+  const handleClear = async () => {
+    await window.desktopApi.clearActivityEvents();
+    await load();
+  };
+
+  const filtered = events.filter((e) => {
+    const type = e.type ?? "";
+    if (type.includes("security") || type.includes("auth")) return showSecurity;
+    return showRegular;
+  });
+
+  const jobStatusVariant = (status?: string) => {
+    if (status === "running" || status === "active") return "default";
+    if (status === "completed" || status === "success") return "secondary";
+    return "outline";
+  };
+
+  return (
+    <div className="p-6 space-y-6">
+      <div className="flex items-center justify-between">
+        <h2 className="text-lg font-semibold text-[var(--foreground)]">Activity</h2>
+        <div className="flex gap-2">
+          <Button variant="outline" size="sm" onClick={load}>Refresh</Button>
+          <Button variant="outline" size="sm" onClick={handleClear}>Clear Activity</Button>
+        </div>
+      </div>
+
+      <Card>
+        <CardHeader>
+          <CardTitle>Running Jobs</CardTitle>
+        </CardHeader>
+        <CardContent>
+          {runningJobs.length === 0 ? (
+            <p className="text-sm text-[var(--muted-foreground)] text-center py-4">No running jobs</p>
+          ) : (
+            <div className="space-y-2">
+              {runningJobs.map((j) => (
+                <div key={j.id} className="flex items-center justify-between border rounded p-3 text-sm">
+                  <span className="truncate">{j.description ?? j.id}</span>
+                  <Badge variant={jobStatusVariant(j.status)}>{j.status ?? "running"}</Badge>
+                </div>
+              ))}
+            </div>
+          )}
+        </CardContent>
+      </Card>
+
+      <details className="group">
+        <summary className="text-sm font-medium cursor-pointer text-[var(--foreground)] mb-2">Completed Jobs ({completedJobs.length})</summary>
+        <Card className="mt-2">
+          <CardContent>
+            {completedJobs.length === 0 ? (
+              <p className="text-sm text-[var(--muted-foreground)] text-center py-4">No completed jobs</p>
+            ) : (
+              <div className="space-y-2 max-h-48 overflow-y-auto">
+                {completedJobs.map((j) => (
+                  <div key={j.id} className="flex items-center justify-between border rounded p-3 text-sm">
+                    <span className="truncate">{j.description ?? j.id}</span>
+                    <Badge variant={jobStatusVariant(j.status)}>{j.status ?? "completed"}</Badge>
+                  </div>
+                ))}
+              </div>
+            )}
+          </CardContent>
+        </Card>
+      </details>
+
+      <Card>
+        <CardHeader>
+          <CardTitle>Gateway Request Log</CardTitle>
+        </CardHeader>
+        <CardContent className="space-y-3">
+          <div className="flex items-center gap-4 text-sm">
+            <label className="flex items-center gap-2 cursor-pointer">
+              <input type="checkbox" checked={showRegular} onChange={(e) => setShowRegular(e.target.checked)} className="rounded" />
+              Show Regular Events
+            </label>
+            <label className="flex items-center gap-2 cursor-pointer">
+              <input type="checkbox" checked={showSecurity} onChange={(e) => setShowSecurity(e.target.checked)} className="rounded" />
+              Show Security Events
+            </label>
+          </div>
+          {loading ? (
+            <p className="text-sm text-[var(--muted-foreground)] text-center py-4">Loading...</p>
+          ) : filtered.length === 0 ? (
+            <p className="text-sm text-[var(--muted-foreground)] text-center py-4">No events</p>
+          ) : (
+            <div className="max-h-64 overflow-y-auto space-y-1">
+              {filtered.map((e) => (
+                <div key={e.id} className="flex items-start gap-2 text-xs p-1.5 border-b last:border-0">
+                  <span className="shrink-0 text-[var(--muted-foreground)] w-16">
+                    {e.timestamp ? new Date(e.timestamp).toLocaleTimeString() : ""}
+                  </span>
+                  <span className="font-medium">{e.type}</span>
+                  <span className="text-[var(--muted-foreground)] truncate">{e.summary}</span>
+                </div>
+              ))}
+            </div>
+          )}
+        </CardContent>
+      </Card>
+    </div>
+  );
+}
diff --git a/apps/desktop/src/renderer/components/analytics/AnalyticsDetails.tsx b/apps/desktop/src/renderer/components/analytics/AnalyticsDetails.tsx
new file mode 100644
index 00000000..96ffbb46
--- /dev/null
+++ b/apps/desktop/src/renderer/components/analytics/AnalyticsDetails.tsx
@@ -0,0 +1,210 @@
+import { Card, CardContent, CardHeader, CardTitle } from "@closedloop-ai/design-system/components/ui/card";
+import { LineChart } from "@closedloop-ai/design-system/components/ui/primitives/line-chart";
+import { DonutChart } from "@closedloop-ai/design-system/components/ui/primitives/donut-chart";
+import { RankedBar } from "@closedloop-ai/design-system/components/ui/primitives/ranked-bar";
+import { ActivityHeatmap } from "@closedloop-ai/design-system/components/ui/primitives/activity-heatmap";
+import { SegmentedBar } from "@closedloop-ai/design-system/components/ui/primitives/segmented-bar";
+import type { AnalyticsData } from "../../../shared/agent-db-contract";
+
+const PALETTE = [
+  "#3b82f6", "#10b981", "#f59e0b", "#ef4444", "#8b5cf6",
+  "#ec4899", "#14b8a6", "#f97316", "#6366f1", "#84cc16",
+];
+
+const STATUS_COLORS: Record<string, string> = {
+  running: "#3b82f6", active: "#3b82f6", completed: "#10b981",
+  failed: "#ef4444", error: "#ef4444", stopped: "#6b7280",
+  waiting: "#f59e0b", abandoned: "#9ca3af",
+};
+
+function buildHeatmapWeeks(dailyEvents: Array<{ date: string; count: number }>) {
+  const counts = new Map(dailyEvents.map((d) => [d.date, d.count]));
+  const weeks: Array<Array<{ date: string; count: number }>> = [];
+  const today = new Date();
+  const start = new Date(today);
+  start.setDate(start.getDate() - 364);
+  start.setDate(start.getDate() - start.getDay());
+
+  let week: Array<{ date: string; count: number }> = [];
+  for (let d = new Date(start); d <= today; d.setDate(d.getDate() + 1)) {
+    const iso = d.toISOString().slice(0, 10);
+    week.push({ date: iso, count: counts.get(iso) ?? 0 });
+    if (week.length === 7) {
+      weeks.push(week);
+      week = [];
+    }
+  }
+  if (week.length > 0) weeks.push(week);
+  return weeks;
+}
+
+export function AnalyticsDetails({ data }: { data: AnalyticsData }) {
+  const { tokens, eventsByType, toolUsage, dailyEvents, sessionsByStatus, agentsByStatus, agentsByType } = data;
+  const totalTokens = tokens.totalInputTokens + tokens.totalOutputTokens;
+  const cacheTokens = tokens.totalCacheReadTokens + tokens.totalCacheWriteTokens;
+
+  const tokenSegments = [
+    { label: "Input", value: tokens.totalInputTokens, color: PALETTE[0] },
+    { label: "Output", value: tokens.totalOutputTokens, color: PALETTE[1] },
+    { label: "Cache Read", value: tokens.totalCacheReadTokens, color: PALETTE[2] },
+    { label: "Cache Write", value: tokens.totalCacheWriteTokens, color: PALETTE[3] },
+  ].filter((s) => s.value > 0);
+
+  const sessionSegments = sessionsByStatus.map((s, i) => ({
+    label: s.status, value: s.count, color: STATUS_COLORS[s.status] ?? PALETTE[i % PALETTE.length],
+  }));
+
+  const agentStatusSegments = agentsByStatus.map((s, i) => ({
+    label: s.status, value: s.count, color: STATUS_COLORS[s.status] ?? PALETTE[i % PALETTE.length],
+  }));
+
+  const eventSegments = eventsByType.slice(0, 8).map((e, i) => ({
+    label: e.eventType, value: e.count, color: PALETTE[i % PALETTE.length],
+  }));
+
+  const agentTypeSegments = agentsByType.slice(0, 8).map((a, i) => ({
+    key: a.type, label: a.type, value: a.count,
+    colorClassName: `bg-[${PALETTE[i % PALETTE.length]}]`,
+  }));
+  const agentTypeTotal = agentsByType.reduce((s, a) => s + a.count, 0);
+
+  const dayPoints = (tokens.byDay ?? []).map((d) => ({
+    label: d.day, value: d.inputTokens + d.outputTokens,
+  }));
+
+  const maxToolCount = toolUsage.length > 0 ? toolUsage[0].count : 1;
+  const heatmapWeeks = buildHeatmapWeeks(dailyEvents);
+
+  return (
+    <>
+      {dailyEvents.length > 0 && (
+        <Card>
+          <CardHeader><CardTitle>Activity Heatmap</CardTitle></CardHeader>
+          <CardContent>
+            <ActivityHeatmap weeks={heatmapWeeks} />
+          </CardContent>
+        </Card>
+      )}
+
+      <div className="grid grid-cols-2 gap-6">
+        <Card>
+          <CardHeader><CardTitle>Token Distribution</CardTitle></CardHeader>
+          <CardContent>
+            {tokenSegments.length > 0 ? (
+              <DonutChart segments={tokenSegments} formatTotal={(t) => t.toLocaleString()} centerLabel="Tokens" />
+            ) : (
+              <p className="py-8 text-sm text-center text-[var(--muted-foreground)]">No token data</p>
+            )}
+          </CardContent>
+        </Card>
+
+        <Card>
+          <CardHeader><CardTitle>Sessions by Status</CardTitle></CardHeader>
+          <CardContent>
+            {sessionSegments.length > 0 ? (
+              <DonutChart segments={sessionSegments} formatTotal={(t) => `${t}`} centerLabel="Sessions" />
+            ) : (
+              <p className="py-8 text-sm text-center text-[var(--muted-foreground)]">No session data</p>
+            )}
+          </CardContent>
+        </Card>
+
+        <Card>
+          <CardHeader><CardTitle>Agents by Status</CardTitle></CardHeader>
+          <CardContent>
+            {agentStatusSegments.length > 0 ? (
+              <DonutChart segments={agentStatusSegments} formatTotal={(t) => `${t}`} centerLabel="Agents" />
+            ) : (
+              <p className="py-8 text-sm text-center text-[var(--muted-foreground)]">No agent data</p>
+            )}
+          </CardContent>
+        </Card>
+
+        <Card>
+          <CardHeader><CardTitle>Events by Type</CardTitle></CardHeader>
+          <CardContent>
+            {eventSegments.length > 0 ? (
+              <DonutChart segments={eventSegments} formatTotal={(t) => t.toLocaleString()} centerLabel="Events" />
+            ) : (
+              <p className="py-8 text-sm text-center text-[var(--muted-foreground)]">No event data</p>
+            )}
+          </CardContent>
+        </Card>
+      </div>
+
+      {agentTypeSegments.length > 0 && (
+        <Card>
+          <CardHeader><CardTitle>Agent Type Distribution</CardTitle></CardHeader>
+          <CardContent>
+            <SegmentedBar segments={agentTypeSegments} total={agentTypeTotal} />
+          </CardContent>
+        </Card>
+      )}
+
+      <Card>
+        <CardHeader><CardTitle>Tool Usage</CardTitle></CardHeader>
+        <CardContent>
+          {toolUsage.length > 0 ? (
+            <div className="space-y-2">
+              {toolUsage.slice(0, 15).map((t) => (
+                <RankedBar
+                  key={t.toolName}
+                  label={<span className="font-mono text-xs">{t.toolName}</span>}
+                  value={t.count}
+                  percent={(t.count / maxToolCount) * 100}
+                />
+              ))}
+            </div>
+          ) : (
+            <p className="py-8 text-sm text-center text-[var(--muted-foreground)]">No tool usage data</p>
+          )}
+        </CardContent>
+      </Card>
+
+      <Card>
+        <CardHeader><CardTitle>Token Usage by Model</CardTitle></CardHeader>
+        <CardContent>
+          {tokens.byModel.length > 0 ? (
+            <div className="space-y-2">
+              {tokens.byModel.map((m) => {
+                const modelTotal = m.inputTokens + m.outputTokens;
+                const maxModel = tokens.byModel[0] ? tokens.byModel[0].inputTokens + tokens.byModel[0].outputTokens : 1;
+                return (
+                  <RankedBar
+                    key={m.model}
+                    label={<span className="font-mono text-xs">{m.model}</span>}
+                    value={modelTotal.toLocaleString()}
+                    percent={(modelTotal / maxModel) * 100}
+                    description={<span className="text-[var(--muted-foreground)]">{m.sessions} sessions</span>}
+                  />
+                );
+              })}
+            </div>
+          ) : (
+            <p className="py-8 text-sm text-center text-[var(--muted-foreground)]">No model data</p>
+          )}
+        </CardContent>
+      </Card>
+
+      {dayPoints.length > 0 && (
+        <Card>
+          <CardHeader><CardTitle>Daily Token Usage (Last 30 Days)</CardTitle></CardHeader>
+          <CardContent>
+            <div className="h-48">
+              <LineChart points={dayPoints} color={PALETTE[0]} valueFormatter={(v) => v.toLocaleString()} />
+            </div>
+          </CardContent>
+        </Card>
+      )}
+
+      <Card>
+        <CardHeader><CardTitle>At a Glance</CardTitle></CardHeader>
+        <CardContent className="text-sm text-[var(--muted-foreground)]">
+          {cacheTokens > 0
+            ? `${Math.round((cacheTokens / (totalTokens + cacheTokens)) * 100)}% of total token traffic was cache-related.`
+            : "No cache token activity recorded yet."}
+        </CardContent>
+      </Card>
+    </>
+  );
+}
diff --git a/apps/desktop/src/renderer/components/analytics/AnalyticsView.tsx b/apps/desktop/src/renderer/components/analytics/AnalyticsView.tsx
new file mode 100644
index 00000000..b0c61060
--- /dev/null
+++ b/apps/desktop/src/renderer/components/analytics/AnalyticsView.tsx
@@ -0,0 +1,93 @@
+import { lazy, Suspense, useEffect, useState } from "react";
+import { MetricCard } from "@closedloop-ai/design-system/components/ui/primitives/metric-card";
+import { Coins, ArrowDownToLine, ArrowUpFromLine, DatabaseZap } from "lucide-react";
+import { useQueryCache } from "../../hooks/useQueryCache";
+import type { AnalyticsData } from "../../../shared/agent-db-contract";
+
+const AnalyticsDetails = lazy(() =>
+  import("./AnalyticsDetails").then((module) => ({
+    default: module.AnalyticsDetails,
+  })),
+);
+
+function AnalyticsDetailsFallback() {
+  return (
+    <div className="rounded-xl border border-border/70 bg-card/90 p-6 text-sm text-[var(--muted-foreground)] shadow-sm">
+      Loading charts and breakdowns...
+    </div>
+  );
+}
+
+export function AnalyticsView() {
+  const { data, loading } = useQueryCache<AnalyticsData>(
+    "db:analytics",
+    () => window.desktopApi.db.getAnalytics() as Promise<AnalyticsData>,
+    10_000, 15_000,
+  );
+  const [showDetails, setShowDetails] = useState(false);
+
+  useEffect(() => {
+    if (!data) {
+      setShowDetails(false);
+      return;
+    }
+
+    let cancelled = false;
+    const schedule = typeof window.requestAnimationFrame === "function"
+      ? window.requestAnimationFrame.bind(window)
+      : (callback: FrameRequestCallback) => window.setTimeout(callback, 16);
+    const firstFrame = schedule(() => {
+      const secondFrame = schedule(() => {
+        if (!cancelled) {
+          setShowDetails(true);
+        }
+      });
+      if (cancelled && typeof window.cancelAnimationFrame === "function") {
+        window.cancelAnimationFrame(secondFrame);
+      }
+    });
+
+    return () => {
+      cancelled = true;
+      if (typeof window.cancelAnimationFrame === "function") {
+        window.cancelAnimationFrame(firstFrame);
+      }
+    };
+  }, [data]);
+
+  if (loading || !data) {
+    return (
+      <div className="flex items-center justify-center h-full">
+        <p className="text-sm text-[var(--muted-foreground)]">Loading analytics...</p>
+      </div>
+    );
+  }
+
+  const { tokens } = data;
+  const totalTokens = tokens.totalInputTokens + tokens.totalOutputTokens;
+  const cacheTokens = tokens.totalCacheReadTokens + tokens.totalCacheWriteTokens;
+
+  return (
+    <div className="p-6 space-y-6">
+      <div>
+        <h1 className="text-xl font-bold text-[var(--foreground)]">Analytics</h1>
+        <p className="text-sm text-[var(--muted-foreground)]">Token usage, event metrics, and activity trends</p>
+      </div>
+
+      <div className="grid grid-cols-4 gap-4">
+        <MetricCard label="Total Tokens" value={totalTokens.toLocaleString()} detail={`${data.totalSessions} sessions`} icon={Coins} />
+        <MetricCard label="Input Tokens" value={tokens.totalInputTokens.toLocaleString()} icon={ArrowDownToLine} />
+        <MetricCard label="Output Tokens" value={tokens.totalOutputTokens.toLocaleString()} icon={ArrowUpFromLine} />
+        <MetricCard label="Cache Saved" value={cacheTokens.toLocaleString()} detail={totalTokens > 0 ? `${Math.round((cacheTokens / (totalTokens + cacheTokens)) * 100)}% cache rate` : undefined} icon={DatabaseZap} />
+      </div>
+
+      {showDetails ? (
+        <Suspense fallback={<AnalyticsDetailsFallback />}>
+          <AnalyticsDetails data={data} />
+        </Suspense>
+      ) : (
+        <AnalyticsDetailsFallback />
+      )}
+    </div>
+  );
+}
diff --git a/apps/desktop/src/renderer/components/approvals/ApprovalsPanel.tsx b/apps/desktop/src/renderer/components/approvals/ApprovalsPanel.tsx
new file mode 100644
index 00000000..f31ced97
--- /dev/null
+++ b/apps/desktop/src/renderer/components/approvals/ApprovalsPanel.tsx
@@ -0,0 +1,109 @@
+import { useState, useEffect, useCallback } from "react";
+import { Button } from "@closedloop-ai/design-system/components/ui/button";
+import { Badge } from "@closedloop-ai/design-system/components/ui/badge";
+import { Card, CardContent } from "@closedloop-ai/design-system/components/ui/card";
+
+interface Approval {
+  id: string;
+  reason: string;
+  request?: { path?: string; args?: Record<string, unknown> };
+  tier?: string;
+  createdAt?: string;
+}
+
+export function ApprovalsPanel() {
+  const [approvals, setApprovals] = useState<Approval[]>([]);
+  const [loading, setLoading] = useState(true);
+
+  const load = useCallback(async () => {
+    setLoading(true);
+    try {
+      const data = await window.desktopApi.getPendingApprovals();
+      setApprovals(data as Approval[]);
+    } catch { /* ignore */ }
+    setLoading(false);
+  }, []);
+
+  useEffect(() => {
+    load();
+    const interval = setInterval(load, 3000);
+    return () => clearInterval(interval);
+  }, [load]);
+
+  const handleApprove = async (id: string) => {
+    try {
+      await window.desktopApi.approveApproval(id);
+    } catch { /* reload will pick up current state */ }
+    await load();
+  };
+  const handleDeny = async (id: string) => {
+    try {
+      await window.desktopApi.denyApproval(id);
+    } catch { /* reload will pick up current state */ }
+    await load();
+  };
+  const handleAlwaysAllow = async (id: string) => {
+    try {
+      await window.desktopApi.alwaysAllowApproval(id);
+    } catch { /* reload will pick up current state */ }
+    await load();
+  };
+  const handleClear = async () => {
+    try {
+      await window.desktopApi.clearPendingApprovals();
+    } catch { /* reload will pick up current state */ }
+    await load();
+  };
+
+  return (
+    <div className="p-6 space-y-4">
+      <div className="flex items-center justify-between">
+        <div>
+          <h2 className="text-lg font-semibold text-[var(--foreground)]">Approvals</h2>
+          <p className="text-sm text-[var(--muted-foreground)]">Pending requests that need approval</p>
+        </div>
+        <div className="flex gap-2">
+          <Button variant="outline" size="sm" onClick={load}>Refresh</Button>
+          <Button variant="outline" size="sm" onClick={handleClear}>Clear Queue</Button>
+        </div>
+      </div>
+
+      {loading ? (
+        <div className="flex items-center justify-center py-12">
+          <p className="text-sm text-[var(--muted-foreground)]">Loading approvals...</p>
+        </div>
+      ) : approvals.length === 0 ? (
+        <Card>
+          <CardContent className="py-12 text-center text-sm text-[var(--muted-foreground)]">
+            No pending approvals
+          </CardContent>
+        </Card>
+      ) : (
+        <div className="space-y-3">
+          {approvals.map((a) => (
+            <Card key={a.id}>
+              <CardContent className="pt-4">
+                <div className="space-y-2">
+                  <div className="flex items-start justify-between gap-4">
+                    <div className="min-w-0 flex-1 space-y-1">
+                      <p className="text-sm font-medium">{a.reason}</p>
+                      {a.request?.path && (
+                        <p className="text-xs font-mono text-[var(--muted-foreground)] break-all">{a.request.path}</p>
+                      )}
+                    </div>
+                    <Badge variant="outline">{a.tier ?? "unknown"}</Badge>
+                  </div>
+                  <div className="flex gap-2 pt-1">
+                    <Button size="sm" onClick={() => handleApprove(a.id)}>Approve</Button>
+                    <Button size="sm" variant="outline" onClick={() => handleDeny(a.id)}>Deny</Button>
+                    <Button size="sm" variant="secondary" onClick={() => handleAlwaysAllow(a.id)}>Always Allow</Button>
+                  </div>
+                </div>
+              </CardContent>
+            </Card>
+          ))}
+        </div>
+      )}
+    </div>
+  );
+}
diff --git a/apps/desktop/src/renderer/components/dashboard/DashboardPage.tsx b/apps/desktop/src/renderer/components/dashboard/DashboardPage.tsx
new file mode 100644
index 00000000..f98f5896
--- /dev/null
+++ b/apps/desktop/src/renderer/components/dashboard/DashboardPage.tsx
@@ -0,0 +1,54 @@
+import { MetricCard } from "@closedloop-ai/design-system/components/ui/primitives/metric-card";
+import { MonitorDot, Bot, Zap, Layers } from "lucide-react";
+import { useQueryCache } from "../../hooks/useQueryCache";
+import { SessionsView } from "../sessions/SessionsView";
+import type { DashboardSummary } from "../../../shared/agent-db-contract";
+
+const SUMMARY_CARD_CLASS_NAME =
+  "min-h-0 rounded-xl border-border/70 bg-card shadow-sm [&>div:first-child]:px-5 [&>div:first-child]:pt-4 [&>div:first-child]:pb-2 [&_[data-slot='card-description']]:text-[10px] [&_[data-slot='card-title']]:text-[1.7rem] [&>div:last-child]:px-5 [&>div:last-child]:pb-4 [&>div:last-child]:text-xs";
+
+export function DashboardPage() {
+  const { data: summary, error } = useQueryCache<DashboardSummary>(
+    "db:summary",
+    () => window.desktopApi.db.getDashboardSummary(),
+    3_000, 5_000,
+  );
+
+  if (error) {
+    return (
+      <div className="flex items-center justify-center py-16">
+        <p className="text-[var(--destructive)]">Failed to load data.</p>
+      </div>
+    );
+  }
+
+  if (!summary) {
+    return (
+      <div className="flex items-center justify-center py-16">
+        <p className="text-[var(--muted-foreground)]">Loading...</p>
+      </div>
+    );
+  }
+
+  return (
+    <div className="h-full overflow-auto">
+      <div className="mx-auto flex w-full max-w-[1500px] flex-col gap-6 p-6">
+        <section className="space-y-1">
+          <h1 className="text-[1.8rem] font-semibold tracking-tight text-[var(--foreground)]">Sessions</h1>
+          <p className="text-sm text-[var(--muted-foreground)]">
+            High-level loop volume and direct access to the session explorer.
+          </p>
+        </section>
+
+        <div className="grid grid-cols-1 gap-3 sm:grid-cols-2 xl:grid-cols-4">
+          <MetricCard className={SUMMARY_CARD_CLASS_NAME} label="Sessions" value={summary.totalSessions} detail={`${summary.activeSessions} active`} icon={MonitorDot} />
+          <MetricCard className={SUMMARY_CARD_CLASS_NAME} label="Agents" value={summary.totalAgents} icon={Bot} />
+          <MetricCard className={SUMMARY_CARD_CLASS_NAME} label="Events" value={summary.totalEvents} icon={Zap} />
+          <MetricCard className={SUMMARY_CARD_CLASS_NAME} label="Event Types" value={summary.eventTypeCount} icon={Layers} />
+        </div>
+
+        <SessionsView showOverview={false} />
+      </div>
+    </div>
+  );
+}
diff --git a/apps/desktop/src/renderer/components/feed/ActivityFeedView.tsx b/apps/desktop/src/renderer/components/feed/ActivityFeedView.tsx
new file mode 100644
index 00000000..a2464e5d
--- /dev/null
+++ b/apps/desktop/src/renderer/components/feed/ActivityFeedView.tsx
@@ -0,0 +1,172 @@
+import { useState, useEffect, useCallback, useMemo } from "react";
+import { Button } from "@closedloop-ai/design-system/components/ui/button";
+import { Badge } from "@closedloop-ai/design-system/components/ui/badge";
+import { MetricCard } from "@closedloop-ai/design-system/components/ui/primitives/metric-card";
+import { Zap, Wrench, AlertCircle, Layers } from "lucide-react";
+import type { EventRow } from "../../../shared/agent-db-contract";
+
+const EVENT_TYPE_TONES: Record<string, string> = {
+  tool_use: "bg-blue-500/10 text-blue-600",
+  tool_result: "bg-green-500/10 text-green-600",
+  error: "bg-red-500/10 text-red-600",
+  thinking: "bg-yellow-500/10 text-yellow-700",
+  text: "bg-zinc-500/10 text-zinc-600",
+};
+
+function eventTypeColor(eventType: string): string {
+  return EVENT_TYPE_TONES[eventType] ?? "bg-zinc-500/10 text-zinc-600";
+}
+
+interface EventWithSession extends EventRow {
+  sessionName: string | null;
+}
+
+export function ActivityFeedView() {
+  const [events, setEvents] = useState<EventWithSession[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [paused, setPaused] = useState(false);
+  const [search, setSearch] = useState("");
+  const [typeFilter, setTypeFilter] = useState<string>("all");
+  const [expandedId, setExpandedId] = useState<string | null>(null);
+
+  const load = useCallback(() => {
+    if (paused) return;
+    window.desktopApi.db
+      .getEventFeed()
+      .then((data) => setEvents(data as EventWithSession[]))
+      .catch(() => {});
+  }, [paused]);
+
+  useEffect(() => {
+    load();
+    setLoading(false);
+  }, [load]);
+
+  useEffect(() => {
+    if (paused) return;
+    const interval = setInterval(load, 5000);
+    return () => clearInterval(interval);
+  }, [load, paused]);
+
+  const eventTypes = useMemo(() => {
+    const types = new Set(events.map((e) => e.eventType));
+    return Array.from(types).sort();
+  }, [events]);
+
+  const filtered = useMemo(() => {
+    let result = events;
+    if (typeFilter !== "all") {
+      result = result.filter((e) => e.eventType === typeFilter);
+    }
+    if (search) {
+      const q = search.toLowerCase();
+      result = result.filter(
+        (e) =>
+          (e.summary ?? "").toLowerCase().includes(q) ||
+          (e.toolName ?? "").toLowerCase().includes(q) ||
+          (e.sessionName ?? "").toLowerCase().includes(q),
+      );
+    }
+    return result;
+  }, [events, typeFilter, search]);
+
+  const toolCount = events.filter((e) => e.eventType === "tool_use" || e.eventType === "tool_result").length;
+  const errorCount = events.filter((e) => e.eventType === "error").length;
+
+  if (loading) {
+    return (
+      <div className="flex items-center justify-center h-full">
+        <p className="text-sm text-[var(--muted-foreground)]">Loading activity feed...</p>
+      </div>
+    );
+  }
+
+  return (
+    <div className="p-6 space-y-6">
+      <div className="flex items-center justify-between">
+        <div>
+          <h1 className="text-xl font-bold text-[var(--foreground)]">Activity Feed</h1>
+          <p className="text-sm text-[var(--muted-foreground)]">
+            Real-time agent event stream
+          </p>
+        </div>
+        <Button
+          variant={paused ? "default" : "outline"}
+          size="sm"
+          onClick={() => setPaused((p) => !p)}
+        >
+          {paused ? "Resume" : "Pause"}
+        </Button>
+      </div>
+
+      <div className="grid grid-cols-4 gap-4">
+        <MetricCard label="Events" value={events.length} icon={Zap} />
+        <MetricCard label="Tool Calls" value={toolCount} icon={Wrench} />
+        <MetricCard label="Errors" value={errorCount} icon={AlertCircle} />
+        <MetricCard label="Types" value={eventTypes.length} icon={Layers} />
+      </div>
+
+      <div className="flex items-center gap-3">
+        <input
+          type="text"
+          value={search}
+          onChange={(e) => setSearch(e.target.value)}
+          placeholder="Search events..."
+          className="flex-1 bg-[var(--input)] border border-[var(--input-border)] rounded-md px-3 py-1.5 text-sm text-[var(--foreground)] placeholder:text-[var(--muted-foreground)]"
+        />
+        <select
+          value={typeFilter}
+          onChange={(e) => setTypeFilter(e.target.value)}
+          className="bg-[var(--input)] border border-[var(--input-border)] rounded-md px-3 py-1.5 text-sm text-[var(--foreground)]"
+        >
+          <option value="all">All types</option>
+          {eventTypes.map((t) => (
+            <option key={t} value={t}>{t}</option>
+          ))}
+        </select>
+      </div>
+
+      <div className="space-y-1">
+        {filtered.length === 0 && (
+          <div className="py-12 text-center text-sm text-[var(--muted-foreground)]">
+            {search || typeFilter !== "all" ? "No events match the current filters." : "No events recorded yet."}
+          </div>
+        )}
+        {filtered.map((event) => (
+          <div key={event.id}>
+            <div
+              className="flex items-start gap-3 rounded-lg border p-3 text-sm cursor-pointer hover:bg-[var(--accent)]"
+              onClick={() => setExpandedId(expandedId === event.id ? null : event.id)}
+            >
+              <span
+                className={`mt-0.5 shrink-0 rounded px-1.5 py-0.5 text-[10px] font-medium uppercase ${eventTypeColor(event.eventType)}`}
+              >
+                {event.eventType.replace(/_/g, " ").slice(0, 12)}
+              </span>
+              <div className="min-w-0 flex-1 space-y-0.5">
+                {event.summary && (
+                  <p className="truncate text-[var(--foreground)]">{event.summary}</p>
+                )}
+                <div className="flex flex-wrap gap-x-3 gap-y-0.5 text-[11px] text-[var(--muted-foreground)]">
+                  {event.sessionName && <span>{event.sessionName}</span>}
+                  {event.toolName && <span className="font-mono">{event.toolName}</span>}
+                  {event.createdAt && <span>{new Date(event.createdAt).toLocaleTimeString()}</span>}
+                </div>
+              </div>
+              {event.toolName && (
+                <Badge variant="outline" className="shrink-0 text-[10px]">{event.toolName}</Badge>
+              )}
+            </div>
+            {expandedId === event.id && event.data && (
+              <div className="ml-10 mt-1 mb-2 p-3 bg-[var(--muted)] rounded text-xs font-mono overflow-auto max-h-48">
+                <pre className="whitespace-pre-wrap break-all text-[var(--foreground)]">
+                  {(() => { try { return JSON.stringify(JSON.parse(event.data), null, 2); } catch { return event.data; } })()}
+                </pre>
+              </div>
+            )}
+          </div>
+        ))}
+      </div>
+    </div>
+  );
+}
diff --git a/apps/desktop/src/renderer/components/kanban/KanbanView.tsx b/apps/desktop/src/renderer/components/kanban/KanbanView.tsx
new file mode 100644
index 00000000..81f532b4
--- /dev/null
+++ b/apps/desktop/src/renderer/components/kanban/KanbanView.tsx
@@ -0,0 +1,121 @@
+import { useState } from "react";
+import { KanbanBoardLayout, KanbanColumn, KanbanCardFrame } from "@closedloop-ai/design-system/components/ui/layout/kanban-board";
+import { Badge } from "@closedloop-ai/design-system/components/ui/badge";
+import { useQueryCache } from "../../hooks/useQueryCache";
+import type { SessionWithAgents } from "../../../shared/agent-db-contract";
+
+function PlayIcon() { return <span className="text-blue-400 text-xs">&#9654;</span>; }
+function ClockIcon() { return <span className="text-yellow-400 text-xs">&#9201;</span>; }
+function CheckIcon() { return <span className="text-green-400 text-xs">&#10003;</span>; }
+function XIcon() { return <span className="text-red-400 text-xs">&#10007;</span>; }
+function StopIcon() { return <span className="text-zinc-400 text-xs">&#9632;</span>; }
+
+const COLUMNS = [
+  { key: "running", label: "Running", icon: PlayIcon(), color: "text-blue-400" },
+  { key: "waiting", label: "Waiting", icon: ClockIcon(), color: "text-yellow-400" },
+  { key: "completed", label: "Completed", icon: CheckIcon(), color: "text-green-400" },
+  { key: "failed", label: "Failed", icon: XIcon(), color: "text-red-400" },
+  { key: "stopped", label: "Stopped", icon: StopIcon(), color: "text-zinc-400" },
+];
+
+export function KanbanView() {
+  const { data: sessions, loading } = useQueryCache<SessionWithAgents[]>(
+    "db:sessions-details",
+    () => window.desktopApi.db.getSessionsWithDetails() as Promise<SessionWithAgents[]>,
+  );
+  const [selectedId, setSelectedId] = useState<string | null>(null);
+
+  if (loading || !sessions) {
+    return (
+      <div className="flex items-center justify-center h-full">
+        <p className="text-sm text-[var(--muted-foreground)]">Loading...</p>
+      </div>
+    );
+  }
+
+  const grouped: Record<string, SessionWithAgents[]> = {};
+  for (const col of COLUMNS) {
+    grouped[col.key] = sessions.filter((s) => s.status === col.key);
+  }
+
+  const uncategorized = sessions.filter(
+    (s) => !COLUMNS.some((c) => c.key === s.status),
+  );
+
+  return (
+    <div className="p-6 h-full flex flex-col">
+      <div className="mb-4">
+        <h1 className="text-xl font-bold text-[var(--foreground)]">My Tasks</h1>
+
+        <p className="text-sm text-[var(--muted-foreground)]">
+          Sessions grouped by status
+        </p>
+      </div>
+
+      <div className="flex-1 overflow-auto">
+        <KanbanBoardLayout>
+          {COLUMNS.map((col) => {
+            const items = grouped[col.key] ?? [];
+            return (
+              <KanbanColumn
+                key={col.key}
+                title={col.label}
+                count={items.length}
+                icon={col.icon}
+                emptyState={
+                  <div className="py-6 text-center text-xs text-[var(--muted-foreground)]">
+                    No {col.label.toLowerCase()} sessions
+                  </div>
+                }
+              >
+                {items.map((session) => (
+                  <KanbanCardFrame
+                    key={session.id}
+                    active={session.id === selectedId}
+                  >
+                    <button
+                      className="w-full text-left"
+                      onClick={() => setSelectedId(selectedId === session.id ? null : session.id)}
+                    >
+                      <p className="truncate text-sm font-medium text-[var(--foreground)]">
+                        {session.name ?? "Unnamed"}
+                      </p>
+                      {session.model && (
+                        <p className="truncate text-xs text-[var(--muted-foreground)] mt-0.5">
+                          {session.model}
+                        </p>
+                      )}
+                      <div className="flex items-center gap-2 mt-1.5">
+                        <span className="text-[11px] text-[var(--muted-foreground)]">
+                          {session.agentCount} agents
+                        </span>
+                        <span className="text-[11px] text-[var(--muted-foreground)]">
+                          {session.totalTokens.toLocaleString()} tokens
+                        </span>
+                      </div>
+                    </button>
+                  </KanbanCardFrame>
+                ))}
+              </KanbanColumn>
+            );
+          })}
+
+          {uncategorized.length > 0 && (
+            <KanbanColumn
+              title="Other"
+              count={uncategorized.length}
+              emptyState={null}
+            >
+              {uncategorized.map((session) => (
+                <KanbanCardFrame key={session.id}>
+                  <p className="truncate text-sm font-medium">{session.name ?? "Unnamed"}</p>
+                  <Badge variant="secondary">{session.status}</Badge>
+                </KanbanCardFrame>
+              ))}
+            </KanbanColumn>
+          )}
+        </KanbanBoardLayout>
+      </div>
+    </div>
+  );
+}
diff --git a/apps/desktop/src/renderer/components/layout/Sidebar.tsx b/apps/desktop/src/renderer/components/layout/Sidebar.tsx
new file mode 100644
index 00000000..a4b8bd1b
--- /dev/null
+++ b/apps/desktop/src/renderer/components/layout/Sidebar.tsx
@@ -0,0 +1,121 @@
+import type { NavId } from "../../App";
+
+interface NavItem {
+  id: NavId;
+  label: string;
+  icon: string;
+  section: "agent" | "gateway";
+}
+
+const NAV_ITEMS: NavItem[] = [
+  { id: "kanban", label: "My Tasks", icon: "kanban", section: "agent" },
+  { id: "dashboard", label: "Sessions", icon: "dashboard", section: "agent" },
+  { id: "activity", label: "Activity", icon: "activity", section: "agent" },
+  { id: "analytics", label: "Analytics", icon: "analytics", section: "agent" },
+  { id: "workflows", label: "Workflows", icon: "workflows", section: "agent" },
+  { id: "approvals", label: "Approvals", icon: "shield", section: "gateway" },
+  { id: "requests", label: "Requests", icon: "inbox", section: "gateway" },
+  { id: "diagnostics", label: "Diagnostics", icon: "stethoscope", section: "gateway" },
+  { id: "settings", label: "Settings", icon: "settings", section: "gateway" },
+];
+
+const SVG_ICONS: Record<string, string> = {
+  dashboard: '<rect width="7" height="9" x="3" y="3" rx="1"/><rect width="7" height="5" x="14" y="3" rx="1"/><rect width="7" height="9" x="14" y="12" rx="1"/><rect width="7" height="5" x="3" y="16" rx="1"/>',
+  kanban: '<rect width="18" height="18" x="3" y="3" rx="2"/><path d="M9 3v18"/><path d="M15 3v18"/>',
+  sessions: '<path d="m7 11 2-2-2-2"/><path d="M11 13h4"/><rect width="18" height="18" x="3" y="3" rx="2" ry="2"/>',
+  activity: '<path d="M22 12h-2.48a2 2 0 0 0-1.93 1.46l-2.35 8.36a.25.25 0 0 1-.48 0L9.24 2.18a.25.25 0 0 0-.48 0l-2.35 8.36A2 2 0 0 1 4.49 12H2"/>',
+  analytics: '<path d="M3 3v16a2 2 0 0 0 2 2h16"/><path d="M18 17V9"/><path d="M13 17V5"/><path d="M8 17v-3"/>',
+  workflows: '<rect width="8" height="8" x="3" y="3" rx="2"/><path d="M7 11v4a2 2 0 0 0 2 2h4"/><rect width="8" height="8" x="13" y="13" rx="2"/>',
+  shield: '<path d="M20 13c0 5-3.5 7.5-7.66 8.95a1 1 0 0 1-.67-.01C7.5 20.5 4 18 4 13V6a1 1 0 0 1 1-1c2 0 4.5-1.2 6.24-2.72a1.17 1.17 0 0 1 1.52 0C14.51 3.81 17 5 19 5a1 1 0 0 1 1 1z"/><path d="m9 12 2 2 4-4"/>',
+  inbox: '<polyline points="22 12 16 12 14 15 10 15 8 12 2 12"/><path d="M5.45 5.11 2 12v6a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-6l-3.45-6.89A2 2 0 0 0 16.76 4H7.24a2 2 0 0 0-1.79 1.11z"/>',
+  stethoscope: '<path d="M11 2v2"/><path d="M5 2v2"/><path d="M5 3H4a2 2 0 0 0-2 2v4a6 6 0 0 0 12 0V5a2 2 0 0 0-2-2h-1"/><path d="M8 15a6 6 0 0 0 12 0v-3"/><circle cx="20" cy="10" r="2"/>',
+  settings: '<path d="M12.22 2h-.44a2 2 0 0 0-2 2v.18a2 2 0 0 1-1 1.73l-.43.25a2 2 0 0 1-2 0l-.15-.08a2 2 0 0 0-2.73.73l-.22.38a2 2 0 0 0 .73 2.73l.15.1a2 2 0 0 1 1 1.72v.51a2 2 0 0 1-1 1.74l-.15.09a2 2 0 0 0-.73 2.73l.22.38a2 2 0 0 0 2.73.73l.15-.08a2 2 0 0 1 2 0l.43.25a2 2 0 0 1 1 1.73V20a2 2 0 0 0 2 2h.44a2 2 0 0 0 2-2v-.18a2 2 0 0 1 1-1.73l.43-.25a2 2 0 0 1 2 0l.15.08a2 2 0 0 0 2.73-.73l.22-.39a2 2 0 0 0-.73-2.73l-.15-.08a2 2 0 0 1-1-1.74v-.5a2 2 0 0 1 1-1.74l.15-.09a2 2 0 0 0 .73-2.73l-.22-.38a2 2 0 0 0-2.73-.73l-.15.08a2 2 0 0 1-2 0l-.43-.25a2 2 0 0 1-1-1.73V4a2 2 0 0 0-2-2z"/><circle cx="12" cy="12" r="3"/>',
+};
+
+function NavIcon({ name }: { name: string }) {
+  const paths = SVG_ICONS[name] || "";
+  return (
+    <span className="shrink-0 size-[18px] text-current opacity-70">
+      <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" className="size-full">
+        <g dangerouslySetInnerHTML={{ __html: paths }} />
+      </svg>
+    </span>
+  );
+}
+
+interface SidebarProps {
+  collapsed: boolean;
+  activeNav: NavId;
+  onNavigate: (id: NavId) => void;
+  runtimeHealthy: boolean;
+}
+
+export function Sidebar({ collapsed, activeNav, onNavigate, runtimeHealthy }: SidebarProps) {
+  const agentItems = NAV_ITEMS.filter((i) => i.section === "agent");
+  const gatewayItems = NAV_ITEMS.filter((i) => i.section === "gateway");
+
+  const navWidth = collapsed ? "w-[52px]" : "w-[200px]";
+
+  return (
+    <aside className={`${navWidth} flex flex-col border-r bg-[var(--sidebar)] text-[var(--sidebar-foreground)] transition-all duration-200`}>
+      <div className="flex items-center gap-2 h-12 px-3 border-b shrink-0">
+        <svg viewBox="0 0 100 100" fill="none" className="size-5 shrink-0 text-[var(--primary)]">
+          <path d="M0.424623 49.6765C0.339767 56.2176 1.55939 62.7103 4.01272 68.7779C6.46604 74.8455 10.1042 80.3673 14.7161 85.0227C19.3281 89.6781 24.8219 93.3744 30.8788 95.8973C36.9358 98.4202 43.4352 99.7193 50 99.7193C56.5648 99.7193 63.0643 98.4202 69.1212 95.8973C75.1782 93.3744 80.672 89.6781 85.2839 85.0227C89.8958 80.3673 93.534 74.8455 95.9873 68.7779C98.4406 62.7103 99.6603 56.2176 99.5754 49.6765C99.5754 49.5115 99.5754 49.3546 99.5754 49.1895H71.7496C71.7496 49.3546 71.7496 49.5115 71.7496 49.6765C71.7496 53.9658 70.473 58.1587 68.0814 61.7249C65.6898 65.2912 62.2906 68.0706 58.3136 69.7117C54.3367 71.3527 49.9606 71.7817 45.739 70.9443C41.5174 70.1069 37.6398 68.0408 34.5966 65.0072C31.5535 61.9737 29.4815 58.109 28.6428 53.902C27.804 49.695 28.2361 45.3346 29.8845 41.3723C31.5329 37.4101 34.3235 34.0239 37.9033 31.6421C41.4831 29.2603 45.6914 27.9899 49.9959 27.9915H50.0704L50.0373 0.280626C43.524 0.275203 37.0735 1.54886 31.0545 4.02881C25.0354 6.50876 19.5659 10.1464 14.9583 14.7338C10.3508 19.3211 6.69575 24.7683 4.20197 30.764C1.70819 36.7597 0.424621 43.1863 0.424623 49.6765Z" fill="currentColor" />
+          <path d="M57.1534 0.801147V29.2137C60.1811 30.2616 62.939 31.9629 65.2303 34.1961C67.5215 36.4293 69.2895 39.1392 70.4077 42.1323H99.004C97.3792 31.6897 92.4381 22.0411 84.906 14.6024C77.3738 7.16375 67.6471 2.32669 57.1534 0.801147Z" fill="#41A3FF" />
+        </svg>
+        {!collapsed && <span className="text-sm font-semibold truncate">ClosedLoop Gateway</span>}
+      </div>
+
+      <nav className="flex-1 overflow-y-auto py-2 px-1.5 space-y-1">
+        {collapsed ? null : (
+          <div className="text-[10px] font-semibold uppercase tracking-wider text-[var(--muted-foreground)] px-2 pb-1">Agents</div>
+        )}
+        {agentItems.map((item) => (
+          <button
+            key={item.id}
+            type="button"
+            onClick={() => onNavigate(item.id)}
+            className={`w-full flex items-center gap-2.5 px-2 py-1.5 rounded-md text-sm transition-colors ${
+              activeNav === item.id
+                ? "bg-[var(--sidebar-accent)] text-[var(--sidebar-accent-foreground)] font-medium"
+                : "text-[var(--sidebar-foreground)] hover:bg-[var(--sidebar-accent)]/60"
+            }`}
+            title={item.label}
+          >
+            <NavIcon name={item.icon} />
+            {!collapsed && <span className="truncate">{item.label}</span>}
+          </button>
+        ))}
+
+        {collapsed ? (
+          <div className="border-t my-2" />
+        ) : (
+          <div className="text-[10px] font-semibold uppercase tracking-wider text-[var(--muted-foreground)] px-2 pt-3 pb-1">Gateway</div>
+        )}
+        {gatewayItems.map((item) => (
+          <button
+            key={item.id}
+            type="button"
+            onClick={() => onNavigate(item.id)}
+            className={`w-full flex items-center gap-2.5 px-2 py-1.5 rounded-md text-sm transition-colors ${
+              activeNav === item.id
+                ? "bg-[var(--sidebar-accent)] text-[var(--sidebar-accent-foreground)] font-medium"
+                : "text-[var(--sidebar-foreground)] hover:bg-[var(--sidebar-accent)]/60"
+            }`}
+            title={item.label}
+          >
+            <NavIcon name={item.icon} />
+            {!collapsed && <span className="truncate">{item.label}</span>}
+          </button>
+        ))}
+      </nav>
+
+      <div className="border-t px-2 py-2 shrink-0">
+        <div className="flex items-center gap-2 text-xs text-[var(--muted-foreground)]">
+          <span className={`size-2 rounded-full ${runtimeHealthy ? "bg-[var(--success)]" : "bg-[var(--destructive)]"}`} />
+          {!collapsed && <span className="truncate">{runtimeHealthy ? "Healthy" : "Unhealthy"}</span>}
+        </div>
+      </div>
+    </aside>
+  );
+}
diff --git a/apps/desktop/src/renderer/components/layout/Topbar.tsx b/apps/desktop/src/renderer/components/layout/Topbar.tsx
new file mode 100644
index 00000000..1e89affa
--- /dev/null
+++ b/apps/desktop/src/renderer/components/layout/Topbar.tsx
@@ -0,0 +1,57 @@
+interface TopbarProps {
+  collapsed: boolean;
+  onToggleSidebar: () => void;
+  navId: string;
+  runtimeStatus: Record<string, unknown> | null;
+}
+
+const NAV_LABELS: Record<string, string> = {
+  dashboard: "Sessions",
+  kanban: "My Tasks",
+  activity: "Activity",
+  analytics: "Analytics",
+  workflows: "Workflows",
+  approvals: "Approvals",
+  requests: "Requests",
+  diagnostics: "Diagnostics",
+  settings: "Settings",
+};
+
+export function Topbar({ collapsed, onToggleSidebar, navId, runtimeStatus }: TopbarProps) {
+  const section = ["approvals", "requests", "diagnostics", "settings"].includes(navId)
+    ? "Gateway"
+    : "Agents";
+  const label = NAV_LABELS[navId] ?? navId;
+
+  return (
+    <header className="flex items-center gap-3 h-12 px-3 border-b shrink-0 bg-[var(--card)]">
+      <button
+        type="button"
+        onClick={onToggleSidebar}
+        className="p-1 rounded hover:bg-[var(--accent)] text-[var(--muted-foreground)]"
+        title={collapsed ? "Expand sidebar" : "Collapse sidebar"}
+      >
+        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" className="size-4">
+          <rect width="18" height="18" x="3" y="3" rx="2" />
+          <path d="M9 3v18" />
+        </svg>
+      </button>
+
+      <div className="flex items-center gap-2 text-sm">
+        <span className="text-[var(--muted-foreground)]">{section}</span>
+        <span className="text-[var(--muted-foreground)]">/</span>
+        <span className="font-medium">{label}</span>
+      </div>
+
+      <div className="flex-1" />
+
+      <div className="flex items-center gap-3 text-xs">
+        {runtimeStatus && (
+          <span className="text-[var(--muted-foreground)]">
+            Port: {(runtimeStatus as Record<string, unknown>).port as string ?? "..."}
+          </span>
+        )}
+      </div>
+    </header>
+  );
+}
diff --git a/apps/desktop/src/renderer/components/logs/LogsPanel.tsx b/apps/desktop/src/renderer/components/logs/LogsPanel.tsx
new file mode 100644
index 00000000..93977cc7
--- /dev/null
+++ b/apps/desktop/src/renderer/components/logs/LogsPanel.tsx
@@ -0,0 +1,133 @@
+import { useState, useEffect, useRef, useCallback } from "react";
+import { Button } from "@closedloop-ai/design-system/components/ui/button";
+import { Card, CardContent } from "@closedloop-ai/design-system/components/ui/card";
+
+interface LogEntry {
+  timestamp?: string;
+  level?: string;
+  message?: string;
+  text?: string;
+}
+
+export function LogsPanel() {
+  const [entries, setEntries] = useState<LogEntry[]>([]);
+  const [verbose, setVerbose] = useState(false);
+  const [paused, setPaused] = useState(false);
+  const containerRef = useRef<HTMLDivElement>(null);
+  const autoScroll = useRef(true);
+
+  const load = useCallback(async () => {
+    try {
+      const data = await window.desktopApi.getLogs();
+      const raw = (data as LogEntry[]) ?? [];
+      setEntries(raw);
+    } catch { /* ignore */ }
+  }, []);
+
+  useEffect(() => { load(); }, [load]);
+
+  useEffect(() => {
+    if (paused) return;
+    const interval = setInterval(load, 3000);
+    return () => clearInterval(interval);
+  }, [paused, load]);
+
+  const handleScroll = () => {
+    if (!containerRef.current) return;
+    const { scrollTop, scrollHeight, clientHeight } = containerRef.current;
+    autoScroll.current = scrollHeight - scrollTop - clientHeight < 50;
+  };
+
+  useEffect(() => {
+    if (autoScroll.current && containerRef.current) {
+      containerRef.current.scrollTop = containerRef.current.scrollHeight;
+    }
+  }, [entries]);
+
+  const handleClear = async () => {
+    await window.desktopApi.clearLogs();
+    await load();
+  };
+
+  const handleOpenFile = async () => {
+    await window.desktopApi.openLogFile();
+  };
+
+  const filtered = verbose ? entries : entries.filter((e) => {
+    const msg = e.message ?? e.text ?? "";
+    return !msg.startsWith("[debug") && !msg.startsWith("[trace");
+  });
+
+  const levelColor = (level?: string) => {
+    if (!level) return "";
+    const l = level.toLowerCase();
+    if (l === "error" || l === "fatal") return "text-[var(--destructive)]";
+    if (l === "warn" || l === "warning") return "text-[var(--warning)]";
+    if (l === "info") return "text-[var(--info)]";
+    return "text-[var(--muted-foreground)]";
+  };
+
+  return (
+    <div className="p-6 space-y-4">
+      <div className="flex items-center justify-between">
+        <h2 className="text-lg font-semibold text-[var(--foreground)]">Diagnostics</h2>
+      </div>
+
+      <Card>
+        <CardContent className="pt-4">
+          <div className="flex items-center gap-2 mb-3">
+            <label className="flex items-center gap-2 text-sm cursor-pointer">
+              <input type="checkbox" checked={verbose} onChange={(e) => setVerbose(e.target.checked)} className="rounded" />
+              Verbose
+            </label>
+            <div className="flex-1" />
+            <Button variant="ghost" size="sm" onClick={load} title="Refresh">
+              <svg viewBox="0 0 16 16" fill="none" stroke="currentColor" strokeWidth="1.8" className="size-3.5">
+                <path d="M1.5 1.5v4.5h4.5"/><path d="M2.3 10a6 6 0 1 0 .9-4.8L1.5 6"/>
+              </svg>
+            </Button>
+            <Button variant="ghost" size="sm" onClick={() => setPaused((p) => !p)} title={paused ? "Resume" : "Pause"}>
+              {paused ? "▶" : "⏸"}
+            </Button>
+            <Button variant="ghost" size="sm" onClick={handleOpenFile} title="Open log file">
+              <svg viewBox="0 0 16 16" fill="none" stroke="currentColor" strokeWidth="1.6" className="size-3.5">
+                <path d="M9 2H4.5A1.5 1.5 0 0 0 3 3.5v9A1.5 1.5 0 0 0 4.5 14h7a1.5 1.5 0 0 0 1.5-1.5V6"/><path d="M9 2v4h4"/><path d="M6 10h4"/>
+              </svg>
+            </Button>
+            <Button variant="ghost" size="sm" onClick={handleClear} title="Clear logs">
+              <svg viewBox="0 0 16 16" fill="none" stroke="currentColor" strokeWidth="1.8" className="size-3.5">
+                <line x1="2" y1="2" x2="14" y2="14"/><line x1="14" y1="2" x2="2" y2="14"/>
+              </svg>
+            </Button>
+          </div>
+
+          {paused && (
+            <div className="text-xs text-[var(--warning)] mb-2 px-2 py-1 rounded bg-[var(--warning)]/10">Paused</div>
+          )}
+
+          <div
+            ref={containerRef}
+            onScroll={handleScroll}
+            className="max-h-[60vh] overflow-y-auto font-mono text-xs leading-relaxed space-y-0.5"
+          >
+            {filtered.length === 0 ? (
+              <p className="text-[var(--muted-foreground)] py-4 text-center">No log entries</p>
+            ) : (
+              filtered.slice(-500).map((e, i) => {
+                const msg = e.message ?? e.text ?? "";
+                const time = e.timestamp ? new Date(e.timestamp).toLocaleTimeString() : "";
+                return (
+                  <div key={i} className="flex gap-2">
+                    <span className="shrink-0 text-[var(--muted-foreground)] w-16">{time}</span>
+                    <span className={`shrink-0 w-12 ${levelColor(e.level)}`}>{e.level ?? ""}</span>
+                    <span className="break-all">{msg}</span>
+                  </div>
+                );
+              })
+            )}
+          </div>
+        </CardContent>
+      </Card>
+    </div>
+  );
+}
diff --git a/apps/desktop/src/renderer/components/sessions/SessionDetailView.tsx b/apps/desktop/src/renderer/components/sessions/SessionDetailView.tsx
new file mode 100644
index 00000000..8c815687
--- /dev/null
+++ b/apps/desktop/src/renderer/components/sessions/SessionDetailView.tsx
@@ -0,0 +1,172 @@
+import { Card, CardContent, CardHeader, CardTitle } from "@closedloop-ai/design-system/components/ui/card";
+import { Badge } from "@closedloop-ai/design-system/components/ui/badge";
+import { Button } from "@closedloop-ai/design-system/components/ui/button";
+import { ArrowLeft, Bot, Coins, Clock, Cpu, FolderGit2 } from "lucide-react";
+import { useQueryCache } from "../../hooks/useQueryCache";
+import type {
+  SessionWithAgents,
+  AgentHierarchyNode,
+  EventRow,
+} from "../../../shared/agent-db-contract";
+
+const EVENT_TIMELINE_CAP = 200;
+
+function statusTone(status: string): string {
+  switch (status) {
+    case "active":
+    case "working":
+      return "bg-blue-500/10 text-blue-600";
+    case "waiting":
+      return "bg-yellow-500/10 text-yellow-700";
+    case "completed":
+      return "bg-green-500/10 text-green-600";
+    case "error":
+      return "bg-red-500/10 text-red-600";
+    case "abandoned":
+      return "bg-zinc-500/10 text-zinc-600";
+    default:
+      return "bg-zinc-500/10 text-zinc-600";
+  }
+}
+
+function formatDuration(startedAt: string | null, endedAt: string | null, updatedAt: string | null): string {
+  if (!startedAt) return "—";
+  const start = new Date(startedAt).getTime();
+  const end = new Date(endedAt ?? updatedAt ?? startedAt).getTime();
+  if (Number.isNaN(start) || Number.isNaN(end) || end < start) return "—";
+  const sec = Math.round((end - start) / 1000);
+  if (sec < 60) return `${sec}s`;
+  if (sec < 3600) return `${Math.round(sec / 60)}m`;
+  return `${(sec / 3600).toFixed(1)}h`;
+}
+
+function AgentNode({ node, depth }: { node: AgentHierarchyNode; depth: number }) {
+  return (
+    <div>
+      <div
+        className="flex items-center gap-2 py-1.5 text-sm border-b border-[var(--border)]/40"
+        style={{ paddingLeft: `${depth * 16}px` }}
+      >
+        <Bot className="size-3.5 text-[var(--muted-foreground)] shrink-0" />
+        <span className="font-medium truncate">{node.name ?? node.agentId}</span>
+        {node.subagentType && (
+          <span className="text-xs text-[var(--muted-foreground)]">({node.subagentType})</span>
+        )}
+        <Badge className={`ml-auto text-[10px] ${statusTone(node.status)}`}>{node.status}</Badge>
+        {node.currentTool && (
+          <span className="text-xs text-[var(--muted-foreground)]">{node.currentTool}</span>
+        )}
+      </div>
+      {node.children.map((child) => (
+        <AgentNode key={child.agentId} node={child} depth={depth + 1} />
+      ))}
+    </div>
+  );
+}
+
+export function SessionDetailView({ sessionId, onBack }: { sessionId: string; onBack: () => void }) {
+  // Reuses the shared db:sessions-details cache (also feeding the list/kanban),
+  // so opening a detail view issues no extra round-trip for header data.
+  const { data: sessions } = useQueryCache<SessionWithAgents[]>(
+    "db:sessions-details",
+    () => window.desktopApi.db.getSessionsWithDetails(),
+  );
+  const { data: hierarchy } = useQueryCache<AgentHierarchyNode[]>(
+    `db:agent-hierarchy:${sessionId}`,
+    () => window.desktopApi.db.getAgentHierarchy(sessionId),
+  );
+  const { data: events } = useQueryCache<EventRow[]>(
+    `db:events:${sessionId}`,
+    () => window.desktopApi.db.getEvents(sessionId),
+  );
+
+  const session = (sessions ?? []).find((s) => s.id === sessionId);
+  const timeline = (events ?? []).slice(-EVENT_TIMELINE_CAP).reverse();
+  const truncated = (events?.length ?? 0) > EVENT_TIMELINE_CAP;
+
+  return (
+    <div className="p-6 space-y-6">
+      <div className="flex items-center gap-3">
+        <Button variant="outline" size="sm" onClick={onBack}>
+          <ArrowLeft className="size-4" /> Back
+        </Button>
+        <h1 className="text-xl font-bold truncate">{session?.name ?? sessionId}</h1>
+        {session && <Badge className={statusTone(session.status)}>{session.status}</Badge>}
+        {session?.harness && (
+          <Badge className="bg-[var(--muted)] text-[var(--muted-foreground)]">{session.harness}</Badge>
+        )}
+      </div>
+
+      {!session ? (
+        <p className="text-sm text-[var(--muted-foreground)]">Session not found.</p>
+      ) : (
+        <>
+          <div className="grid grid-cols-2 md:grid-cols-4 gap-3 text-sm">
+            <Meta icon={Cpu} label="Model" value={session.model ?? "—"} />
+            <Meta icon={FolderGit2} label="Directory" value={session.cwd ?? "—"} />
+            <Meta icon={Clock} label="Duration" value={formatDuration(session.startedAt, session.endedAt, session.updatedAt)} />
+            <Meta icon={Coins} label="Tokens" value={session.totalTokens.toLocaleString()} />
+            <Meta icon={Bot} label="Agents" value={String(session.agentCount)} />
+            <Meta icon={Coins} label="Events" value={String(session.eventCount)} />
+            {session.billingMode && <Meta icon={Coins} label="Billing" value={session.billingMode} />}
+            {session.awaitingInputSince && <Meta icon={Clock} label="Awaiting input since" value={session.awaitingInputSince} />}
+          </div>
+
+          <Card>
+            <CardHeader>
+              <CardTitle>Agent hierarchy</CardTitle>
+            </CardHeader>
+            <CardContent>
+              {hierarchy && hierarchy.length > 0 ? (
+                hierarchy.map((node) => <AgentNode key={node.agentId} node={node} depth={0} />)
+              ) : (
+                <p className="text-sm text-[var(--muted-foreground)]">No agents recorded.</p>
+              )}
+            </CardContent>
+          </Card>
+
+          <Card>
+            <CardHeader>
+              <CardTitle>
+                Event timeline
+                {truncated && (
+                  <span className="ml-2 text-xs font-normal text-[var(--muted-foreground)]">
+                    (most recent {EVENT_TIMELINE_CAP} of {events?.length})
+                  </span>
+                )}
+              </CardTitle>
+            </CardHeader>
+            <CardContent>
+              {timeline.length > 0 ? (
+                <div className="space-y-1">
+                  {timeline.map((e) => (
+                    <div key={e.id} className="flex items-center gap-2 py-1 text-sm border-b border-[var(--border)]/30">
+                      <Badge className="text-[10px] bg-[var(--muted)] text-[var(--muted-foreground)]">{e.eventType}</Badge>
+                      {e.toolName && <span className="text-xs font-mono">{e.toolName}</span>}
+                      {e.summary && <span className="truncate text-[var(--muted-foreground)]">{e.summary}</span>}
+                      <span className="ml-auto text-xs text-[var(--muted-foreground)] shrink-0">{e.createdAt}</span>
+                    </div>
+                  ))}
+                </div>
+              ) : (
+                <p className="text-sm text-[var(--muted-foreground)]">No events recorded.</p>
+              )}
+            </CardContent>
+          </Card>
+        </>
+      )}
+    </div>
+  );
+}
+
+function Meta({ icon: Icon, label, value }: { icon: typeof Bot; label: string; value: string }) {
+  return (
+    <div className="flex items-start gap-2">
+      <Icon className="size-4 text-[var(--muted-foreground)] mt-0.5 shrink-0" />
+      <div className="min-w-0">
+        <p className="text-xs text-[var(--muted-foreground)]">{label}</p>
+        <p className="font-medium truncate" title={value}>{value}</p>
+      </div>
+    </div>
+  );
+}
diff --git a/apps/desktop/src/renderer/components/sessions/SessionsView.tsx b/apps/desktop/src/renderer/components/sessions/SessionsView.tsx
new file mode 100644
index 00000000..a7b87eb1
--- /dev/null
+++ b/apps/desktop/src/renderer/components/sessions/SessionsView.tsx
@@ -0,0 +1,153 @@
+import { useState, useMemo } from "react";
+import { Button } from "@closedloop-ai/design-system/components/ui/button";
+import { MetricCard } from "@closedloop-ai/design-system/components/ui/primitives/metric-card";
+import { SessionTable } from "@closedloop-ai/design-system/components/ui/composites/session-table";
+import { MonitorDot, Activity, Bot, Coins } from "lucide-react";
+import { useQueryCache } from "../../hooks/useQueryCache";
+import type { SessionRow } from "@closedloop-ai/design-system/components/ui/types";
+import type { SessionWithAgents } from "../../../shared/agent-db-contract";
+
+const OVERVIEW_CARD_CLASS_NAME =
+  "min-h-0 gap-0 rounded-xl border-border/70 bg-card shadow-sm [&>div:first-child]:px-5 [&>div:first-child]:pt-4 [&>div:first-child]:pb-2 [&_[data-slot='card-description']]:text-[10px] [&_[data-slot='card-title']]:text-[1.75rem] [&>div:last-child]:px-5 [&>div:last-child]:pb-4 [&>div:last-child]:text-xs";
+
+function adaptSession(raw: SessionWithAgents): SessionRow {
+  return {
+    id: raw.id,
+    name: raw.name ?? "Unnamed Session",
+    repo: raw.cwd ?? "",
+    model: raw.model ?? "",
+    harness: raw.harness ?? "claude",
+    status: raw.status,
+    startedAt: raw.startedAt ?? "",
+    lastActivity: raw.updatedAt ?? raw.startedAt ?? "",
+    cost: 0,
+    agents: raw.agentCount,
+    totalTokens: raw.totalTokens,
+    awaitingInputSince: raw.awaitingInputSince,
+  };
+}
+
+const STATUS_OPTIONS = ["all", "active", "waiting", "completed", "abandoned", "error"] as const;
+const TERMINAL_STATUSES = ["completed", "abandoned", "error"];
+
+interface SessionsViewProps {
+  showOverview?: boolean;
+}
+
+export function SessionsView({ showOverview = true }: SessionsViewProps) {
+  const { data: sessions, loading } = useQueryCache<SessionWithAgents[]>(
+    "db:sessions-details",
+    () => window.desktopApi.db.getSessionsWithDetails(),
+  );
+  const [search, setSearch] = useState("");
+  const [statusFilter, setStatusFilter] = useState<string>("all");
+
+  const allSessions = sessions ?? [];
+
+  const filtered = useMemo(() => {
+    let result = allSessions;
+    if (statusFilter !== "all") {
+      result = result.filter((s) => s.status === statusFilter);
+    }
+    if (search) {
+      const q = search.toLowerCase();
+      result = result.filter(
+        (s) =>
+          (s.name ?? "").toLowerCase().includes(q) ||
+          s.id.toLowerCase().includes(q) ||
+          (s.cwd ?? "").toLowerCase().includes(q) ||
+          (s.model ?? "").toLowerCase().includes(q),
+      );
+    }
+    return result;
+  }, [allSessions, statusFilter, search]);
+
+  const totalAgents = allSessions.reduce((a, s) => a + s.agentCount, 0);
+  const totalTokens = allSessions.reduce((a, s) => a + s.totalTokens, 0);
+  const activeSessions = allSessions.filter(
+    (s) => !TERMINAL_STATUSES.includes(s.status),
+  ).length;
+
+  if (loading) {
+    return (
+      <div className="flex items-center justify-center h-full">
+        <p className="text-sm text-[var(--muted-foreground)]">Loading sessions...</p>
+      </div>
+    );
+  }
+
+  return (
+    <div className={showOverview ? "mx-auto flex w-full max-w-[1500px] flex-col gap-6 p-6" : "flex flex-col gap-5"}>
+      {showOverview ? (
+        <>
+          <div className="space-y-1">
+            <h1 className="text-[1.75rem] font-semibold tracking-tight text-[var(--foreground)]">Sessions</h1>
+            <p className="text-sm text-[var(--muted-foreground)]">
+              All agent sessions ({allSessions.length} total)
+            </p>
+          </div>
+
+          <div className="grid grid-cols-1 gap-3 sm:grid-cols-2 xl:grid-cols-4">
+            <MetricCard className={OVERVIEW_CARD_CLASS_NAME} label="Total Sessions" value={allSessions.length} icon={MonitorDot} />
+            <MetricCard className={OVERVIEW_CARD_CLASS_NAME} label="Active" value={activeSessions} icon={Activity} />
+            <MetricCard className={OVERVIEW_CARD_CLASS_NAME} label="Agents" value={totalAgents} icon={Bot} />
+            <MetricCard className={OVERVIEW_CARD_CLASS_NAME} label="Tokens" value={totalTokens.toLocaleString()} icon={Coins} />
+          </div>
+        </>
+      ) : null}
+
+      <section className="rounded-[1.25rem] border border-border/80 bg-card/96 shadow-sm">
+        <div className="flex flex-col gap-4 border-b border-border/70 px-5 py-4 lg:flex-row lg:items-end lg:justify-between">
+          <div className="space-y-1">
+            <h2 className="text-xl font-semibold tracking-tight text-[var(--foreground)]">Session Explorer</h2>
+            <p className="text-sm text-[var(--muted-foreground)]">
+              Search, filter, and drill into recorded loops and agent runs.
+            </p>
+          </div>
+          <div className="text-xs uppercase tracking-[0.18em] text-[var(--muted-foreground)]">
+            {filtered.length.toLocaleString()} shown
+          </div>
+        </div>
+
+        <div className="flex flex-col gap-3 px-5 py-4 xl:flex-row xl:items-center">
+        <input
+          type="text"
+          value={search}
+          onChange={(e) => setSearch(e.target.value)}
+          placeholder="Search sessions..."
+          className="h-11 flex-1 rounded-xl border border-[var(--input-border)] bg-[var(--background)] px-4 text-sm text-[var(--foreground)] shadow-sm placeholder:text-[var(--muted-foreground)]"
+        />
+        <div className="flex flex-wrap gap-2">
+          {STATUS_OPTIONS.map((s) => (
+            <Button
+              key={s}
+              variant={statusFilter === s ? "default" : "outline"}
+              size="sm"
+              onClick={() => setStatusFilter(s)}
+              className="min-w-[5.5rem] rounded-full"
+            >
+              {s === "all" ? "All" : s.charAt(0).toUpperCase() + s.slice(1)}
+            </Button>
+          ))}
+        </div>
+        </div>
+
+        <div className="px-3 pb-3">
+          <div className="overflow-hidden rounded-2xl border border-border/70 bg-[var(--background)]">
+            <SessionTable
+              rows={filtered.map(adaptSession)}
+              getSessionHref={(row: SessionRow) => `#tab=dashboard&sessionId=${encodeURIComponent(row.id)}`}
+              emptyState={
+                <div className="py-12 text-center text-sm text-[var(--muted-foreground)]">
+                  {search || statusFilter !== "all"
+                    ? "No sessions match the current filters."
+                    : "No sessions recorded yet."}
+                </div>
+              }
+            />
+          </div>
+        </div>
+      </section>
+    </div>
+  );
+}
diff --git a/apps/desktop/src/renderer/components/sessions/session-nav.ts b/apps/desktop/src/renderer/components/sessions/session-nav.ts
new file mode 100644
index 00000000..01238582
--- /dev/null
+++ b/apps/desktop/src/renderer/components/sessions/session-nav.ts
@@ -0,0 +1,17 @@
+import { createContext, useContext } from "react";
+
+/**
+ * Minimal drill-down navigation for the session list. The renderer has no
+ * router (FEA-1497 Phase 1 decision: nav-stack over react-router); App owns a
+ * single-depth stack and exposes `openSession` through this context so the
+ * deeply-nested SessionTable rows can push the detail view.
+ */
+export interface SessionNav {
+  openSession: (sessionId: string) => void;
+}
+
+export const SessionNavContext = createContext<SessionNav | null>(null);
+
+export function useSessionNav(): SessionNav {
+  return useContext(SessionNavContext) ?? { openSession: () => {} };
+}
diff --git a/apps/desktop/src/renderer/components/settings/SettingsPanel.tsx b/apps/desktop/src/renderer/components/settings/SettingsPanel.tsx
new file mode 100644
index 00000000..6f191e33
--- /dev/null
+++ b/apps/desktop/src/renderer/components/settings/SettingsPanel.tsx
@@ -0,0 +1,526 @@
+import { useState, useEffect } from "react";
+import { Button } from "@closedloop-ai/design-system/components/ui/button";
+import { Card, CardContent, CardHeader, CardTitle } from "@closedloop-ai/design-system/components/ui/card";
+
+type SettingsTab = "relay-gateway" | "security" | "policies" | "binary-paths" | "labs";
+
+/** Renderer view of ApiKeyStore.getStatus() (src/main/api-key-store.ts). */
+interface ApiKeyStatusView {
+  hasApiKey: boolean;
+  source: "safeStorage" | "environment" | "none";
+  environmentVariable?: string;
+  provenance?: string;
+}
+
+export function SettingsPanel() {
+  const [tab, setTab] = useState<SettingsTab>("relay-gateway");
+  const [settings, setSettings] = useState<Record<string, unknown> | null>(null);
+
+  useEffect(() => {
+    window.desktopApi.getSettings().then((s) => setSettings(s as Record<string, unknown>));
+  }, []);
+
+  useEffect(() => {
+    const handler = (e: CustomEvent<string>) => setTab(e.detail as SettingsTab);
+    window.addEventListener("desktop:navigate-settings-tab", handler as EventListener);
+    return () => window.removeEventListener("desktop:navigate-settings-tab", handler as EventListener);
+  }, []);
+
+  const tabs: { id: SettingsTab; label: string }[] = [
+    { id: "relay-gateway", label: "Relay / Gateway" },
+    { id: "security", label: "Security" },
+    { id: "policies", label: "Policies" },
+    { id: "binary-paths", label: "CLI Tools" },
+    { id: "labs", label: "Labs" },
+  ];
+
+  return (
+    <div className="p-6 space-y-4">
+      <h2 className="text-lg font-semibold text-[var(--foreground)]">Settings</h2>
+
+      <div className="flex gap-1 border-b">
+        {tabs.map((t) => (
+          <button
+            key={t.id}
+            type="button"
+            onClick={() => setTab(t.id)}
+            className={`px-3 py-2 text-sm border-b-2 transition-colors ${
+              tab === t.id
+                ? "border-[var(--primary)] text-[var(--foreground)] font-medium"
+                : "border-transparent text-[var(--muted-foreground)] hover:text-[var(--foreground)]"
+            }`}
+          >
+            {t.label}
+          </button>
+        ))}
+      </div>
+
+      {tab === "relay-gateway" && <RelayGatewayTab settings={settings} />}
+      {tab === "security" && <SecurityTab settings={settings} />}
+      {tab === "policies" && <PoliciesTab settings={settings} />}
+      {tab === "binary-paths" && <BinaryPathsTab />}
+      {tab === "labs" && <LabsTab settings={settings} onSettingsChange={setSettings} />}
+    </div>
+  );
+}
+
+function RelayGatewayTab({ settings }: { settings: Record<string, unknown> | null }) {
+  const [runtime, setRuntime] = useState<Record<string, unknown> | null>(null);
+  const [paused, setPaused] = useState(false);
+  const [connected, setConnected] = useState(true);
+  const [hooksEnabled, setHooksEnabled] = useState(false);
+  const [codexOptIn, setCodexOptIn] = useState(false);
+
+  useEffect(() => {
+    window.desktopApi.getRuntimeStatus().then((r) => setRuntime(r as Record<string, unknown>));
+    window.desktopApi.getCloudCommandsPaused().then((p) => setPaused(p as boolean));
+    window.desktopApi.getCloudConnectionEnabled().then((c) => setConnected(c as boolean));
+    window.desktopApi.getAgentMonitorHooksEnabled().then((h) => setHooksEnabled(h as boolean));
+    window.desktopApi.getAgentMonitorCodexHooksOptIn().then((c) => setCodexOptIn(c as boolean));
+  }, []);
+
+  const handlePauseToggle = async () => {
+    const next = !paused;
+    await window.desktopApi.setCloudCommandsPaused(next);
+    setPaused(next);
+  };
+
+  const handleConnectionToggle = async () => {
+    const next = !connected;
+    await window.desktopApi.setCloudConnectionEnabled(next);
+    setConnected(next);
+  };
+
+  const handleHooksToggle = async () => {
+    const next = !hooksEnabled;
+    const result = await window.desktopApi.setAgentMonitorHooksEnabled(next);
+    setHooksEnabled(result.enabled);
+  };
+
+  const handleCodexToggle = async () => {
+    const next = !codexOptIn;
+    const result = await window.desktopApi.setAgentMonitorCodexHooksOptIn(next);
+    if (result.ok) {
+      setCodexOptIn(next);
+    }
+  };
+
+  return (
+    <div className="space-y-4 mt-4">
+      <Card>
+        <CardHeader>
+          <CardTitle>Connection Status</CardTitle>
+        </CardHeader>
+        <CardContent>
+          <div className="grid grid-cols-2 sm:grid-cols-4 gap-4">
+            <div>
+              <p className="text-xs text-[var(--muted-foreground)]">Gateway Port</p>
+              <p className="text-sm font-semibold">{(runtime?.port as string) ?? "..."}</p>
+            </div>
+            <div>
+              <p className="text-xs text-[var(--muted-foreground)]">Cloud Connection</p>
+              <p className={`text-sm font-semibold ${connected ? "text-[var(--success)]" : "text-[var(--destructive)]"}`}>
+                {connected ? "Connected" : "Disconnected"}
+              </p>
+            </div>
+            <div>
+              <p className="text-xs text-[var(--muted-foreground)]">Remote Commands</p>
+              <p className={`text-sm font-semibold ${paused ? "text-[var(--warning)]" : "text-[var(--success)]"}`}>
+                {paused ? "Paused" : "Active"}
+              </p>
+            </div>
+            <div>
+              <p className="text-xs text-[var(--muted-foreground)]">Security</p>
+              <p className="text-sm font-semibold">{(runtime?.security as string) ?? "..."}</p>
+            </div>
+          </div>
+        </CardContent>
+      </Card>
+
+      <Card>
+        <CardHeader>
+          <CardTitle>Configuration</CardTitle>
+        </CardHeader>
+        <CardContent className="space-y-3">
+          <ConfigRow label="Compute Target" value={runtime?.targetId as string} mono />
+          <ConfigRow label="Relay Origin" value={settings?.relayOrigin as string} mono />
+          <ConfigRow label="API Origin" value={settings?.apiOrigin as string} mono />
+        </CardContent>
+      </Card>
+
+      <div className="space-y-3">
+        <div className="flex items-center justify-between">
+          <div>
+            <p className="text-sm font-medium">Pause Incoming Commands</p>
+            <p className="text-xs text-[var(--muted-foreground)]">Pause processing of remote commands</p>
+          </div>
+          <label className="relative inline-flex items-center cursor-pointer">
+            <input type="checkbox" checked={paused} onChange={handlePauseToggle} className="sr-only peer" />
+            <div className="w-9 h-5 bg-[var(--muted)] peer-focus:outline-none rounded-full peer peer-checked:after:translate-x-full after:content-[''] after:absolute after:top-[2px] after:left-[2px] after:bg-white after:rounded-full after:h-4 after:w-4 after:transition-all peer-checked:bg-[var(--primary)]" />
+          </label>
+        </div>
+
+        <div className="flex items-center justify-between">
+          <div>
+            <p className="text-sm font-medium">Cloud Connection</p>
+            <p className="text-xs text-[var(--muted-foreground)]">Enable cloud relay connection</p>
+          </div>
+          <label className="relative inline-flex items-center cursor-pointer">
+            <input type="checkbox" checked={connected} onChange={handleConnectionToggle} className="sr-only peer" />
+            <div className="w-9 h-5 bg-[var(--muted)] peer-focus:outline-none rounded-full peer peer-checked:after:translate-x-full after:content-[''] after:absolute after:top-[2px] after:left-[2px] after:bg-white after:rounded-full after:h-4 after:w-4 after:transition-all peer-checked:bg-[var(--primary)]" />
+          </label>
+        </div>
+
+        <div className="flex items-center justify-between">
+          <div>
+            <p className="text-sm font-medium">Claude Code Session Tracking</p>
+            <p className="text-xs text-[var(--muted-foreground)]">Receive live session events from Claude Code</p>
+          </div>
+          <label className="relative inline-flex items-center cursor-pointer">
+            <input type="checkbox" checked={hooksEnabled} onChange={handleHooksToggle} className="sr-only peer" />
+            <div className="w-9 h-5 bg-[var(--muted)] peer-focus:outline-none rounded-full peer peer-checked:after:translate-x-full after:content-[''] after:absolute after:top-[2px] after:left-[2px] after:bg-white after:rounded-full after:h-4 after:w-4 after:transition-all peer-checked:bg-[var(--primary)]" />
+          </label>
+        </div>
+
+        <div className="flex items-center justify-between">
+          <div>
+            <p className="text-sm font-medium">Codex Session Tracking</p>
+            <p className="text-xs text-[var(--muted-foreground)]">
+              Also track OpenAI Codex sessions via {"~/.codex/hooks.json"} (requires Claude Code tracking on; enable Codex hooks in {"~/.codex/config.toml"})
+            </p>
+          </div>
+          <label className="relative inline-flex items-center cursor-pointer">
+            <input type="checkbox" checked={codexOptIn} onChange={handleCodexToggle} disabled={!hooksEnabled} className="sr-only peer" />
+            <div className="w-9 h-5 bg-[var(--muted)] peer-focus:outline-none rounded-full peer peer-checked:after:translate-x-full after:content-[''] after:absolute after:top-[2px] after:left-[2px] after:bg-white after:rounded-full after:h-4 after:w-4 after:transition-all peer-checked:bg-[var(--primary)] peer-disabled:opacity-40" />
+          </label>
+        </div>
+      </div>
+    </div>
+  );
+}
+
+function SecurityTab({ settings }: { settings: Record<string, unknown> | null }) {
+  const [dangerousAutoApprove, setDangerousAutoApprove] = useState(false);
+  const [apiKeyStatus, setApiKeyStatus] = useState<ApiKeyStatusView | null>(null);
+  const [apiKeyInput, setApiKeyInput] = useState("");
+  const [apiKeyBusy, setApiKeyBusy] = useState(false);
+  const [apiKeyError, setApiKeyError] = useState<string | null>(null);
+
+  const refreshApiKeyStatus = async () => {
+    const status = await window.desktopApi.getApiKeyStatus();
+    setApiKeyStatus(status as ApiKeyStatusView);
+  };
+
+  useEffect(() => {
+    window.desktopApi.getDangerousAutoApprove().then(setDangerousAutoApprove);
+    void refreshApiKeyStatus();
+  }, []);
+
+  const handleDangerousToggle = async () => {
+    const next = !dangerousAutoApprove;
+    await window.desktopApi.setDangerousAutoApprove(next);
+    setDangerousAutoApprove(next);
+  };
+
+  const handleSetApiKey = async () => {
+    const value = apiKeyInput.trim();
+    if (!value) return;
+    setApiKeyBusy(true);
+    setApiKeyError(null);
+    try {
+      await window.desktopApi.setApiKey(value);
+      setApiKeyInput("");
+      await refreshApiKeyStatus();
+    } catch (err) {
+      setApiKeyError(err instanceof Error ? err.message : "Failed to set API key");
+    } finally {
+      setApiKeyBusy(false);
+    }
+  };
+
+  const handleClearApiKey = async () => {
+    setApiKeyBusy(true);
+    setApiKeyError(null);
+    try {
+      await window.desktopApi.clearApiKey();
+      setApiKeyInput("");
+      await refreshApiKeyStatus();
+    } catch (err) {
+      setApiKeyError(err instanceof Error ? err.message : "Failed to clear API key");
+    } finally {
+      setApiKeyBusy(false);
+    }
+  };
+
+  const apiKeyConfigured = apiKeyStatus?.hasApiKey === true;
+  const apiKeyFromEnv = apiKeyStatus?.source === "environment";
+  const apiKeyValueLabel = !apiKeyStatus
+    ? "..."
+    : apiKeyConfigured
+      ? `Configured (${apiKeyStatus.source}${apiKeyStatus.provenance ? `, ${apiKeyStatus.provenance}` : ""})`
+      : "Not configured";
+
+  return (
+    <div className="space-y-4 mt-4">
+      <Card>
+        <CardHeader>
+          <CardTitle>Security Settings</CardTitle>
+        </CardHeader>
+        <CardContent className="space-y-4">
+          <ConfigRow label="API Key" value={apiKeyValueLabel} />
+          <ConfigRow label="Auth Mode" value={(settings?.authMode as string) ?? "standard"} />
+
+          <div className="space-y-2 pt-2 border-t">
+            <p className="text-sm font-medium">Manage API Key</p>
+            <p className="text-xs text-[var(--muted-foreground)]">
+              {apiKeyFromEnv
+                ? "An API key is provided via an environment variable. Setting one here stores an encrypted key that takes precedence."
+                : "Set a ClosedLoop API key (starts with sk_live_). It is stored encrypted at rest."}
+            </p>
+            <div className="flex gap-2">
+              <input
+                type="password"
+                value={apiKeyInput}
+                onChange={(e) => setApiKeyInput(e.target.value)}
+                onKeyDown={(e) => { if (e.key === "Enter") handleSetApiKey(); }}
+                placeholder="sk_live_..."
+                autoComplete="off"
+                className="flex-1 text-xs font-mono bg-[var(--input)] border rounded px-2 py-1 text-[var(--foreground)]"
+              />
+              <Button
+                variant="outline"
+                size="sm"
+                onClick={handleSetApiKey}
+                disabled={apiKeyBusy || apiKeyInput.trim().length === 0}
+              >
+                Set
+              </Button>
+              <Button
+                variant="ghost"
+                size="sm"
+                onClick={handleClearApiKey}
+                disabled={apiKeyBusy || !apiKeyConfigured}
+                className="text-[var(--destructive)]"
+              >
+                Clear
+              </Button>
+            </div>
+            {apiKeyError && (
+              <p className="text-xs text-[var(--destructive)]">{apiKeyError}</p>
+            )}
+          </div>
+
+          <div className="flex items-center justify-between pt-2 border-t">
+            <div>
+              <p className="text-sm font-medium text-[var(--destructive)]">Dangerous Auto-Approve</p>
+              <p className="text-xs text-[var(--muted-foreground)]">Automatically approve all commands — use with extreme caution</p>
+            </div>
+            <label className="relative inline-flex items-center cursor-pointer">
+              <input type="checkbox" checked={dangerousAutoApprove} onChange={handleDangerousToggle} className="sr-only peer" />
+              <div className="w-9 h-5 bg-[var(--muted)] peer-focus:outline-none rounded-full peer peer-checked:after:translate-x-full after:content-[''] after:absolute after:top-[2px] after:left-[2px] after:bg-white after:rounded-full after:h-4 after:w-4 after:transition-all peer-checked:bg-[var(--destructive)]" />
+            </label>
+          </div>
+        </CardContent>
+      </Card>
+    </div>
+  );
+}
+
+function PoliciesTab({ settings }: { settings: Record<string, unknown> | null }) {
+  const rules = (settings?.alwaysAllowRules as Array<{ id: string; description?: string; command?: string }>) ?? [];
+
+  const handleRemoveRule = async (ruleId: string) => {
+    await window.desktopApi.removeAlwaysAllowRule(ruleId);
+  };
+
+  return (
+    <div className="space-y-4 mt-4">
+      <Card>
+        <CardHeader>
+          <CardTitle>Always Allow Rules</CardTitle>
+        </CardHeader>
+        <CardContent>
+          {rules.length === 0 ? (
+            <p className="text-sm text-[var(--muted-foreground)] text-center py-4">No always-allow rules configured</p>
+          ) : (
+            <div className="space-y-2">
+              {rules.map((rule) => (
+                <div key={rule.id} className="flex items-center justify-between border rounded p-3 text-sm">
+                  <div className="min-w-0 flex-1">
+                    <p className="truncate font-medium">{rule.description ?? "Rule"}</p>
+                    {rule.command && <p className="truncate text-xs text-[var(--muted-foreground)] font-mono">{rule.command}</p>}
+                  </div>
+                  <Button variant="ghost" size="sm" onClick={() => handleRemoveRule(rule.id)} className="text-[var(--destructive)] shrink-0 ml-2">Remove</Button>
+                </div>
+              ))}
+            </div>
+          )}
+        </CardContent>
+      </Card>
+    </div>
+  );
+}
+
+function BinaryPathsTab() {
+  const [binaries, setBinaries] = useState<Record<string, string>>({});
+  const [loading, setLoading] = useState(true);
+  const [editing, setEditing] = useState<string | null>(null);
+  const [editValue, setEditValue] = useState("");
+
+  useEffect(() => {
+    window.desktopApi.getBinaryPaths().then((b) => {
+      setBinaries(b as Record<string, string>);
+      setLoading(false);
+    });
+  }, []);
+
+  const handleDetect = async () => {
+    setLoading(true);
+    await window.desktopApi.detectCliTools();
+    const b = await window.desktopApi.getBinaryPaths();
+    setBinaries(b as Record<string, string>);
+    setLoading(false);
+  };
+
+  const startEdit = (tool: string) => {
+    setEditing(tool);
+    setEditValue(binaries[tool] ?? "");
+  };
+
+  const handleSave = async (tool: string) => {
+    if (editValue) {
+      await window.desktopApi.patchBinaryPaths({ [tool]: editValue });
+      const b = await window.desktopApi.getBinaryPaths();
+      setBinaries(b as Record<string, string>);
+    }
+    setEditing(null);
+  };
+
+  const BINARY_TOOLS = ["claude", "node", "git", "bash", "python3"];
+
+  return (
+    <div className="space-y-4 mt-4">
+      <Card>
+        <CardHeader>
+          <div className="flex items-center justify-between">
+            <CardTitle>CLI Tools</CardTitle>
+            <Button variant="outline" size="sm" onClick={handleDetect} disabled={loading}>Detect Tools</Button>
+          </div>
+        </CardHeader>
+        <CardContent className="space-y-3">
+          {loading ? (
+            <p className="text-sm text-[var(--muted-foreground)] text-center py-4">Detecting tools...</p>
+          ) : (
+            BINARY_TOOLS.map((tool) => (
+              <div key={tool} className="flex items-center justify-between border rounded p-3">
+                <div className="min-w-0 flex-1">
+                  <p className="text-sm font-medium">{tool}</p>
+                  {editing === tool ? (
+                    <input
+                      type="text"
+                      value={editValue}
+                      onChange={(e) => setEditValue(e.target.value)}
+                      onKeyDown={(e) => { if (e.key === "Enter") handleSave(tool); if (e.key === "Escape") setEditing(null); }}
+                      autoFocus
+                      className="mt-1 w-full text-xs font-mono bg-[var(--input)] border rounded px-2 py-1 text-[var(--foreground)]"
+                      placeholder={`/usr/bin/${tool}`}
+                    />
+                  ) : (
+                    <p className="text-xs text-[var(--muted-foreground)] font-mono truncate max-w-[300px]">
+                      {binaries[tool] ?? "Not found"}
+                    </p>
+                  )}
+                </div>
+                <div className="flex gap-2 ml-2 shrink-0">
+                  {editing === tool ? (
+                    <>
+                      <Button variant="outline" size="sm" onClick={() => handleSave(tool)}>Save</Button>
+                      <Button variant="ghost" size="sm" onClick={() => setEditing(null)}>Cancel</Button>
+                    </>
+                  ) : (
+                    <Button variant="outline" size="sm" onClick={() => startEdit(tool)}>Edit</Button>
+                  )}
+                </div>
+              </div>
+            ))
+          )}
+        </CardContent>
+      </Card>
+    </div>
+  );
+}
+
+const LAB_FLAGS: { key: string; label: string; description: string; category: string; requiresRestart?: boolean }[] = [
+  { key: "agentMonitorEnabled", label: "Agent Dashboard", description: "Enable the legacy sidecar-backed Agent Dashboard.", category: "Monitoring", requiresRestart: true },
+  { key: "agentDashboardDesignSystemEnabled", label: "Agent Dashboard Design System", description: "Use the in-process design-system dashboard instead of the legacy dashboard.", category: "Labs", requiresRestart: true },
+  { key: "planExtractionEnabled", label: "Plan Extraction", description: "Enable Plans / plan extraction UI in the Agent Dashboard.", category: "Monitoring" },
+  { key: "commandSigningEnforcementEnabled", label: "Command Signing Enforcement", description: "Require ED25519 signatures on browser commands.", category: "Security", requiresRestart: true },
+  { key: "verboseLogging", label: "Verbose Logging", description: "Enable verbose gateway logging for debugging.", category: "Debugging" },
+];
+
+function LabsTab({ settings, onSettingsChange }: { settings: Record<string, unknown> | null; onSettingsChange: (s: Record<string, unknown>) => void }) {
+  const [saving, setSaving] = useState<string | null>(null);
+
+  const handleToggle = async (key: string, currentValue: boolean) => {
+    setSaving(key);
+    try {
+      await window.desktopApi.updateSettings({ [key]: !currentValue });
+      const updated = await window.desktopApi.getSettings();
+      onSettingsChange(updated as Record<string, unknown>);
+    } catch { /* ignore */ }
+    setSaving(null);
+  };
+
+  return (
+    <div className="space-y-4 mt-4">
+      <Card>
+        <CardHeader>
+          <CardTitle>Labs</CardTitle>
+        </CardHeader>
+        <CardContent>
+          <p className="text-sm text-[var(--muted-foreground)] mb-4">
+            Early access to experimental features and advanced controls.
+          </p>
+          <div className="space-y-3">
+            {LAB_FLAGS.map((flag) => {
+              const value = settings?.[flag.key] === true;
+              return (
+                <div key={flag.key} className="flex items-center justify-between border rounded p-3">
+                  <div className="min-w-0 flex-1">
+                    <div className="flex items-center gap-2">
+                      <p className="text-sm font-medium">{flag.label}</p>
+                      <span className="text-[10px] px-1.5 py-0.5 rounded bg-[var(--muted)] text-[var(--muted-foreground)]">{flag.category}</span>
+                    </div>
+                    <p className="text-xs text-[var(--muted-foreground)] mt-0.5">{flag.description}</p>
+                    {flag.requiresRestart && (
+                      <p className="text-[10px] text-[var(--warning-foreground)] mt-0.5">Requires restart</p>
+                    )}
+                  </div>
+                  <label className="relative inline-flex items-center cursor-pointer ml-3 shrink-0">
+                    <input
+                      type="checkbox"
+                      checked={value}
+                      onChange={() => handleToggle(flag.key, value)}
+                      disabled={saving === flag.key}
+                      className="sr-only peer"
+                    />
+                    <div className="w-9 h-5 bg-[var(--muted)] peer-focus:outline-none rounded-full peer peer-checked:after:translate-x-full after:content-[''] after:absolute after:top-[2px] after:left-[2px] after:bg-white after:rounded-full after:h-4 after:w-4 after:transition-all peer-checked:bg-[var(--primary)]" />
+                  </label>
+                </div>
+              );
+            })}
+          </div>
+        </CardContent>
+      </Card>
+    </div>
+  );
+}
+
+function ConfigRow({ label, value, mono }: { label: string; value: string; mono?: boolean }) {
+  return (
+    <div className="flex items-center gap-3 text-sm">
+      <span className="text-[var(--muted-foreground)] w-24 shrink-0">{label}</span>
+      <span className={`truncate ${mono ? "font-mono" : ""}`}>{value || "—"}</span>
+    </div>
+  );
+}
diff --git a/apps/desktop/src/renderer/components/update-banner-state.ts b/apps/desktop/src/renderer/components/update-banner-state.ts
new file mode 100644
index 00000000..b07669ec
--- /dev/null
+++ b/apps/desktop/src/renderer/components/update-banner-state.ts
@@ -0,0 +1,160 @@
+/**
+ * Renderer-side model of the desktop auto-update banner.
+ *
+ * Mirrors the main-process PackagedUpdateStatusPayload
+ * (src/main/packaged-update-state.ts) but is kept local so the renderer stays
+ * decoupled from main-process modules. The pure reducers/selectors here are the
+ * single source of truth for banner visibility and the apply gate, so they can
+ * be unit-tested without a DOM (see test/update-banner-state.test.ts).
+ *
+ * Two IPC-bridged window events feed this state:
+ *  - `desktop:update-status`    -> the canonical PackagedUpdateStatusPayload
+ *  - `desktop:update-available` -> a lighter nudge ({ updateAvailable, version,
+ *                                   readyToInstall } when packaged; the
+ *                                   checkForUpdate() result in dev) with no
+ *                                   `status` field.
+ */
+export type UpdateBannerStatus =
+  | "idle"
+  | "available"
+  | "downloading"
+  | "downloaded"
+  | "not-available"
+  | "error";
+
+export interface UpdateBannerState {
+  status: UpdateBannerStatus;
+  updateAvailable: boolean;
+  readyToInstall: boolean;
+  version?: string;
+  percent?: number;
+  error?: string;
+}
+
+export const INITIAL_UPDATE_BANNER_STATE: UpdateBannerState = {
+  status: "idle",
+  updateAvailable: false,
+  readyToInstall: false,
+};
+
+const KNOWN_STATUSES: readonly UpdateBannerStatus[] = [
+  "idle",
+  "available",
+  "downloading",
+  "downloaded",
+  "not-available",
+  "error",
+];
+
+function asRecord(detail: unknown): Record<string, unknown> | null {
+  return typeof detail === "object" && detail !== null
+    ? (detail as Record<string, unknown>)
+    : null;
+}
+
+function asStatus(value: unknown): UpdateBannerStatus | null {
+  return typeof value === "string" &&
+    (KNOWN_STATUSES as readonly string[]).includes(value)
+    ? (value as UpdateBannerStatus)
+    : null;
+}
+
+/**
+ * Applies a `desktop:update-status` event (the canonical
+ * PackagedUpdateStatusPayload) over the previous banner state. Payloads without
+ * a recognized `status` field are ignored (untrusted IPC boundary).
+ */
+export function reduceUpdateStatusEvent(
+  prev: UpdateBannerState,
+  detail: unknown,
+): UpdateBannerState {
+  const record = asRecord(detail);
+  const status = record ? asStatus(record.status) : null;
+  if (!record || !status) {
+    return prev;
+  }
+  return {
+    status,
+    updateAvailable: record.updateAvailable === true,
+    readyToInstall: record.readyToInstall === true,
+    version: typeof record.version === "string" ? record.version : undefined,
+    percent: typeof record.percent === "number" ? record.percent : undefined,
+    error: typeof record.error === "string" ? record.error : undefined,
+  };
+}
+
+/**
+ * Applies a `desktop:update-available` nudge. This event carries no `status`
+ * field, so we only escalate to "available" and never regress a more advanced
+ * downloading/downloaded state observed via `desktop:update-status`.
+ */
+export function reduceUpdateAvailableEvent(
+  prev: UpdateBannerState,
+  detail: unknown,
+): UpdateBannerState {
+  const record = asRecord(detail);
+  if (!record || record.updateAvailable !== true) {
+    return prev;
+  }
+  const version =
+    typeof record.version === "string" ? record.version : prev.version;
+  if (prev.status === "downloading" || prev.status === "downloaded") {
+    return { ...prev, updateAvailable: true, version };
+  }
+  return {
+    ...prev,
+    status: "available",
+    updateAvailable: true,
+    readyToInstall: false,
+    version,
+  };
+}
+
+/** The banner is only shown for actionable/visible update states. */
+export function isUpdateBannerVisible(state: UpdateBannerState): boolean {
+  if (state.status === "error") {
+    return true;
+  }
+  if (state.status === "idle" || state.status === "not-available") {
+    return false;
+  }
+  return state.updateAvailable || state.readyToInstall;
+}
+
+/**
+ * The Apply / Restart action is only enabled once the update is fully
+ * downloaded. This mirrors the main-process invariant
+ * (assertPackagedUpdateReadyToInstall) so the renderer never offers an apply
+ * action the main process would reject.
+ */
+export function isUpdateApplyEnabled(state: UpdateBannerState): boolean {
+  return state.status === "downloaded" && state.readyToInstall === true;
+}
+
+/** Human-readable banner message for the current state. */
+export function updateBannerMessage(state: UpdateBannerState): string {
+  switch (state.status) {
+    case "downloaded":
+      return state.version
+        ? `Version ${state.version} is ready to install.`
+        : "A new version is ready to install.";
+    case "downloading": {
+      const pct =
+        typeof state.percent === "number"
+          ? ` (${Math.round(state.percent)}%)`
+          : "";
+      const ver = state.version ? ` ${state.version}` : "";
+      return `Downloading update${ver}${pct}...`;
+    }
+    case "available":
+      return state.version
+        ? `Version ${state.version} is available and downloading.`
+        : "A new version is available.";
+    case "error":
+      return state.error
+        ? `Update error: ${state.error}`
+        : "Update failed. It will retry automatically.";
+    default:
+      return "";
+  }
+}
diff --git a/apps/desktop/src/renderer/components/workflows/WorkflowsView.tsx b/apps/desktop/src/renderer/components/workflows/WorkflowsView.tsx
new file mode 100644
index 00000000..b66f37a3
--- /dev/null
+++ b/apps/desktop/src/renderer/components/workflows/WorkflowsView.tsx
@@ -0,0 +1,168 @@
+import { useQueryCache } from "../../hooks/useQueryCache";
+import { Card, CardContent, CardHeader, CardTitle } from "@closedloop-ai/design-system/components/ui/card";
+import { WorkflowStatTile } from "@closedloop-ai/design-system/components/ui/primitives/workflow-stat-tile";
+import { OrchestrationDag } from "@closedloop-ai/design-system/components/ui/composites/orchestration-dag";
+import { SankeyGraph } from "@closedloop-ai/design-system/components/ui/primitives/sankey-graph";
+import { AgentCollaborationNetwork } from "@closedloop-ai/design-system/components/ui/composites/agent-collaboration-network";
+import { RankedBar } from "@closedloop-ai/design-system/components/ui/primitives/ranked-bar";
+import { Badge } from "@closedloop-ai/design-system/components/ui/badge";
+import { Monitor, Bot, GitFork, Target, Layers, Timer } from "lucide-react";
+import type { WorkflowQueryData } from "../../../shared/agent-db-contract";
+
+function formatDuration(sec: number): string {
+  if (sec < 60) return `${Math.round(sec)}s`;
+  if (sec < 3600) return `${Math.round(sec / 60)}m`;
+  return `${(sec / 3600).toFixed(1)}h`;
+}
+
+export function WorkflowsView() {
+  const { data, loading } = useQueryCache<WorkflowQueryData>(
+    "db:workflows",
+    () => window.desktopApi.db.getWorkflowData() as Promise<WorkflowQueryData>,
+    10_000, 15_000,
+  );
+
+  if (loading || !data) {
+    return (
+      <div className="flex items-center justify-center h-full">
+        <p className="text-sm text-[var(--muted-foreground)]">Loading workflows...</p>
+      </div>
+    );
+  }
+
+  const { stats, orchestration, toolFlow, effectiveness, cooccurrence } = data;
+
+  const hasOrchestration = orchestration.subagentTypes.length > 0 || orchestration.edges.length > 0;
+  const hasToolFlow = toolFlow.transitions.length > 0;
+  const hasEffectiveness = effectiveness.length > 0;
+  const hasCooccurrence = cooccurrence.length > 0;
+  const maxToolCount = toolFlow.toolCounts.length > 0 ? toolFlow.toolCounts[0].count : 1;
+
+  return (
+    <div className="p-6 space-y-6">
+      <div>
+        <h1 className="text-xl font-bold text-[var(--foreground)]">Workflows</h1>
+        <p className="text-sm text-[var(--muted-foreground)]">
+          Agent orchestration patterns, tool flows, and effectiveness
+        </p>
+      </div>
+
+      <div className="grid grid-cols-3 gap-4 lg:grid-cols-6">
+        <WorkflowStatTile label="Sessions" value={stats.totalSessions} icon={Monitor} />
+        <WorkflowStatTile label="Agents" value={stats.totalAgents} description={`${stats.totalSubagents} subagents`} icon={Bot} />
+        <WorkflowStatTile label="Avg Subagents" value={stats.avgSubagents.toFixed(1)} icon={GitFork} />
+        <WorkflowStatTile label="Success Rate" value={`${stats.successRate.toFixed(0)}%`} icon={Target} />
+        <WorkflowStatTile label="Avg Depth" value={stats.avgDepth.toFixed(1)} icon={Layers} />
+        <WorkflowStatTile label="Avg Duration" value={formatDuration(stats.avgDurationSec)} icon={Timer} />
+      </div>
+
+      {stats.topFlow && (
+        <Card>
+          <CardContent className="py-3">
+            <p className="text-sm text-[var(--muted-foreground)]">
+              Top tool flow: <span className="font-mono text-[var(--foreground)]">{stats.topFlow.source}</span>
+              {" → "}
+              <span className="font-mono text-[var(--foreground)]">{stats.topFlow.target}</span>
+              {" "}
+              <Badge variant="secondary">{stats.topFlow.count}x</Badge>
+            </p>
+          </CardContent>
+        </Card>
+      )}
+
+      {hasOrchestration && (
+        <Card>
+          <CardHeader><CardTitle>Orchestration DAG</CardTitle></CardHeader>
+          <CardContent>
+            <OrchestrationDag data={orchestration} />
+          </CardContent>
+        </Card>
+      )}
+
+      {hasToolFlow && (
+        <Card>
+          <CardHeader><CardTitle>Tool Execution Flow</CardTitle></CardHeader>
+          <CardContent>
+            <SankeyGraph
+              flows={toolFlow.transitions}
+              totals={toolFlow.toolCounts.map((t) => ({ id: t.toolName, value: t.count }))}
+              ariaLabel="Tool execution flow"
+              emptyMessage="No tool transitions recorded"
+            />
+          </CardContent>
+        </Card>
+      )}
+
+      {hasCooccurrence && hasEffectiveness && (
+        <Card>
+          <CardHeader><CardTitle>Agent Collaboration Network</CardTitle></CardHeader>
+          <CardContent>
+            <AgentCollaborationNetwork data={effectiveness} edges={cooccurrence} />
+          </CardContent>
+        </Card>
+      )}
+
+      {hasEffectiveness && (
+        <Card>
+          <CardHeader><CardTitle>Subagent Effectiveness</CardTitle></CardHeader>
+          <CardContent>
+            <div className="overflow-auto">
+              <table className="w-full text-sm">
+                <thead>
+                  <tr className="border-b text-[var(--muted-foreground)]">
+                    <th className="py-2 text-left font-medium">Agent Type</th>
+                    <th className="py-2 text-right font-medium">Total</th>
+                    <th className="py-2 text-right font-medium">Completed</th>
+                    <th className="py-2 text-right font-medium">Errors</th>
+                    <th className="py-2 text-right font-medium">Success Rate</th>
+                  </tr>
+                </thead>
+                <tbody>
+                  {effectiveness.map((e) => (
+                    <tr key={e.subagentType} className="border-b border-[var(--border)]">
+                      <td className="py-2 font-mono text-xs">{e.subagentType}</td>
+                      <td className="py-2 text-right">{e.total}</td>
+                      <td className="py-2 text-right text-[var(--success)]">{e.completed}</td>
+                      <td className="py-2 text-right text-[var(--destructive)]">{e.errors}</td>
+                      <td className="py-2 text-right">
+                        <Badge variant={e.successRate >= 80 ? "default" : "secondary"}>
+                          {e.successRate.toFixed(0)}%
+                        </Badge>
+                      </td>
+                    </tr>
+                  ))}
+                </tbody>
+              </table>
+            </div>
+          </CardContent>
+        </Card>
+      )}
+
+      {toolFlow.toolCounts.length > 0 && (
+        <Card>
+          <CardHeader><CardTitle>Tool Invocation Counts</CardTitle></CardHeader>
+          <CardContent>
+            <div className="space-y-2">
+              {toolFlow.toolCounts.slice(0, 15).map((t) => (
+                <RankedBar
+                  key={t.toolName}
+                  label={<span className="font-mono text-xs">{t.toolName}</span>}
+                  value={t.count}
+                  percent={(t.count / maxToolCount) * 100}
+                />
+              ))}
+            </div>
+          </CardContent>
+        </Card>
+      )}
+
+      {!hasOrchestration && !hasToolFlow && !hasEffectiveness && (
+        <Card>
+          <CardContent className="py-12 text-center text-sm text-[var(--muted-foreground)]">
+            No workflow data yet. Agent orchestration patterns will appear here once sessions with subagents are recorded.
+          </CardContent>
+        </Card>
+      )}
+    </div>
+  );
+}
diff --git a/apps/desktop/src/renderer/design-system/index.html b/apps/desktop/src/renderer/design-system/index.html
new file mode 100644
index 00000000..df168ac6
--- /dev/null
+++ b/apps/desktop/src/renderer/design-system/index.html
@@ -0,0 +1,12 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>ClosedLoop Gateway</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="../main.tsx"></script>
+  </body>
+</html>
diff --git a/apps/desktop/src/renderer/globals.css b/apps/desktop/src/renderer/globals.css
new file mode 100644
index 00000000..301b079d
--- /dev/null
+++ b/apps/desktop/src/renderer/globals.css
@@ -0,0 +1,6 @@
+@source "./**/*.{ts,tsx}";
+
+:root {
+  --font-sans: "Geist", "Avenir Next", "Segoe UI", system-ui, sans-serif;
+  --font-mono: "Geist Mono", "JetBrains Mono", ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+}
diff --git a/apps/desktop/src/renderer/hooks/useDesktopApi.ts b/apps/desktop/src/renderer/hooks/useDesktopApi.ts
new file mode 100644
index 00000000..07d0fc25
--- /dev/null
+++ b/apps/desktop/src/renderer/hooks/useDesktopApi.ts
@@ -0,0 +1,45 @@
+import { useCallback, useEffect, useState } from "react";
+
+interface DesktopEventMap {
+  "desktop:navigate-tab": CustomEvent<string>;
+  "desktop:navigate-settings-tab": CustomEvent<string>;
+  "desktop:command-keys-changed": CustomEvent;
+  "desktop:update-available": CustomEvent<unknown>;
+  "desktop:update-status": CustomEvent<unknown>;
+  "desktop:onboarding-state-changed": CustomEvent;
+  "desktop:show-onboarding-popup": CustomEvent;
+}
+
+export function useDesktopEvent<K extends keyof DesktopEventMap>(
+  event: K,
+  handler: (detail: DesktopEventMap[K]["detail"]) => void,
+): void {
+  useEffect(() => {
+    const listener = (e: Event) => {
+      handler((e as DesktopEventMap[K]).detail);
+    };
+    window.addEventListener(event, listener);
+    return () => window.removeEventListener(event, listener);
+  }, [event, handler]);
+}
+
+export function useCurrentTab(): [string, (tab: string) => void] {
+  const [tab, setTab] = useState(() => {
+    if (typeof window !== "undefined") {
+      const params = new URLSearchParams(window.location.hash.slice(1));
+      return params.get("tab") || "claude-dashboard";
+    }
+    return "claude-dashboard";
+  });
+
+  const navigate = useCallback((newTab: string) => {
+    window.location.hash = `tab=${newTab}`;
+    setTab(newTab);
+  }, []);
+
+  useDesktopEvent("desktop:navigate-tab", useCallback((detail) => {
+    setTab(detail);
+  }, []));
+
+  return [tab, navigate];
+}
diff --git a/apps/desktop/src/renderer/hooks/useQueryCache.ts b/apps/desktop/src/renderer/hooks/useQueryCache.ts
new file mode 100644
index 00000000..5849e197
--- /dev/null
+++ b/apps/desktop/src/renderer/hooks/useQueryCache.ts
@@ -0,0 +1,96 @@
+import { useEffect, useRef, useState } from "react";
+
+interface CacheEntry<T> {
+  data: T;
+  fetchedAt: number;
+}
+
+const cache = new Map<string, CacheEntry<unknown>>();
+
+/**
+ * Simple in-memory query cache with TTL. Multiple components using the same
+ * key share a single cached result and avoid redundant IPC round-trips.
+ *
+ * @param key    Stable cache key (e.g. "db:analytics")
+ * @param fetcher  Async function that returns the data
+ * @param ttlMs    How long the cached value is considered fresh (default 3 000 ms)
+ * @param pollMs   Re-fetch interval; skipped while the cached value is fresh (default 5 000 ms)
+ */
+export function useQueryCache<T>(
+  key: string,
+  fetcher: () => Promise<T>,
+  ttlMs = 3_000,
+  pollMs = 5_000,
+): { data: T | null; loading: boolean; error: boolean } {
+  const [data, setData] = useState<T | null>(() => {
+    const cached = cache.get(key) as CacheEntry<T> | undefined;
+    return cached ? cached.data : null;
+  });
+  const [loading, setLoading] = useState(data === null);
+  const [error, setError] = useState(false);
+  const fetcherRef = useRef(fetcher);
+  fetcherRef.current = fetcher;
+
+  useEffect(() => {
+    let mounted = true;
+
+    const load = () => {
+      const existing = cache.get(key) as CacheEntry<T> | undefined;
+      if (existing && Date.now() - existing.fetchedAt < ttlMs) {
+        if (mounted) {
+          setData(existing.data);
+          setLoading(false);
+        }
+        return;
+      }
+
+      fetcherRef.current()
+        .then((result) => {
+          cache.set(key, { data: result, fetchedAt: Date.now() });
+          if (mounted) {
+            setData(result);
+            setLoading(false);
+            setError(false);
+          }
+        })
+        .catch(() => {
+          if (mounted) setError(true);
+        });
+    };
+
+    load();
+    const interval = setInterval(load, pollMs);
+
+    // Live updates: the main process pushes desktop:db:changed after each
+    // processed hook event. For DB-backed keys, drop the cached value and
+    // reload immediately so a new session/event appears without waiting for
+    // the next poll tick.
+    let unsubscribe: (() => void) | undefined;
+    if (key.startsWith("db:") && typeof window !== "undefined" && window.desktopApi?.onDbChanged) {
+      unsubscribe = window.desktopApi.onDbChanged(() => {
+        cache.delete(key);
+        load();
+      });
+    }
+
+    return () => {
+      mounted = false;
+      clearInterval(interval);
+      unsubscribe?.();
+    };
+  }, [key, ttlMs, pollMs]);
+
+  return { data, loading, error };
+}
+
+/** Invalidate a specific cache key (e.g. after a mutation). */
+export function invalidateCache(key: string): void {
+  cache.delete(key);
+}
+
+/** Invalidate all cache keys matching a prefix. */
+export function invalidateCachePrefix(prefix: string): void {
+  for (const k of cache.keys()) {
+    if (k.startsWith(prefix)) cache.delete(k);
+  }
+}
diff --git a/apps/desktop/src/renderer/main.tsx b/apps/desktop/src/renderer/main.tsx
new file mode 100644
index 00000000..d89165c6
--- /dev/null
+++ b/apps/desktop/src/renderer/main.tsx
@@ -0,0 +1,31 @@
+import { StrictMode } from "react";
+import { createRoot } from "react-dom/client";
+import { DesignSystemProvider } from "@closedloop-ai/design-system";
+import "./globals.css";
+import "@closedloop-ai/design-system/styles/globals.css";
+import App from "./App";
+
+window.addEventListener("error", (event) => {
+  console.error("[renderer]", event.error ?? event.message);
+});
+window.addEventListener("unhandledrejection", (event) => {
+  console.error("[renderer] unhandled rejection:", event.reason);
+});
+
+const rootElement = document.getElementById("root");
+if (!rootElement) {
+  throw new Error("Root element not found");
+}
+
+createRoot(rootElement).render(
+  <StrictMode>
+    <DesignSystemProvider
+      attribute="class"
+      defaultTheme="light"
+      disableTransitionOnChange
+      enableSystem={false}
+    >
+      <App />
+    </DesignSystemProvider>
+  </StrictMode>,
+);
diff --git a/apps/desktop/src/renderer/types/desktop-api.d.ts b/apps/desktop/src/renderer/types/desktop-api.d.ts
new file mode 100644
index 00000000..c0a5468b
--- /dev/null
+++ b/apps/desktop/src/renderer/types/desktop-api.d.ts
@@ -0,0 +1,127 @@
+import type {
+  SessionRow,
+  AgentRow,
+  EventRow,
+  EventWithSession,
+  EventCountByType,
+  SessionWithAgents,
+  DashboardSummary,
+  TokenAnalytics,
+  AnalyticsData,
+  WorkflowQueryData,
+  AgentHierarchyNode,
+} from "../../shared/agent-db-contract";
+
+export interface AgentMonitorUrl {
+  url: string | null;
+  ready: boolean;
+  enabled: boolean;
+  planExtractionEnabled: boolean;
+}
+
+export interface SandboxInspectResult {
+  path: string;
+  isGitRepo: boolean;
+  suggestedPath: string | undefined;
+}
+
+export interface AgentMonitorHookResult {
+  ok: boolean;
+  enabled: boolean;
+  error?: string;
+}
+
+export interface DesktopApi {
+  getSettings: () => Promise<unknown>;
+  updateSettings: (partial: unknown) => Promise<unknown>;
+  getRuntimeStatus: () => Promise<unknown>;
+  listCommandSigningKeys: () => Promise<unknown>;
+  listAuthorizedKeys: () => Promise<unknown>;
+  authorizeKey: (payload: unknown) => Promise<unknown>;
+  removeAuthorizedKey: (fingerprint: string) => Promise<unknown>;
+  listOrgPublicKeys: () => Promise<unknown>;
+  approveOrgPublicKey: (fingerprint: string) => Promise<unknown>;
+  rejectOrgPublicKey: (fingerprint: string) => Promise<unknown>;
+  authorizeCommandSigningKey: (fingerprint: string) => Promise<unknown>;
+  revokeCommandSigningKey: (fingerprint: string) => Promise<unknown>;
+  getActivityEvents: () => Promise<unknown>;
+  clearActivityEvents: () => Promise<unknown>;
+  getPendingApprovals: () => Promise<unknown>;
+  approveApproval: (approvalId: string) => Promise<unknown>;
+  denyApproval: (approvalId: string) => Promise<unknown>;
+  alwaysAllowApproval: (approvalId: string) => Promise<unknown>;
+  clearPendingApprovals: () => Promise<unknown>;
+  getResolvedApprovals: () => Promise<unknown>;
+  clearResolvedApprovals: () => Promise<unknown>;
+  getApiKeyStatus: () => Promise<unknown>;
+  setApiKey: (apiKey: string) => Promise<unknown>;
+  clearApiKey: () => Promise<unknown>;
+  getCloudCommandsPaused: () => Promise<unknown>;
+  setCloudCommandsPaused: (paused: boolean) => Promise<unknown>;
+  getCloudConnectionEnabled: () => Promise<unknown>;
+  setCloudConnectionEnabled: (enabled: boolean) => Promise<unknown>;
+  getOnboardingState: () => Promise<unknown>;
+  completeOnboarding: (payload: unknown) => Promise<unknown>;
+  startDeviceOnboarding: (payload: unknown) => Promise<unknown>;
+  dismissOnboardingPopup: (payload: { permanent: boolean }) => Promise<unknown>;
+  onboardingPopupCta: () => Promise<unknown>;
+  pickSandboxDirectory: () => Promise<SandboxInspectResult | null>;
+  inspectSandboxPath: (path: string) => Promise<SandboxInspectResult | null>;
+  getDangerousAutoApprove: () => Promise<boolean>;
+  setDangerousAutoApprove: (enabled: boolean) => Promise<boolean>;
+  removeAlwaysAllowRule: (ruleId: string) => Promise<unknown>;
+  checkForUpdate: () => Promise<unknown>;
+  applyUpdate: () => Promise<unknown>;
+  isDebugAuthEnabled: () => Promise<boolean>;
+  mintDebugToken: (origin?: string) => Promise<unknown>;
+  listRunningJobs: () => Promise<unknown>;
+  listCompletedJobs: () => Promise<unknown>;
+  getJob: (jobId: string) => Promise<unknown>;
+  getJobLogTail: (jobId: string, lines?: number) => Promise<unknown>;
+  getLogs: () => Promise<unknown>;
+  clearLogs: () => Promise<unknown>;
+  getLogFilePath: () => Promise<string>;
+  openLogFile: () => Promise<unknown>;
+  getAppVersion: () => Promise<string>;
+  getBinaryPaths: () => Promise<unknown>;
+  patchBinaryPaths: (patch: unknown) => Promise<unknown>;
+  detectCliTools: () => Promise<unknown>;
+  saveConfig: (name: string) => Promise<unknown>;
+  findMatchingConfig: () => Promise<unknown>;
+  listConfigs: () => Promise<unknown>;
+  deleteConfig: (id: string) => Promise<unknown>;
+  renameConfig: (id: string, name: string) => Promise<unknown>;
+  applyConfig: (id: string) => Promise<unknown>;
+  getAgentMonitorUrl: () => Promise<AgentMonitorUrl>;
+  openAgentMonitor: () => Promise<unknown>;
+  getAgentMonitorHooksEnabled: () => Promise<boolean>;
+  setAgentMonitorHooksEnabled: (enabled: boolean) => Promise<AgentMonitorHookResult>;
+  getAgentMonitorCodexHooksOptIn: () => Promise<boolean>;
+  setAgentMonitorCodexHooksOptIn: (optIn: boolean) => Promise<AgentMonitorHookResult>;
+  /** @deprecated Replaced by in-process SQLite database */
+  getAgentMonitorData?: (query: string) => Promise<unknown>;
+  /** Database IPC channels (typed against the in-process repository shapes). */
+  db: {
+    getSessions: () => Promise<SessionRow[]>;
+    getSession: (id: string) => Promise<SessionRow | undefined>;
+    getAgents: (sessionId: string) => Promise<AgentRow[]>;
+    getEvents: (sessionId: string, agentId?: string) => Promise<EventRow[]>;
+    getDashboardSummary: () => Promise<DashboardSummary>;
+    getSessionsWithDetails: () => Promise<SessionWithAgents[]>;
+    getEventFeed: () => Promise<EventWithSession[]>;
+    getEventsWithSession: (sessionId: string) => Promise<EventWithSession[]>;
+    getEventCountByType: () => Promise<EventCountByType[]>;
+    getTokenAnalytics: () => Promise<TokenAnalytics>;
+    getAgentHierarchy: (sessionId: string) => Promise<AgentHierarchyNode[]>;
+    getAnalytics: () => Promise<AnalyticsData>;
+    getWorkflowData: () => Promise<WorkflowQueryData>;
+  };
+  /** Live DB-change push subscription; returns an unsubscribe fn. */
+  onDbChanged: (callback: (payload: { sessionId?: string }) => void) => () => void;
+}
+
+declare global {
+  interface Window {
+    desktopApi: DesktopApi;
+  }
+}
diff --git a/apps/desktop/src/renderer/vite-env.d.ts b/apps/desktop/src/renderer/vite-env.d.ts
new file mode 100644
index 00000000..11f02fe2
--- /dev/null
+++ b/apps/desktop/src/renderer/vite-env.d.ts
@@ -0,0 +1 @@
+/// <reference types="vite/client" />
diff --git a/apps/desktop/src/shared/agent-db-contract.ts b/apps/desktop/src/shared/agent-db-contract.ts
new file mode 100644
index 00000000..797aad0f
--- /dev/null
+++ b/apps/desktop/src/shared/agent-db-contract.ts
@@ -0,0 +1,194 @@
+// Renderer-facing agent-database IPC contract.
+//
+// These are the response DTOs returned by the `desktop:db:*` IPC handlers and
+// consumed by the first-party renderer (`src/renderer/`). They are the stable
+// shared contract between main and renderer — the renderer MUST import its DB
+// response shapes from here, NOT from `src/main/database/types.ts`.
+//
+// Raw persistence rows (the untyped `Record<string, unknown>` produced by
+// `node:sqlite`) are private to `src/main/database/`. Each repository store maps
+// those raw rows into the DTOs below via its `toRow()` helper, so a SQLite
+// schema/column change is absorbed at that boundary and does not break the
+// renderer's compile-time contract. Purely-internal row types that never cross
+// IPC (e.g. `TokenUsageRow`) stay in `src/main/database/types.ts`.
+
+export interface SessionRow {
+  id: string;
+  name: string | null;
+  status: string;
+  cwd: string | null;
+  model: string | null;
+  startedAt: string | null;
+  updatedAt: string | null;
+  endedAt: string | null;
+  awaitingInputSince: string | null;
+  metadata: string | null;
+  harness: string | null;
+  billingMode: string | null;
+}
+
+export interface AgentRow {
+  id: string;
+  sessionId: string;
+  name: string | null;
+  type: string | null;
+  subagentType: string | null;
+  status: string;
+  task: string | null;
+  currentTool: string | null;
+  startedAt: string | null;
+  updatedAt: string | null;
+  endedAt: string | null;
+  awaitingInputSince: string | null;
+  parentAgentId: string | null;
+  metadata: string | null;
+}
+
+export interface EventRow {
+  id: string;
+  sessionId: string;
+  agentId: string | null;
+  eventType: string;
+  toolName: string | null;
+  summary: string | null;
+  data: string | null;
+  createdAt: string | null;
+}
+
+export interface DashboardSummary {
+  totalSessions: number;
+  activeSessions: number;
+  totalAgents: number;
+  totalEvents: number;
+  eventTypeCount: number;
+  totalTokens: number;
+  recentSessions: Array<{
+    id: string;
+    name: string | null;
+    status: string;
+    model: string | null;
+    cwd: string | null;
+    startedAt: string | null;
+  }>;
+}
+
+export interface SessionWithAgents extends SessionRow {
+  agentCount: number;
+  eventCount: number;
+  totalTokens: number;
+}
+
+export interface EventWithSession extends EventRow {
+  sessionName: string | null;
+}
+
+export interface TokenAnalytics {
+  totalInputTokens: number;
+  totalOutputTokens: number;
+  totalCacheReadTokens: number;
+  totalCacheWriteTokens: number;
+  byModel: Array<{
+    model: string;
+    inputTokens: number;
+    outputTokens: number;
+    sessions: number;
+  }>;
+  byDay: Array<{
+    day: string;
+    inputTokens: number;
+    outputTokens: number;
+  }>;
+}
+
+export interface EventCountByType {
+  eventType: string;
+  count: number;
+}
+
+export interface ToolUsageItem {
+  toolName: string;
+  count: number;
+}
+
+export interface DailyEventCount {
+  date: string;
+  count: number;
+}
+
+export interface StatusCount {
+  status: string;
+  count: number;
+}
+
+export interface AgentTypeCount {
+  type: string;
+  count: number;
+}
+
+export interface AnalyticsData {
+  tokens: TokenAnalytics;
+  eventsByType: EventCountByType[];
+  toolUsage: ToolUsageItem[];
+  dailyEvents: DailyEventCount[];
+  sessionsByStatus: StatusCount[];
+  agentsByStatus: StatusCount[];
+  agentsByType: AgentTypeCount[];
+  totalSessions: number;
+  totalAgents: number;
+  totalEvents: number;
+}
+
+export interface WorkflowQueryData {
+  stats: {
+    totalSessions: number;
+    totalAgents: number;
+    totalSubagents: number;
+    avgSubagents: number;
+    successRate: number;
+    avgDepth: number;
+    avgDurationSec: number;
+    totalCompactions: number;
+    avgCompactions: number;
+    topFlow: { source: string; target: string; count: number } | null;
+  };
+  orchestration: {
+    sessionCount: number;
+    mainCount: number;
+    subagentTypes: Array<{ subagentType: string; count: number; completed: number; errors: number }>;
+    edges: Array<{ source: string; target: string; weight: number }>;
+    outcomes: Array<{ status: string; count: number }>;
+    compactions: { total: number; sessions: number };
+  };
+  toolFlow: {
+    transitions: Array<{ source: string; target: string; value: number }>;
+    toolCounts: Array<{ toolName: string; count: number }>;
+  };
+  effectiveness: Array<{
+    subagentType: string;
+    total: number;
+    completed: number;
+    errors: number;
+    sessions: number;
+    successRate: number;
+    avgDuration: number | null;
+    trend: number[];
+  }>;
+  cooccurrence: Array<{ source: string; target: string; weight: number }>;
+}
+
+export interface AgentHierarchyNode {
+  agentId: string;
+  name: string | null;
+  type: string | null;
+  subagentType: string | null;
+  status: string;
+  task: string | null;
+  currentTool: string | null;
+  children: AgentHierarchyNode[];
+  events: Array<{
+    eventType: string;
+    toolName: string | null;
+    summary: string | null;
+    createdAt: string | null;
+  }>;
+}
diff --git a/apps/desktop/src/shared/contracts.ts b/apps/desktop/src/shared/contracts.ts
index b279781a..56140014 100644
--- a/apps/desktop/src/shared/contracts.ts
+++ b/apps/desktop/src/shared/contracts.ts
@@ -161,8 +161,10 @@ export interface DesktopSettings {
   dashboardWelcomeSeen: boolean;
   cloudCommandsPaused: boolean;
   cloudConnectionEnabled: boolean;
-  /** Enables the Claude Dashboard sidecar/tab. Off by default. */
+  /** Enables the legacy sidecar-backed Agent Dashboard experience. On by default. */
   agentMonitorEnabled: boolean;
+  /** Opts into the in-process design-system Agent Dashboard. Labs-only and off by default. */
+  agentDashboardDesignSystemEnabled: boolean;
   /** Host-owned opt-in for Plans / plan extraction UI in the embedded Agent Dashboard. */
   planExtractionEnabled: boolean;
   /** Desktop-local opt-in that requires trusted browser command signatures. */
@@ -208,6 +210,7 @@ export const DEFAULT_DESKTOP_SETTINGS: DesktopSettings = {
   cloudCommandsPaused: false,
   cloudConnectionEnabled: true,
   agentMonitorEnabled: true,
+  agentDashboardDesignSystemEnabled: false,
   planExtractionEnabled: false,
   commandSigningEnforcementEnabled: false,
   defaultApprovalTier: "high",
diff --git a/apps/desktop/src/shared/feature-flags.ts b/apps/desktop/src/shared/feature-flags.ts
index 81118183..4f217ef1 100644
--- a/apps/desktop/src/shared/feature-flags.ts
+++ b/apps/desktop/src/shared/feature-flags.ts
@@ -12,7 +12,7 @@ export interface FlagDefinition {
   default: boolean;
   label: string;
   description: string;
-  category: "Cloud" | "Diagnostics" | "Experimental" | "Security";
+  category: "Cloud" | "Diagnostics" | "Experimental" | "Labs" | "Security";
   /** If true, flag requires an app restart to take full effect. */
   requiresRestart?: boolean;
   /** Env var that overrides the persisted value when set to "1"/"0"/"true"/"false". */
@@ -29,6 +29,15 @@ const FEATURE_FLAGS_INTERNAL = [
     category: "Diagnostics" as const,
     requiresRestart: true,
   },
+  {
+    key: "agentDashboardDesignSystemEnabled" as const,
+    default: false,
+    label: "Agent Dashboard Design System",
+    description:
+      "Use the in-process design-system Agent Dashboard instead of the legacy sidecar dashboard.",
+    category: "Labs" as const,
+    requiresRestart: true,
+  },
   {
     key: "planExtractionEnabled" as const,
     default: false,
diff --git a/apps/desktop/test-e2e/agent-monitor/inventory/PHASE3-RENDERER-MAP.md b/apps/desktop/test-e2e/agent-monitor/inventory/PHASE3-RENDERER-MAP.md
index 3e184f52..09357217 100644
--- a/apps/desktop/test-e2e/agent-monitor/inventory/PHASE3-RENDERER-MAP.md
+++ b/apps/desktop/test-e2e/agent-monitor/inventory/PHASE3-RENDERER-MAP.md
@@ -132,4 +132,3 @@
 | `kanban.agents.waiting.count` | — | ✅ text | `upstream/KanbanBoard.tsx:397` | column count badge | groupedAgents['waiting']?.length ?? 0 |
 | `kanban.agents.completed.count` | — | ✅ text | `upstream/KanbanBoard.tsx:397` | column count badge | groupedAgents['completed']?.length ?? 0 |
 | `kanban.agents.error.count` | — | ✅ text | `upstream/KanbanBoard.tsx:397` | column count badge | groupedAgents['error']?.length ?? 0 |
-
diff --git a/apps/desktop/test-e2e/agent-monitor/inventory/PHASE3-WEAK-TRIAGE.md b/apps/desktop/test-e2e/agent-monitor/inventory/PHASE3-WEAK-TRIAGE.md
index a9aaaaf4..b6e538a2 100644
--- a/apps/desktop/test-e2e/agent-monitor/inventory/PHASE3-WEAK-TRIAGE.md
+++ b/apps/desktop/test-e2e/agent-monitor/inventory/PHASE3-WEAK-TRIAGE.md
@@ -154,4 +154,3 @@ PLN-738/FEA-1437 set a target of driving `cross_ref_weak` to 0. This triage show
 | Analytics | toLocaleString | `s.value` | `upstream/Analytics.tsx:1263` | chart/sparkline/breakdown series aggregate of token/cost/event data that IS oracle-backed at the API layer, but renders as a chart (no sliceable per-value DOM) — needs explicit covered-by annotation, will NOT auto-resolve via selector binding |
 | Analytics | math | `Math.max(` | `upstream/Analytics.tsx:1286` | chart/sparkline/breakdown series aggregate of token/cost/event data that IS oracle-backed at the API layer, but renders as a chart (no sliceable per-value DOM) — needs explicit covered-by annotation, will NOT auto-resolve via selector binding |
 | Workflows | math | `Math.max(` | `upstream/Workflows.tsx:344` | chart/sparkline/breakdown series aggregate of token/cost/event data that IS oracle-backed at the API layer, but renders as a chart (no sliceable per-value DOM) — needs explicit covered-by annotation, will NOT auto-resolve via selector binding |
-
diff --git a/apps/desktop/test/agent-dashboard-boundary.test.ts b/apps/desktop/test/agent-dashboard-boundary.test.ts
new file mode 100644
index 00000000..99a09190
--- /dev/null
+++ b/apps/desktop/test/agent-dashboard-boundary.test.ts
@@ -0,0 +1,275 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { test } from "node:test";
+import { fileURLToPath } from "node:url";
+import ts from "typescript";
+
+const appDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const srcDir = path.join(appDir, "src");
+const bootEntries = [
+  "src/main/index.ts",
+  "src/main/app.ts",
+  "src/main/window.ts",
+  "src/main/preload.ts",
+].map((relativePath) => path.join(appDir, relativePath));
+
+function readSource(relativePath: string): string {
+  return fs.readFileSync(path.join(appDir, relativePath), "utf8");
+}
+
+function toRelative(filePath: string): string {
+  return path.relative(appDir, filePath).split(path.sep).join("/");
+}
+
+function isTypeOnlyImport(node: ts.ImportDeclaration): boolean {
+  const importClause = node.importClause;
+  if (!importClause) {
+    return false;
+  }
+  if (importClause.isTypeOnly) {
+    return true;
+  }
+  if (importClause.name) {
+    return false;
+  }
+  const bindings = importClause.namedBindings;
+  return (
+    bindings != null &&
+    ts.isNamedImports(bindings) &&
+    bindings.elements.length > 0 &&
+    bindings.elements.every((element) => element.isTypeOnly)
+  );
+}
+
+function resolveLocalImport(importer: string, specifier: string): string | null {
+  if (!specifier.startsWith(".")) {
+    return null;
+  }
+
+  const basePath = path.resolve(path.dirname(importer), specifier);
+  const candidates = specifier.endsWith(".js")
+    ? [basePath.replace(/\.js$/, ".ts"), basePath.replace(/\.js$/, ".tsx")]
+    : [
+        `${basePath}.ts`,
+        `${basePath}.tsx`,
+        path.join(basePath, "index.ts"),
+      ];
+
+  return candidates.find((candidate) => fs.existsSync(candidate)) ?? null;
+}
+
+function staticValueImports(filePath: string): string[] {
+  const source = fs.readFileSync(filePath, "utf8");
+  const ast = ts.createSourceFile(
+    filePath,
+    source,
+    ts.ScriptTarget.ES2023,
+    true,
+    ts.ScriptKind.TS,
+  );
+  const imports: string[] = [];
+
+  for (const statement of ast.statements) {
+    if (
+      ts.isImportDeclaration(statement) &&
+      ts.isStringLiteral(statement.moduleSpecifier) &&
+      !isTypeOnlyImport(statement)
+    ) {
+      const resolved = resolveLocalImport(
+        filePath,
+        statement.moduleSpecifier.text,
+      );
+      if (resolved) {
+        imports.push(resolved);
+      }
+    }
+  }
+
+  return imports;
+}
+
+function isDesignSystemRuntimeModule(filePath: string): boolean {
+  const relativePath = toRelative(filePath);
+  return (
+    relativePath === "src/main/agent-dashboard-design-system-runtime.ts" ||
+    relativePath === "src/main/agent-monitor-listener.ts" ||
+    relativePath.startsWith("src/main/collectors/") ||
+    relativePath.startsWith("src/main/database/")
+  );
+}
+
+test("boot files do not statically import design-system dashboard runtime modules", () => {
+  assert.deepEqual(
+    collectDesignSystemRuntimeImportViolations(bootEntries),
+    [],
+  );
+});
+
+test("design-system import graph guard rejects value imports used only as types", () => {
+  const fixtureDir = fs.mkdtempSync(
+    path.join(tmpdir(), "agent-dashboard-boundary-"),
+  );
+  const runtimeSpecifier = toImportSpecifier(
+    fixtureDir,
+    path.join(appDir, "src/main/agent-dashboard-design-system-runtime.js"),
+  );
+  const valueImportFixture = path.join(fixtureDir, "value-import.ts");
+  const typeImportFixture = path.join(fixtureDir, "type-import.ts");
+
+  try {
+    fs.writeFileSync(
+      valueImportFixture,
+      [
+        `import { AgentDashboardDesignSystemRuntime } from "${runtimeSpecifier}";`,
+        "type Runtime = AgentDashboardDesignSystemRuntime;",
+        "export type { Runtime };",
+      ].join("\n"),
+    );
+    fs.writeFileSync(
+      typeImportFixture,
+      [
+        `import type { AgentDashboardDesignSystemRuntime } from "${runtimeSpecifier}";`,
+        "type Runtime = AgentDashboardDesignSystemRuntime;",
+        "export type { Runtime };",
+      ].join("\n"),
+    );
+
+    assert.deepEqual(
+      collectDesignSystemRuntimeImportViolations(
+        [typeImportFixture],
+        [fixtureDir, srcDir],
+      ),
+      [],
+    );
+    assert.deepEqual(
+      collectDesignSystemRuntimeImportViolations(
+        [valueImportFixture],
+        [fixtureDir, srcDir],
+      ),
+      [
+        `${toRelative(valueImportFixture)} -> src/main/agent-dashboard-design-system-runtime.ts`,
+      ],
+    );
+  } finally {
+    fs.rmSync(fixtureDir, { recursive: true, force: true });
+  }
+});
+
+function collectDesignSystemRuntimeImportViolations(
+  entries: string[],
+  allowedRoots = [srcDir],
+): string[] {
+  const visited = new Set<string>();
+  const queue = [...entries];
+  const violations: string[] = [];
+
+  while (queue.length > 0) {
+    const filePath = queue.shift()!;
+    if (visited.has(filePath) || !isInsideAnyRoot(filePath, allowedRoots)) {
+      continue;
+    }
+    visited.add(filePath);
+
+    for (const imported of staticValueImports(filePath)) {
+      if (isDesignSystemRuntimeModule(imported)) {
+        violations.push(`${toRelative(filePath)} -> ${toRelative(imported)}`);
+        continue;
+      }
+      queue.push(imported);
+    }
+  }
+
+  return violations;
+}
+
+function isInsideAnyRoot(filePath: string, roots: string[]): boolean {
+  return roots.some((root) => {
+    const relative = path.relative(root, filePath);
+    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+  });
+}
+
+function toImportSpecifier(fromDir: string, targetJsPath: string): string {
+  let specifier = path.relative(fromDir, targetJsPath).split(path.sep).join("/");
+  if (!specifier.startsWith(".")) {
+    specifier = `./${specifier}`;
+  }
+  return specifier;
+}
+
+test("design-system dashboard side effects stay behind explicit mode gates", () => {
+  const appSource = readSource("src/main/app.ts");
+  const indexSource = readSource("src/main/index.ts");
+  const preloadSource = readSource("src/main/preload.ts");
+  const preloadCommonSource = readSource("src/main/preload-common.ts");
+  const preloadDesignSystemSource = readSource("src/main/preload-design-system.ts");
+  const windowSource = readSource("src/main/window.ts");
+
+  assert.doesNotMatch(appSource, /ipcMain\.handle\("desktop:db:/);
+  assert.match(
+    appSource,
+    /await import\(\s*"\.\/agent-dashboard-design-system-runtime\.js"\s*\)/,
+  );
+  assert.match(
+    indexSource,
+    /if \(shouldRegisterDesignSystemScheme\(\)\) \{\s*protocol\.registerSchemesAsPrivileged/s,
+  );
+  assert.doesNotMatch(preloadSource, /desktop:db:/);
+  assert.doesNotMatch(preloadCommonSource, /desktop:db:/);
+  assert.match(preloadSource, /exposeDesktopApi\(\)/);
+  assert.match(preloadDesignSystemSource, /desktop:db:get-sessions/);
+  assert.match(preloadDesignSystemSource, /desktop:db:changed/);
+  assert.match(
+    windowSource,
+    /agentDashboardMode === "design-system"[\s\S]*--closedloop-agent-dashboard-design-system/,
+  );
+  assert.match(windowSource, /preload-design-system\.js/);
+  assert.match(windowSource, /preload\.js/);
+  assert.match(
+    windowSource,
+    /agentDashboardMode !== "design-system"[\s\S]*const rendererPath = resolveLegacyRendererPath\(\)[\s\S]*loadFile\(rendererPath\)/,
+  );
+  assert.match(designSystemRuntimeSource(), /ipcMain\.removeHandler\(channel\)/);
+  assert.match(
+    appSource,
+    /stopAgentCapture\(\{ closeDesignSystem: true \}\)/,
+  );
+  assert.match(
+    appSource,
+    /reloadForAgentDashboardMode\("disabled"\)/,
+  );
+  assert.match(windowSource, /unhandle\?\: \(scheme: string\) => void/);
+  assert.match(windowSource, /protocolWithUnhandle\.unhandle\(APP_PROTOCOL\)/);
+});
+
+function designSystemRuntimeSource(): string {
+  return readSource("src/main/agent-dashboard-design-system-runtime.ts");
+}
+
+test("design-system BrowserWindow protocol and navigation guards are fail-closed", () => {
+  const windowSource = readSource("src/main/window.ts");
+
+  assert.match(windowSource, /request\.method !== "GET"/);
+  assert.match(windowSource, /url\.hostname !== "renderer"/);
+  assert.match(windowSource, /decodeURIComponent\(url\.pathname\)/);
+  assert.match(windowSource, /startsWith\("\/design-system\/"\)/);
+  assert.match(windowSource, /pathParts\.includes\("\.\."\)/);
+  assert.match(windowSource, /APP_PROTOCOL_EXTENSIONS\.has\(ext\)/);
+  assert.match(windowSource, /realpathSync\(DESIGN_RENDERER_DIR\)/);
+  assert.match(windowSource, /statSync\(realFile\)\.isFile\(\)/);
+  assert.match(windowSource, /isPathInside\(realFile, realRoot\)/);
+  assert.match(windowSource, /new URL\(url\)\.href === this\.allowedRendererUrl/);
+  assert.match(windowSource, /parsed\.protocol === "https:"/);
+  assert.match(windowSource, /EXTERNAL_LINK_HOSTS\.has\(parsed\.hostname\)/);
+  assert.doesNotMatch(windowSource, /parsed\.protocol === "file:"/);
+  assert.doesNotMatch(
+    windowSource,
+    /parsed\.protocol === "app:" && parsed\.hostname === "renderer"/,
+  );
+  assert.doesNotMatch(
+    windowSource,
+    /parsed\.protocol === "http:" \|\| parsed\.protocol === "https:"/,
+  );
+});
diff --git a/apps/desktop/test/agent-monitor-hooks-core.test.ts b/apps/desktop/test/agent-monitor-hooks-core.test.ts
new file mode 100644
index 00000000..74e9013c
--- /dev/null
+++ b/apps/desktop/test/agent-monitor-hooks-core.test.ts
@@ -0,0 +1,276 @@
+// FEA-1444 regression coverage for the electron-free hook-install core.
+// The outer agent-monitor-hooks.ts shell imports `electron`, which the
+// `tsx --test` runner cannot load. The core module owns the install/uninstall
+// logic in isolation so the behavior contract — idempotent install, in-place
+// self-heal of a moved handler path, narrow-scope uninstall that leaves
+// foreign entries alone, and clean separation between Claude and Codex
+// handler identity — can be exercised here without an Electron runtime.
+
+import assert from "node:assert/strict";
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, test } from "node:test";
+
+import {
+  applyHookInstall,
+  applyHookUninstall,
+  CODEX_HOOK_TYPES,
+  CODEX_SESSION_START_MATCHER,
+  HOOK_TYPES,
+  isClaudeEntry,
+  isCodexEntry,
+  makeClaudeHookEntry,
+  makeCodexHookEntry,
+} from "../src/main/agent-monitor-hooks-core.js";
+
+let tempRoot = "";
+const FAKE_EXEC = "/fake/Electron";
+const CLAUDE_HANDLER = "/fake/userData/agent-monitor/hook-handler.js";
+const CODEX_HANDLER = "/fake/userData/agent-monitor/codex-hook-handler.js";
+
+beforeEach(() => {
+  tempRoot = mkdtempSync(join(tmpdir(), "fea1444-hooks-"));
+});
+
+afterEach(() => {
+  if (tempRoot) {
+    rmSync(tempRoot, { recursive: true, force: true });
+  }
+});
+
+function readJson(file: string): Record<string, unknown> {
+  return JSON.parse(readFileSync(file, "utf8")) as Record<string, unknown>;
+}
+
+test("isClaudeEntry / isCodexEntry distinguish handler identities", () => {
+  const claudeCmd =
+    `ELECTRON_RUN_AS_NODE=1 "${FAKE_EXEC}" "${CLAUDE_HANDLER}" "SessionStart"`;
+  const codexCmd =
+    `ELECTRON_RUN_AS_NODE=1 "${FAKE_EXEC}" "${CODEX_HANDLER}" "SessionStart"`;
+
+  const claudeEntry = { hooks: [{ type: "command", command: claudeCmd }] };
+  const codexEntry = { hooks: [{ type: "command", command: codexCmd }] };
+
+  assert.equal(isClaudeEntry(claudeEntry), true);
+  assert.equal(isClaudeEntry(codexEntry), false);
+  assert.equal(isCodexEntry(codexEntry), true);
+  assert.equal(isCodexEntry(claudeEntry), false);
+});
+
+test("makeClaudeHookEntry applies '*' matcher only to gated events", () => {
+  const tooled = makeClaudeHookEntry(FAKE_EXEC, CLAUDE_HANDLER, "PreToolUse");
+  assert.equal(tooled.matcher, "*");
+  const sessionStart = makeClaudeHookEntry(
+    FAKE_EXEC,
+    CLAUDE_HANDLER,
+    "SessionStart",
+  );
+  assert.equal(sessionStart.matcher, undefined);
+});
+
+test("makeCodexHookEntry uses startup|resume matcher for SessionStart", () => {
+  const sessionStart = makeCodexHookEntry(
+    FAKE_EXEC,
+    CODEX_HANDLER,
+    "SessionStart",
+  );
+  assert.equal(sessionStart.matcher, CODEX_SESSION_START_MATCHER);
+
+  const tooled = makeCodexHookEntry(FAKE_EXEC, CODEX_HANDLER, "PreToolUse");
+  assert.equal(tooled.matcher, "*");
+
+  const stop = makeCodexHookEntry(FAKE_EXEC, CODEX_HANDLER, "Stop");
+  // Codex Stop / UserPromptSubmit ignore matchers — must NOT emit one.
+  assert.equal(stop.matcher, undefined);
+});
+
+test("applyHookInstall creates a fresh settings file with all hook types", () => {
+  const file = join(tempRoot, "settings.json");
+  const result = applyHookInstall({
+    file,
+    hookTypes: HOOK_TYPES,
+    isOurEntry: isClaudeEntry,
+    makeEntry: (h) => makeClaudeHookEntry(FAKE_EXEC, CLAUDE_HANDLER, h),
+  });
+  assert.equal(result.installed, HOOK_TYPES.length);
+  assert.equal(result.repaired, 0);
+
+  const settings = readJson(file) as {
+    hooks: Record<string, unknown[]>;
+  };
+  for (const hookType of HOOK_TYPES) {
+    assert.equal(settings.hooks[hookType].length, 1);
+    assert.equal(isClaudeEntry(settings.hooks[hookType][0]), true);
+  }
+});
+
+test("applyHookInstall is idempotent: re-running self-heals a moved handler path", () => {
+  const file = join(tempRoot, "settings.json");
+  // First install with the original path.
+  applyHookInstall({
+    file,
+    hookTypes: HOOK_TYPES,
+    isOurEntry: isClaudeEntry,
+    makeEntry: (h) => makeClaudeHookEntry(FAKE_EXEC, CLAUDE_HANDLER, h),
+  });
+
+  // Simulate the .app moving: re-install with a different handler path. The
+  // stale entry must be replaced in place (NOT appended) so the file does
+  // not grow unboundedly across upgrades.
+  const newHandler = "/fake/userData2/agent-monitor/hook-handler.js";
+  const result = applyHookInstall({
+    file,
+    hookTypes: HOOK_TYPES,
+    isOurEntry: isClaudeEntry,
+    makeEntry: (h) => makeClaudeHookEntry(FAKE_EXEC, newHandler, h),
+  });
+  assert.equal(result.installed, 0);
+  assert.equal(result.repaired, HOOK_TYPES.length);
+
+  const settings = readJson(file) as {
+    hooks: Record<string, Array<{ hooks: Array<{ command: string }> }>>;
+  };
+  for (const hookType of HOOK_TYPES) {
+    assert.equal(settings.hooks[hookType].length, 1);
+    const cmd = settings.hooks[hookType][0].hooks[0].command;
+    assert.match(cmd, /userData2/);
+  }
+});
+
+test("applyHookInstall preserves user-installed foreign entries", () => {
+  const file = join(tempRoot, "settings.json");
+  // Pre-seed a foreign entry the user installed themselves.
+  writeFileSync(
+    file,
+    JSON.stringify({
+      hooks: {
+        PreToolUse: [
+          { hooks: [{ type: "command", command: "echo my-own-thing" }] },
+        ],
+      },
+    }),
+  );
+
+  applyHookInstall({
+    file,
+    hookTypes: HOOK_TYPES,
+    isOurEntry: isClaudeEntry,
+    makeEntry: (h) => makeClaudeHookEntry(FAKE_EXEC, CLAUDE_HANDLER, h),
+  });
+
+  const settings = readJson(file) as {
+    hooks: Record<string, Array<{ hooks: Array<{ command: string }> }>>;
+  };
+  // Foreign entry must still be present alongside ours.
+  assert.equal(settings.hooks.PreToolUse.length, 2);
+  assert.equal(
+    settings.hooks.PreToolUse[0].hooks[0].command,
+    "echo my-own-thing",
+  );
+  assert.equal(isClaudeEntry(settings.hooks.PreToolUse[1]), true);
+});
+
+test("applyHookUninstall removes only our entries and preserves foreign ones", () => {
+  const file = join(tempRoot, "settings.json");
+  // Install ours, then add a foreign entry.
+  applyHookInstall({
+    file,
+    hookTypes: HOOK_TYPES,
+    isOurEntry: isClaudeEntry,
+    makeEntry: (h) => makeClaudeHookEntry(FAKE_EXEC, CLAUDE_HANDLER, h),
+  });
+  const seeded = readJson(file) as {
+    hooks: Record<string, Array<unknown>>;
+  };
+  seeded.hooks.PreToolUse.push({
+    hooks: [{ type: "command", command: "echo my-own-thing" }],
+  });
+  writeFileSync(file, JSON.stringify(seeded));
+
+  const result = applyHookUninstall({ file, isOurEntry: isClaudeEntry });
+  assert.equal(result.removed, HOOK_TYPES.length);
+
+  const after = readJson(file) as {
+    hooks?: Record<string, Array<{ hooks: Array<{ command: string }> }>>;
+  };
+  // The only surviving event is PreToolUse, with only the foreign entry.
+  assert.deepEqual(Object.keys(after.hooks ?? {}), ["PreToolUse"]);
+  assert.equal(after.hooks?.PreToolUse.length, 1);
+  assert.equal(
+    after.hooks?.PreToolUse[0].hooks[0].command,
+    "echo my-own-thing",
+  );
+});
+
+test("applyHookUninstall deletes the hooks block when nothing remains", () => {
+  const file = join(tempRoot, "settings.json");
+  applyHookInstall({
+    file,
+    hookTypes: HOOK_TYPES,
+    isOurEntry: isClaudeEntry,
+    makeEntry: (h) => makeClaudeHookEntry(FAKE_EXEC, CLAUDE_HANDLER, h),
+  });
+  applyHookUninstall({ file, isOurEntry: isClaudeEntry });
+
+  const after = readJson(file);
+  assert.equal(
+    Object.prototype.hasOwnProperty.call(after, "hooks"),
+    false,
+    "outer `hooks` block must be removed when no entries remain",
+  );
+});
+
+test("applyHookUninstall is a no-op when the settings file does not exist", () => {
+  const result = applyHookUninstall({
+    file: join(tempRoot, "does-not-exist.json"),
+    isOurEntry: isClaudeEntry,
+  });
+  assert.equal(result.removed, 0);
+});
+
+test("Codex install does not touch Claude entries in a co-mingled file", () => {
+  // Defensive check: although Claude hooks live in ~/.claude/settings.json
+  // and Codex hooks live in ~/.codex/hooks.json under normal operation, the
+  // filename-boundary predicates must not cross-match if entries ever end
+  // up co-mingled (e.g., a future change targeting the same file).
+  const file = join(tempRoot, "settings.json");
+  applyHookInstall({
+    file,
+    hookTypes: HOOK_TYPES,
+    isOurEntry: isClaudeEntry,
+    makeEntry: (h) => makeClaudeHookEntry(FAKE_EXEC, CLAUDE_HANDLER, h),
+  });
+  const claudePreToolBefore = (readJson(file) as {
+    hooks: Record<string, Array<unknown>>;
+  }).hooks.PreToolUse.length;
+
+  applyHookInstall({
+    file,
+    hookTypes: CODEX_HOOK_TYPES,
+    isOurEntry: isCodexEntry,
+    makeEntry: (h) => makeCodexHookEntry(FAKE_EXEC, CODEX_HANDLER, h),
+  });
+
+  const settings = readJson(file) as {
+    hooks: Record<string, Array<unknown>>;
+  };
+  // Claude PreToolUse entry must still be present (now alongside the Codex
+  // one). Total count for PreToolUse should be claudePreToolBefore + 1.
+  assert.equal(
+    settings.hooks.PreToolUse.length,
+    claudePreToolBefore + 1,
+    "Codex install must not have replaced the Claude PreToolUse entry",
+  );
+
+  // Now uninstall Codex; Claude entries must remain intact.
+  applyHookUninstall({ file, isOurEntry: isCodexEntry });
+  const afterCodexUninstall = readJson(file) as {
+    hooks: Record<string, Array<unknown>>;
+  };
+  assert.equal(
+    afterCodexUninstall.hooks.PreToolUse.length,
+    claudePreToolBefore,
+    "Codex uninstall must not have touched the Claude entry",
+  );
+});
diff --git a/apps/desktop/test/agent-monitor-lifecycle.test.ts b/apps/desktop/test/agent-monitor-lifecycle.test.ts
new file mode 100644
index 00000000..d0e97cde
--- /dev/null
+++ b/apps/desktop/test/agent-monitor-lifecycle.test.ts
@@ -0,0 +1,151 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { test } from "node:test";
+import { openAgentDatabase } from "../src/main/database/index.js";
+import { createLifecycle, type HookData } from "../src/main/database/lifecycle.js";
+import type { TranscriptExtract } from "../src/main/database/transcript.js";
+
+function makeHarness(transcript?: TranscriptExtract | null) {
+  const dir = mkdtempSync(path.join(tmpdir(), "cl-lifecycle-"));
+  const db = openAgentDatabase(path.join(dir, "agent-dashboard.sqlite"));
+  const lifecycle = createLifecycle(db.connection, {
+    tokenUsage: db.tokenUsage,
+    detectBillingMode: () => "api",
+    extractTranscript: () => transcript ?? null,
+  });
+  return {
+    db,
+    lifecycle,
+    sessionStatus(id: string): string | undefined {
+      return (db.connection.prepare("SELECT status FROM sessions WHERE id = ?").get(id) as { status: string } | undefined)?.status;
+    },
+    agent(id: string) {
+      return db.connection.prepare("SELECT * FROM agents WHERE id = ?").get(id) as
+        | { status: string; current_tool: string | null; awaiting_input_since: string | null; type: string }
+        | undefined;
+    },
+    cleanup() {
+      db.close();
+      rmSync(dir, { recursive: true, force: true });
+    },
+  };
+}
+
+test("lifecycle: SessionStart creates session + main agent with harness and billing_mode", () => {
+  const h = makeHarness();
+  try {
+    h.lifecycle.processEvent("SessionStart", { session_id: "s1", cwd: "/work" } as HookData, "claude");
+    const session = h.db.sessions.getById("s1");
+    assert.ok(session, "session created");
+    assert.equal(session!.status, "active");
+    assert.equal(session!.harness, "claude");
+    assert.equal(session!.billingMode, "api");
+    const main = h.agent("s1-main");
+    assert.ok(main, "main agent created");
+    assert.equal(main!.type, "main");
+    assert.ok(main!.awaiting_input_since, "fresh session awaits the first prompt");
+  } finally {
+    h.cleanup();
+  }
+});
+
+test("lifecycle: SessionStart -> PreToolUse -> Stop -> SessionEnd status sequence", () => {
+  const h = makeHarness();
+  try {
+    h.lifecycle.processEvent("SessionStart", { session_id: "s1", cwd: "/work" } as HookData, "claude");
+    assert.equal(h.sessionStatus("s1"), "active");
+
+    h.lifecycle.processEvent("UserPromptSubmit", { session_id: "s1" } as HookData, "claude");
+    let main = h.agent("s1-main")!;
+    assert.equal(main.status, "working", "prompt submit resumes work");
+    assert.equal(main.awaiting_input_since, null, "awaiting cleared on user activity");
+
+    h.lifecycle.processEvent("PreToolUse", { session_id: "s1", tool_name: "Bash" } as HookData, "claude");
+    main = h.agent("s1-main")!;
+    assert.equal(main.current_tool, "Bash");
+    assert.equal(main.status, "working");
+
+    h.lifecycle.processEvent("PostToolUse", { session_id: "s1", tool_name: "Bash" } as HookData, "claude");
+    main = h.agent("s1-main")!;
+    assert.equal(main.current_tool, null, "tool cleared after use");
+
+    h.lifecycle.processEvent("Stop", { session_id: "s1" } as HookData, "claude");
+    main = h.agent("s1-main")!;
+    assert.equal(main.status, "waiting", "turn end -> waiting");
+    assert.ok(main.awaiting_input_since, "awaiting stamped on turn end");
+    assert.equal(h.sessionStatus("s1"), "active", "session stays active between turns");
+
+    h.lifecycle.processEvent("SessionEnd", { session_id: "s1" } as HookData, "claude");
+    assert.equal(h.sessionStatus("s1"), "completed");
+    assert.equal(h.agent("s1-main")!.status, "completed");
+  } finally {
+    h.cleanup();
+  }
+});
+
+test("lifecycle: Stop with error marks session and main as error", () => {
+  const h = makeHarness();
+  try {
+    h.lifecycle.processEvent("SessionStart", { session_id: "s1", cwd: "/work" } as HookData, "claude");
+    h.lifecycle.processEvent("Stop", { session_id: "s1", stop_reason: "error" } as HookData, "claude");
+    assert.equal(h.sessionStatus("s1"), "error");
+    assert.equal(h.agent("s1-main")!.status, "error");
+  } finally {
+    h.cleanup();
+  }
+});
+
+test("lifecycle: subagent spawn on Task tool, completed on SubagentStop", () => {
+  const h = makeHarness();
+  try {
+    h.lifecycle.processEvent("SessionStart", { session_id: "s1", cwd: "/work" } as HookData, "claude");
+    h.lifecycle.processEvent("UserPromptSubmit", { session_id: "s1" } as HookData, "claude");
+    h.lifecycle.processEvent(
+      "PreToolUse",
+      { session_id: "s1", tool_name: "Task", tool_input: { subagent_type: "explorer", prompt: "explore the repo" } } as HookData,
+      "claude",
+    );
+    const subs = h.db.agents.getBySession("s1").filter((a) => a.type === "subagent");
+    assert.equal(subs.length, 1, "one subagent spawned");
+    assert.equal(subs[0].subagentType, "explorer");
+    assert.equal(subs[0].status, "working");
+
+    h.lifecycle.processEvent("SubagentStop", { session_id: "s1", agent_type: "explorer" } as HookData, "claude");
+    const after = h.db.agents.getBySession("s1").filter((a) => a.type === "subagent");
+    assert.equal(after[0].status, "completed", "matched subagent completed");
+  } finally {
+    h.cleanup();
+  }
+});
+
+test("lifecycle: transcript token usage is written and session model synced", () => {
+  const transcript: TranscriptExtract = {
+    tokensByModel: new Map([["claude-sonnet-4-6", { input: 1200, output: 340, cacheRead: 50, cacheWrite: 10 }]]),
+    latestModel: "claude-sonnet-4-6",
+    compactionCount: 0,
+  };
+  const h = makeHarness(transcript);
+  try {
+    h.lifecycle.processEvent("SessionStart", { session_id: "s1", cwd: "/work" } as HookData, "claude");
+    h.lifecycle.processEvent("Stop", { session_id: "s1", transcript_path: "/tmp/x.jsonl" } as HookData, "claude");
+    const rows = h.db.tokenUsage.getBySession("s1");
+    assert.equal(rows.length, 1);
+    assert.equal(rows[0].inputTokens, 1200);
+    assert.equal(rows[0].model, "claude-sonnet-4-6");
+    assert.equal(h.db.sessions.getById("s1")!.model, "claude-sonnet-4-6", "session model synced from transcript");
+  } finally {
+    h.cleanup();
+  }
+});
+
+test("lifecycle: ignores events without a session_id and never throws", () => {
+  const h = makeHarness();
+  try {
+    assert.equal(h.lifecycle.processEvent("Stop", {} as HookData, "claude"), false);
+    assert.equal(h.db.sessions.getAll().length, 0);
+  } finally {
+    h.cleanup();
+  }
+});
diff --git a/apps/desktop/test/agent-monitor-listener.test.ts b/apps/desktop/test/agent-monitor-listener.test.ts
new file mode 100644
index 00000000..cc7c78ea
--- /dev/null
+++ b/apps/desktop/test/agent-monitor-listener.test.ts
@@ -0,0 +1,225 @@
+import assert from "node:assert/strict";
+import http from "node:http";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { test } from "node:test";
+import { openAgentDatabase } from "../src/main/database/index.js";
+import { createLifecycle } from "../src/main/database/lifecycle.js";
+import { AgentHookListener } from "../src/main/agent-monitor-listener.js";
+
+interface PostResult {
+  status: number;
+  body: unknown;
+}
+
+function request(url: string, method: string, payload?: unknown): Promise<PostResult> {
+  return requestRaw(
+    url,
+    method,
+    payload === undefined ? undefined : JSON.stringify(payload),
+  );
+}
+
+function requestRaw(
+  url: string,
+  method: string,
+  data?: string,
+): Promise<PostResult> {
+  return new Promise((resolve, reject) => {
+    const u = new URL(url);
+    const req = http.request(
+      {
+        hostname: u.hostname,
+        port: u.port,
+        path: u.pathname,
+        method,
+        headers: data
+          ? {
+              "Content-Type": "application/json",
+              "Content-Length": Buffer.byteLength(data),
+            }
+          : {},
+      },
+      (res) => {
+        let raw = "";
+        res.on("data", (c) => (raw += c));
+        res.on("end", () => {
+          resolve({
+            status: res.statusCode ?? 0,
+            body: raw ? JSON.parse(raw) : null,
+          });
+        });
+      },
+    );
+    req.on("error", reject);
+    if (data) req.write(data);
+    req.end();
+  });
+}
+
+interface ListenerDiagnostics {
+  emits: string[];
+  logs: string[];
+}
+
+async function withListener(
+  sandboxBaseRef: { value: string },
+  run: (
+    url: string,
+    db: ReturnType<typeof openAgentDatabase>,
+    diagnostics: ListenerDiagnostics,
+  ) => Promise<void>,
+): Promise<void> {
+  const dir = mkdtempSync(path.join(tmpdir(), "cl-listener-"));
+  const db = openAgentDatabase(path.join(dir, "agent-dashboard.sqlite"));
+  const diagnostics: ListenerDiagnostics = { emits: [], logs: [] };
+  const lifecycle = createLifecycle(db.connection, {
+    tokenUsage: db.tokenUsage,
+    detectBillingMode: () => "api",
+    extractTranscript: () => null,
+    emit: (sessionId) => diagnostics.emits.push(sessionId),
+    log: (message) => diagnostics.logs.push(message),
+  });
+  const listener = new AgentHookListener({
+    lifecycle,
+    getSandboxBaseDirectory: () => sandboxBaseRef.value,
+    log: (message) => diagnostics.logs.push(message),
+    port: 0,
+  });
+  await listener.start();
+  const url = listener.getUrl();
+  assert.ok(url, "listener bound to an ephemeral port");
+  try {
+    await run(url!, db, diagnostics);
+  } finally {
+    await listener.stop();
+    db.close();
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+function assertNoWritesOrEmits(
+  db: ReturnType<typeof openAgentDatabase>,
+  diagnostics: ListenerDiagnostics,
+): void {
+  assert.equal(db.sessions.getAll().length, 0, "no session rows written");
+  assert.deepEqual(diagnostics.emits, [], "no live DB-change emits");
+}
+
+test("listener: GET /api/health returns 200 ok", async () => {
+  const sandbox = { value: "/work" };
+  await withListener(sandbox, async (url) => {
+    const res = await request(`${url}/api/health`, "GET");
+    assert.equal(res.status, 200);
+    assert.deepEqual(res.body, { ok: true });
+  });
+});
+
+test("listener: in-sandbox SessionStart writes a session with harness=claude", async () => {
+  const sandbox = { value: "/work" };
+  await withListener(sandbox, async (url, db, diagnostics) => {
+    const res = await request(`${url}/api/hooks/event`, "POST", {
+      hook_type: "SessionStart",
+      data: { session_id: "s1", cwd: "/work/project" },
+    });
+    assert.equal(res.status, 200);
+    const session = db.sessions.getById("s1");
+    assert.ok(session, "session written");
+    assert.equal(session!.harness, "claude");
+    assert.deepEqual(diagnostics.emits, ["s1"]);
+  });
+});
+
+test("listener: Codex route stamps harness=codex without payload provider hint", async () => {
+  const sandbox = { value: "/work" };
+  await withListener(sandbox, async (url, db, diagnostics) => {
+    const res = await request(`${url}/api/hooks/codex/event`, "POST", {
+      hook_type: "SessionStart",
+      data: { session_id: "cx1", cwd: "/work/project" },
+    });
+    assert.equal(res.status, 200);
+    assert.equal(db.sessions.getById("cx1")!.harness, "codex");
+    assert.deepEqual(diagnostics.emits, ["cx1"]);
+  });
+});
+
+test("listener: payload provider hints are rejected before writes on every hook route", async () => {
+  const sandbox = { value: "/work" };
+  await withListener(sandbox, async (url, db, diagnostics) => {
+    for (const route of ["/api/hooks/event", "/api/hooks/codex/event"]) {
+      const res = await request(`${url}${route}`, "POST", {
+        hook_type: "SessionStart",
+        data: { session_id: route, cwd: "/work/project", __provider: "codex" },
+      });
+      assert.equal(res.status, 200);
+      assert.deepEqual(res.body, { ok: true, skipped: "invalid-provider-hint" });
+      assertNoWritesOrEmits(db, diagnostics);
+    }
+  });
+});
+
+test("listener: malformed, invalid, and oversized payloads fail soft without writes", async () => {
+  const sandbox = { value: "/work" };
+  await withListener(sandbox, async (url, db, diagnostics) => {
+    const malformed = await requestRaw(
+      `${url}/api/hooks/event`,
+      "POST",
+      "{not-json-secret:super-secret-value",
+    );
+    assert.equal(malformed.status, 200);
+    assert.deepEqual(malformed.body, { ok: false });
+    assertNoWritesOrEmits(db, diagnostics);
+    assert.equal(
+      diagnostics.logs.some((message) => message.includes("super-secret-value")),
+      false,
+      "malformed-body diagnostics stay key-free",
+    );
+
+    const invalidEnvelope = await request(`${url}/api/hooks/event`, "POST", {
+      hook_type: 123,
+      data: { session_id: "invalid", cwd: "/work/project" },
+    });
+    assert.equal(invalidEnvelope.status, 200);
+    assert.deepEqual(invalidEnvelope.body, { ok: true, skipped: "invalid" });
+    assertNoWritesOrEmits(db, diagnostics);
+
+    const oversized = await requestRaw(
+      `${url}/api/hooks/event`,
+      "POST",
+      JSON.stringify({
+        hook_type: "SessionStart",
+        data: { session_id: "large", cwd: "/work/project", blob: "x".repeat(8 * 1024 * 1024) },
+      }),
+    );
+    assert.equal(oversized.status, 200);
+    assert.deepEqual(oversized.body, { ok: false });
+    assertNoWritesOrEmits(db, diagnostics);
+  });
+});
+
+test("listener: out-of-sandbox event is dropped (no write)", async () => {
+  const sandbox = { value: "/work" };
+  await withListener(sandbox, async (url, db, diagnostics) => {
+    const res = await request(`${url}/api/hooks/event`, "POST", {
+      hook_type: "SessionStart",
+      data: { session_id: "outside", cwd: "/somewhere/else" },
+    });
+    assert.equal(res.status, 200, "still acks so the hook never blocks");
+    assert.deepEqual(res.body, { ok: true, skipped: "out-of-sandbox" });
+    assertNoWritesOrEmits(db, diagnostics);
+  });
+});
+
+test("listener: empty sandbox captures nothing (fail-closed)", async () => {
+  const sandbox = { value: "" };
+  await withListener(sandbox, async (url, db, diagnostics) => {
+    const res = await request(`${url}/api/hooks/event`, "POST", {
+      hook_type: "SessionStart",
+      data: { session_id: "s1", cwd: "/work/project" },
+    });
+    assert.equal(res.status, 200);
+    assert.deepEqual(res.body, { ok: true, skipped: "out-of-sandbox" });
+    assertNoWritesOrEmits(db, diagnostics);
+  });
+});
diff --git a/apps/desktop/test/agent-monitor-token-reconciliation.test.ts b/apps/desktop/test/agent-monitor-token-reconciliation.test.ts
new file mode 100644
index 00000000..bb24ceae
--- /dev/null
+++ b/apps/desktop/test/agent-monitor-token-reconciliation.test.ts
@@ -0,0 +1,83 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { test } from "node:test";
+import { openAgentDatabase } from "../src/main/database/index.js";
+
+function makeDb() {
+  const dir = mkdtempSync(path.join(tmpdir(), "cl-tokens-"));
+  const db = openAgentDatabase(path.join(dir, "agent-dashboard.sqlite"));
+  return {
+    db,
+    cleanup() {
+      db.close();
+      rmSync(dir, { recursive: true, force: true });
+    },
+  };
+}
+
+const NOW = "2026-06-02T00:00:00.000Z";
+
+test("token reconciliation: cumulative growth adds the delta", () => {
+  const { db, cleanup } = makeDb();
+  try {
+    db.tokenUsage.replace("s1", "m1", { input: 100, output: 50, cacheRead: 10, cacheWrite: 5 }, NOW);
+    db.tokenUsage.replace("s1", "m1", { input: 150, output: 70, cacheRead: 20, cacheWrite: 5 }, NOW);
+    const [row] = db.tokenUsage.getBySession("s1");
+    assert.equal(row.inputTokens, 150, "effective input follows the cumulative");
+    assert.equal(row.outputTokens, 70);
+    assert.equal(row.cacheReadTokens, 20);
+    assert.equal(row.cacheWriteTokens, 5);
+  } finally {
+    cleanup();
+  }
+});
+
+test("token reconciliation: compaction drop adds the new segment on top of prior effective", () => {
+  const { db, cleanup } = makeDb();
+  try {
+    // First segment reaches 150 input.
+    db.tokenUsage.replace("s1", "m1", { input: 150, output: 80, cacheRead: 0, cacheWrite: 0 }, NOW);
+    // Transcript compacted: cumulative drops to 30 — the prior 150 is already
+    // counted, so effective becomes 150 + 30 = 180.
+    db.tokenUsage.replace("s1", "m1", { input: 30, output: 10, cacheRead: 0, cacheWrite: 0 }, NOW);
+    const [row] = db.tokenUsage.getBySession("s1");
+    assert.equal(row.inputTokens, 180, "compaction drop accumulates the new segment");
+    assert.equal(row.outputTokens, 90);
+  } finally {
+    cleanup();
+  }
+});
+
+test("token reconciliation: tracks each model independently and the read carries no baseline columns", () => {
+  const { db, cleanup } = makeDb();
+  try {
+    db.tokenUsage.replace("s1", "m1", { input: 100, output: 0, cacheRead: 0, cacheWrite: 0 }, NOW);
+    db.tokenUsage.replace("s1", "m2", { input: 200, output: 0, cacheRead: 0, cacheWrite: 0 }, NOW);
+    const rows = db.tokenUsage.getBySession("s1");
+    assert.equal(rows.length, 2);
+    const byModel = Object.fromEntries(rows.map((r) => [r.model, r.inputTokens]));
+    assert.deepEqual(byModel, { m1: 100, m2: 200 });
+
+    // The relay/cost-reconciliation read plain columns — assert they are the
+    // effective totals (no `+ baseline_*` needed at read time).
+    const raw = db.connection
+      .prepare("SELECT input_tokens, raw_input FROM token_usage WHERE session_id = ? AND model = ?")
+      .get("s1", "m1") as { input_tokens: number; raw_input: number };
+    assert.equal(raw.input_tokens, 100);
+    assert.equal(raw.raw_input, 100, "raw_* is the last segment cumulative");
+  } finally {
+    cleanup();
+  }
+});
+
+test("token reconciliation: all-zero counts are a no-op", () => {
+  const { db, cleanup } = makeDb();
+  try {
+    db.tokenUsage.replace("s1", "m1", { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }, NOW);
+    assert.equal(db.tokenUsage.getBySession("s1").length, 0);
+  } finally {
+    cleanup();
+  }
+});
diff --git a/apps/desktop/test/agent-monitor-wiring-static.test.ts b/apps/desktop/test/agent-monitor-wiring-static.test.ts
index c2832a29..15ad5547 100644
--- a/apps/desktop/test/agent-monitor-wiring-static.test.ts
+++ b/apps/desktop/test/agent-monitor-wiring-static.test.ts
@@ -61,9 +61,10 @@ const shutdownSource = read("../src/main/shutdown.ts");
 const stagePackagingSource = read("../scripts/stage-packaging-app.mjs");
 const thirdPartyNoticesSource = read("../../../THIRD_PARTY_NOTICES.md");
 const traySource = read("../src/main/tray.ts");
-const preloadSource = read("../src/main/preload.ts");
+const preloadSource = read("../src/main/preload-common.ts");
 const sidecarSource = read("../src/main/agent-monitor-sidecar.ts");
 const hooksSource = read("../src/main/agent-monitor-hooks.ts");
+const hooksCoreSource = read("../src/main/agent-monitor-hooks-core.ts");
 const embedAppSource = read("../scripts/agent-monitor-embed/App.tsx");
 const embedLayoutSource = read("../scripts/agent-monitor-embed/Layout.tsx");
 const contractsSource = read("../src/shared/contracts.ts");
@@ -394,6 +395,8 @@ test("agent monitor defaults on; plan extraction is feature-gated and defaults o
   // The Agent Dashboard now powers the primary Dashboard + agent nav, so the
   // sidecar defaults ON (it can still be turned off in Settings).
   assert.match(contractsSource, /agentMonitorEnabled: true/);
+  assert.match(contractsSource, /agentDashboardDesignSystemEnabled: boolean/);
+  assert.match(contractsSource, /agentDashboardDesignSystemEnabled: false/);
   assert.match(contractsSource, /planExtractionEnabled: boolean/);
   assert.match(contractsSource, /planExtractionEnabled: false/);
   assert.match(settingsStoreSource, /getAgentMonitorEnabled\(\)/);
@@ -408,14 +411,17 @@ test("agent monitor defaults on; plan extraction is feature-gated and defaults o
 });
 
 test("sidecar is feature-gated and, when enabled, starts before the gateway", () => {
-  assert.match(appSource, /this\.agentMonitor = new AgentMonitorSidecar\([\s\S]*?\)/);
   assert.match(
     appSource,
-    /if \(this\.settingsStore\.getAgentMonitorEnabled\(\)\) \{[\s\S]*void this\.agentMonitor\.start\(\);[\s\S]*syncAgentMonitorHooksOnBoot\(\);[\s\S]*this\.agentSessionSync\.start\(\);/,
+    /this\.agentDashboardMode === "legacy"[\s\S]*new AgentMonitorSidecar/,
   );
-  const startIdx = appSource.indexOf("void this.agentMonitor.start()");
+  assert.match(
+    appSource,
+    /private async startAgentCapture\(\): Promise<void> \{[\s\S]*this\.agentDashboardMode === "legacy"[\s\S]*void this\.agentMonitor\?\.start\(\);[\s\S]*syncAgentMonitorHooksOnBoot\(\);[\s\S]*this\.agentSessionSync\.start\(\);/,
+  );
+  const startIdx = appSource.indexOf("await this.startAgentCapture()");
   const gatewayTryIdx = appSource.indexOf("await this.server.start()");
-  assert.ok(startIdx > 0, "sidecar start call missing");
+  assert.ok(startIdx > 0, "agent capture start call missing");
   assert.ok(gatewayTryIdx > 0, "server.start call missing");
   assert.ok(
     startIdx < gatewayTryIdx,
@@ -426,15 +432,25 @@ test("sidecar is feature-gated and, when enabled, starts before the gateway", ()
 test("agent session sync starts and stops with the agent monitor flag", () => {
   assert.match(
     appSource,
-    /private async applyAgentMonitorSetting\(enabled: boolean\): Promise<void> \{[\s\S]*if \(enabled\) \{[\s\S]*this\.agentSessionSync\.start\(\);[\s\S]*return;[\s\S]*await this\.agentMonitor\.stop\(\);[\s\S]*this\.agentSessionSync\.stop\(\);/,
+    /private async applyAgentMonitorSetting\(enabled: boolean\): Promise<void> \{[\s\S]*if \(enabled\) \{[\s\S]*await this\.startAgentCapture\(\);[\s\S]*return;[\s\S]*await this\.stopAgentCapture\(\{ closeDesignSystem: true \}\);/,
+  );
+  assert.match(
+    appSource,
+    /private async stopAgentCapture\(\s*options: \{ closeDesignSystem\?: boolean \} = \{\},\s*\): Promise<void> \{[\s\S]*await this\.agentMonitor\?\.stop\(\);[\s\S]*this\.agentSessionSync\.stop\(\);/,
+  );
+  assert.match(
+    appSource,
+    /options\.closeDesignSystem[\s\S]*this\.agentDashboardDesignSystem\.close\(\);[\s\S]*this\.agentDashboardDesignSystem = null;/,
   );
 });
 
 test("sidecar URL + hooks toggle exposed via IPC + preload", () => {
   assert.match(
     appSource,
-    /ipcMain\.handle\("desktop:get-agent-monitor-url",[\s\S]*this\.agentMonitor\.getUrl\(\)[\s\S]*this\.agentMonitor\.isReady\(\)[\s\S]*enabled: this\.isAgentMonitorEnabled\(\)[\s\S]*planExtractionEnabled: this\.isPlanExtractionEnabled\(\)/,
+    /ipcMain\.handle\("desktop:get-agent-monitor-url",[\s\S]*url: this\.getAgentMonitorUrl\(\)[\s\S]*ready: this\.isAgentMonitorReady\(\)[\s\S]*enabled: this\.isAgentMonitorEnabled\(\)[\s\S]*planExtractionEnabled: this\.isPlanExtractionEnabled\(\)/,
   );
+  assert.match(appSource, /this\.agentMonitor\?\.getUrl\(\)/);
+  assert.match(appSource, /this\.agentMonitor\?\.isReady\(\)/);
   assert.match(
     appSource,
     /ipcMain\.handle\(\s*"desktop:set-agent-monitor-hooks-enabled"[\s\S]*Agent Dashboard is disabled in Settings\.[\s\S]*setAgentMonitorHooksEnabled/,
@@ -452,7 +468,7 @@ test("sidecar URL + hooks toggle exposed via IPC + preload", () => {
 test("openClaudeDashboard redirects to settings when disabled and tray access is gated", () => {
   assert.match(
     appSource,
-    /openClaudeDashboard\(\): void \{[\s\S]*this\.desktopWindow\.show\(\);[\s\S]*if \(!this\.isAgentMonitorEnabled\(\)\) \{[\s\S]*"desktop:navigate-tab", "settings"[\s\S]*"desktop:navigate-settings-tab", "relay-gateway"[\s\S]*return;[\s\S]*"desktop:navigate-tab",\s*"claude-dashboard"/,
+    /openClaudeDashboard\(\): void \{[\s\S]*this\.desktopWindow\.show\(\);[\s\S]*if \(!this\.isAgentMonitorEnabled\(\)\) \{[\s\S]*"desktop:navigate-tab", "settings"[\s\S]*"desktop:navigate-settings-tab", "relay-gateway"[\s\S]*return;[\s\S]*this\.agentDashboardMode === "design-system"[\s\S]*\? "dashboard"[\s\S]*: "claude-dashboard"/,
   );
   assert.match(
     appSource,
@@ -472,9 +488,9 @@ test("hooks are opt-in: default off, silent server auto-install never enabled",
   // The host never sets CCAM_AUTO_INSTALL_HOOKS=1; it manages hooks directly.
   assert.doesNotMatch(sidecarSource, /CCAM_AUTO_INSTALL_HOOKS:\s*"1"/);
   assert.match(hooksSource, /store\(\)\.get\("enabled", false\)/);
-  assert.match(hooksSource, /ELECTRON_RUN_AS_NODE=1/);
-  assert.match(hooksSource, /JSON\.stringify\(hookType\)/);
-  assert.match(hooksSource, /renameSync/);
+  assert.match(hooksCoreSource, /ELECTRON_RUN_AS_NODE=1/);
+  assert.match(hooksCoreSource, /JSON\.stringify\(hookType\)/);
+  assert.match(hooksCoreSource, /renameSync/);
   assert.match(hooksSource, /function uninstallHooks/);
   assert.match(appSource, /syncAgentMonitorHooksOnBoot\(\)/);
 });
diff --git a/apps/desktop/test/agent-session-sync-service.test.ts b/apps/desktop/test/agent-session-sync-service.test.ts
index 44109c40..b22f230c 100644
--- a/apps/desktop/test/agent-session-sync-service.test.ts
+++ b/apps/desktop/test/agent-session-sync-service.test.ts
@@ -19,7 +19,10 @@ import {
   sanitizeSessionForSync,
   SESSION_PAYLOAD_BYTE_CAP,
 } from "../src/main/agent-session-sync-service.js";
-import { DesktopAgentSessionsAckReason } from "../src/main/cloud-protocol.js";
+import {
+  DesktopAgentSessionsAckReason,
+  type DesktopAgentSessionsAck,
+} from "../src/main/cloud-protocol.js";
 import {
   createAgentMonitorTestDatabase as createServiceTestDatabase,
   flushAgentSessionSync,
@@ -105,17 +108,11 @@ test("agent-session sync loads normalized session payloads with attribution and
       output_tokens INTEGER NOT NULL DEFAULT 0,
       cache_read_tokens INTEGER NOT NULL DEFAULT 0,
       cache_write_tokens INTEGER NOT NULL DEFAULT 0,
-      baseline_input INTEGER NOT NULL DEFAULT 0,
-      baseline_output INTEGER NOT NULL DEFAULT 0,
-      baseline_cache_read INTEGER NOT NULL DEFAULT 0,
-      baseline_cache_write INTEGER NOT NULL DEFAULT 0
-    );
-    CREATE TABLE model_pricing (
-      model_pattern TEXT PRIMARY KEY,
-      input_per_mtok REAL NOT NULL DEFAULT 0,
-      output_per_mtok REAL NOT NULL DEFAULT 0,
-      cache_read_per_mtok REAL NOT NULL DEFAULT 0,
-      cache_write_per_mtok REAL NOT NULL DEFAULT 0
+      raw_input INTEGER NOT NULL DEFAULT 0,
+      raw_output INTEGER NOT NULL DEFAULT 0,
+      raw_cache_read INTEGER NOT NULL DEFAULT 0,
+      raw_cache_write INTEGER NOT NULL DEFAULT 0,
+      PRIMARY KEY (session_id, model)
     );
   `);
 
@@ -176,16 +173,16 @@ test("agent-session sync loads normalized session payloads with attribution and
     "2026-05-20T12:02:00.000Z",
   );
 
+  // FEA-1497: the in-process token_usage stores effective reconciled counts in
+  // the plain columns (no baseline_* at read time). 1000+25 input, 500+10
+  // output, 250+5 cache-read, 100+0 cache-write — the same effective totals the
+  // old baseline-summed query produced.
   db.prepare(`
     INSERT INTO token_usage (
-      session_id, model, input_tokens, output_tokens, cache_read_tokens,
-      cache_write_tokens, baseline_input, baseline_output, baseline_cache_read,
-      baseline_cache_write
-    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-  `).run("sess-1", "gpt-4.1", 1000, 500, 250, 100, 25, 10, 5, 0);
-
-  // No model_pricing INSERT: cost is now derived from @pydantic/genai-prices,
-  // not the (legacy, no-longer-read) model_pricing table.
+      session_id, model, input_tokens, output_tokens, cache_read_tokens, cache_write_tokens
+    ) VALUES (?, ?, ?, ?, ?, ?)
+  `).run("sess-1", "gpt-4.1", 1025, 510, 255, 100);
+
   const sessions = loadSyncedSessions(db, ["sess-1"]);
   assert.equal(sessions.length, 1);
 
@@ -214,9 +211,9 @@ test("agent-session sync loads normalized session payloads with attribution and
   assert.equal(session.tokenUsageByModel[0].cacheReadTokens, 255);
   assert.equal(session.tokenUsageByModel[0].cacheWriteTokens, 100);
   // Cost is computed by genai-prices via the canonical engine. Assert the load
-  // path fed it the correctly baseline-summed, provider-normalized counts
-  // (gpt-4.1 is OpenAI → input passes through as the total, cache is a subset)
-  // rather than hard-coding a library-version-dependent dollar figure.
+  // path fed it the correct effective, provider-normalized counts (gpt-4.1 is
+  // OpenAI → input passes through as the total, cache is a subset) rather than
+  // hard-coding a library-version-dependent dollar figure.
   const expectedCost = computeTokenCost({
     model: "gpt-4.1",
     inputTokens: 1025,
@@ -465,6 +462,136 @@ test("agent-session sync throttles repeated incremental full-session syncs", asy
   }
 });
 
+test("agent-session sync stop clears retry state before a new dashboard source is selected", async () => {
+  const legacyRootDir = mkdtempSync(path.join(tmpdir(), "agent-session-sync-legacy-"));
+  const designRootDir = mkdtempSync(path.join(tmpdir(), "agent-session-sync-design-"));
+  const legacyDb = createServiceTestDatabase(legacyRootDir);
+  const designDb = createServiceTestDatabase(designRootDir);
+  insertSessionRow(legacyDb, {
+    id: "shared-session",
+    startedAt: "2026-05-20T12:00:00.000Z",
+    updatedAt: "2026-05-20T12:05:00.000Z",
+  });
+  insertSessionRow(designDb, {
+    id: "shared-session",
+    startedAt: "2026-05-20T13:00:00.000Z",
+    updatedAt: "2026-05-20T13:05:00.000Z",
+  });
+
+  let monitorEnabled = true;
+  let source: "legacy" | "design" = "legacy";
+  const sentSessionStartedAt: string[] = [];
+  const service = new AgentSessionSyncService({
+    isAgentMonitorEnabled: () => monitorEnabled,
+    isRelayReady: () => true,
+    getSandboxBaseDirectory: () => "/",
+    getConnection: () => (source === "design" ? designDb : null),
+    getUserDataPath: () => path.join(legacyRootDir, "user-data"),
+    sendBatch: async (batch) => {
+      sentSessionStartedAt.push(batch.sessions[0]?.startedAt ?? "");
+      if (source === "legacy") {
+        return {
+          accepted: false,
+          reason: DesktopAgentSessionsAckReason.RateLimited,
+        };
+      }
+      return { accepted: true };
+    },
+  });
+
+  service.start();
+  await flushAgentSessionSync();
+  assert.deepEqual(sentSessionStartedAt, ["2026-05-20T12:00:00.000Z"]);
+
+  monitorEnabled = false;
+  service.stop();
+  service.refresh();
+  await flushAgentSessionSync();
+  assert.deepEqual(
+    sentSessionStartedAt,
+    ["2026-05-20T12:00:00.000Z"],
+    "disabled mode must not send from the stopped source",
+  );
+
+  monitorEnabled = true;
+  source = "design";
+  service.start();
+  await flushAgentSessionSync();
+  assert.deepEqual(
+    sentSessionStartedAt,
+    ["2026-05-20T12:00:00.000Z", "2026-05-20T13:00:00.000Z"],
+    "design source must send immediately instead of inheriting legacy backoff",
+  );
+
+  service.stop();
+  legacyDb.close();
+  designDb.close();
+});
+
+test("agent-session sync ignores stale in-flight acks after source reset", async () => {
+  const legacyRootDir = mkdtempSync(path.join(tmpdir(), "agent-session-sync-legacy-"));
+  const designRootDir = mkdtempSync(path.join(tmpdir(), "agent-session-sync-design-"));
+  const legacyDb = createServiceTestDatabase(legacyRootDir);
+  const designDb = createServiceTestDatabase(designRootDir);
+  insertSessionRow(legacyDb, {
+    id: "shared-session",
+    startedAt: "2026-05-20T12:00:00.000Z",
+    updatedAt: "2026-05-20T12:05:00.000Z",
+  });
+  insertSessionRow(designDb, {
+    id: "shared-session",
+    startedAt: "2026-05-20T13:00:00.000Z",
+    updatedAt: "2026-05-20T13:05:00.000Z",
+  });
+
+  let monitorEnabled = true;
+  let source: "legacy" | "design" = "legacy";
+  let resolveLegacyAck: ((ack: DesktopAgentSessionsAck) => void) | null = null;
+  const sentSessionStartedAt: string[] = [];
+  const service = new AgentSessionSyncService({
+    isAgentMonitorEnabled: () => monitorEnabled,
+    isRelayReady: () => true,
+    getSandboxBaseDirectory: () => "/",
+    getConnection: () => (source === "design" ? designDb : null),
+    getUserDataPath: () => path.join(legacyRootDir, "user-data"),
+    sendBatch: async (batch) => {
+      sentSessionStartedAt.push(batch.sessions[0]?.startedAt ?? "");
+      if (batch.sessions[0]?.startedAt === "2026-05-20T12:00:00.000Z") {
+        return await new Promise<DesktopAgentSessionsAck>((resolve) => {
+          resolveLegacyAck = resolve;
+        });
+      }
+      return { accepted: true };
+    },
+  });
+
+  service.start();
+  await flushAgentSessionSync();
+  assert.deepEqual(sentSessionStartedAt, ["2026-05-20T12:00:00.000Z"]);
+
+  monitorEnabled = false;
+  service.stop();
+  resolveLegacyAck?.({
+    accepted: false,
+    reason: DesktopAgentSessionsAckReason.RateLimited,
+  });
+  await flushAgentSessionSync();
+
+  source = "design";
+  monitorEnabled = true;
+  service.start();
+  await flushAgentSessionSync();
+  assert.deepEqual(
+    sentSessionStartedAt,
+    ["2026-05-20T12:00:00.000Z", "2026-05-20T13:00:00.000Z"],
+    "stale legacy ack after stop must not back off the next design source",
+  );
+
+  service.stop();
+  legacyDb.close();
+  designDb.close();
+});
+
 test("agent-session sync cost estimator returns undefined for an unpriced model", () => {
   // An unknown model is not priced by genai-prices → undefined, so the caller
   // omits the optional estimatedCostUsd field (renders as "—", not a silent $0).
@@ -500,6 +627,87 @@ function insertEventRow(
   );
 }
 
+function insertPaddingEvents(
+  db: DatabaseSync,
+  sessionId: string,
+  count: number,
+  toolName: string,
+): void {
+  for (let index = 0; index < count; index += 1) {
+    db.prepare(`
+      INSERT INTO events (session_id, agent_id, event_type, tool_name, summary, data, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `).run(
+      sessionId,
+      null,
+      "tool_use",
+      toolName,
+      null,
+      null,
+      "2026-05-20T12:00:00.000Z",
+    );
+  }
+}
+
+test("agent-session sync stop clears pending chunks before source re-enable", async () => {
+  const legacyRootDir = mkdtempSync(path.join(tmpdir(), "agent-session-sync-legacy-"));
+  const designRootDir = mkdtempSync(path.join(tmpdir(), "agent-session-sync-design-"));
+  const legacyDb = createServiceTestDatabase(legacyRootDir);
+  const designDb = createServiceTestDatabase(designRootDir);
+  insertSessionRow(legacyDb, {
+    id: "legacy-chunked",
+    startedAt: "2026-05-20T12:00:00.000Z",
+    updatedAt: "2026-05-20T12:05:00.000Z",
+  });
+  insertPaddingEvents(
+    legacyDb,
+    "legacy-chunked",
+    Math.ceil((SESSION_PAYLOAD_BYTE_CAP * 2) / 600),
+    "Z".repeat(500),
+  );
+  insertSessionRow(designDb, {
+    id: "design-fresh",
+    startedAt: "2026-05-20T13:00:00.000Z",
+    updatedAt: "2026-05-20T13:05:00.000Z",
+  });
+
+  let monitorEnabled = true;
+  let source: "legacy" | "design" = "legacy";
+  const sentSessionIds: string[] = [];
+  const service = new AgentSessionSyncService({
+    isAgentMonitorEnabled: () => monitorEnabled,
+    isRelayReady: () => true,
+    isChunkedSyncEnabled: () => true,
+    getSandboxBaseDirectory: () => "/",
+    getConnection: () => (source === "design" ? designDb : null),
+    getUserDataPath: () => path.join(legacyRootDir, "user-data"),
+    sendBatch: async (batch) => {
+      sentSessionIds.push(batch.sessions[0]?.externalSessionId ?? "");
+      return { accepted: true };
+    },
+  });
+
+  service.start();
+  await flushAgentSessionSync();
+  assert.deepEqual(sentSessionIds, ["legacy-chunked"]);
+
+  monitorEnabled = false;
+  service.stop();
+  source = "design";
+  monitorEnabled = true;
+  service.start();
+  await flushAgentSessionSync();
+  assert.deepEqual(
+    sentSessionIds,
+    ["legacy-chunked", "design-fresh"],
+    "source re-enable must not resume pending chunks from the prior DB",
+  );
+
+  service.stop();
+  legacyDb.close();
+  designDb.close();
+});
+
 test("agent-session payload-aware batcher keeps each batch at or below SESSION_PAYLOAD_BYTE_CAP", async () => {
   // Create sessions whose combined size exceeds the cap so the batcher must
   // split them across multiple sync cycles.
diff --git a/apps/desktop/test/approval-policy.test.ts b/apps/desktop/test/approval-policy.test.ts
index 75291d5d..361bf4b9 100644
--- a/apps/desktop/test/approval-policy.test.ts
+++ b/apps/desktop/test/approval-policy.test.ts
@@ -1,5 +1,4 @@
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
 import { test } from "node:test";
 import { shouldAutoApprove, OPERATION_RISK_TIERS, riskTierOrder, FORCE_INTERACTIVE_OPERATIONS } from "../src/main/approval-policy.js";
 import { SUPPORTED_OPERATION_IDS, resolveOperationId } from "../src/main/approval-operations.js";
@@ -60,22 +59,23 @@ test("Branch View local operations are registered in approval catalogs and rende
   assert.equal(OPERATION_RISK_TIERS.git_local_changes, "low");
   assert.equal(OPERATION_RISK_TIERS.git_local_commit_push, "high");
 
-  const rendererSource = readFileSync(
-    new URL("../src/renderer/index.html", import.meta.url),
-    "utf-8"
-  );
-  assert.match(
-    rendererSource,
-    /\["\/api\/gateway\/git\/local-changes", "git_local_changes"\]/
+  // FEA-1497 (Phase 0): the Branch View path->operationId mapping is owned by
+  // the first-party gateway (resolveOperationId), so assert it there directly
+  // instead of string-matching the monolithic index.html that PR #264 replaced
+  // with the React renderer. The human-readable renderer labels ("Branch View
+  // Local Changes" / "Commit and Push Local Changes") now live in React
+  // components and are re-guarded in Phase 1.
+  assert.equal(
+    resolveOperationId("/api/gateway/git/local-changes"),
+    "git_local_changes"
   );
-  assert.match(
-    rendererSource,
-    /\["\/api\/gateway\/git\/local-changes\/commit-push", "git_local_commit_push"\]/
+  assert.equal(
+    resolveOperationId("/api/gateway/git/local-changes/diff"),
+    "git_local_changes"
   );
-  assert.match(rendererSource, /git_local_changes: "Branch View Local Changes"/);
-  assert.match(
-    rendererSource,
-    /git_local_commit_push: "Commit and Push Local Changes"/
+  assert.equal(
+    resolveOperationId("/api/gateway/git/local-changes/commit-push"),
+    "git_local_commit_push"
   );
 });
 
diff --git a/apps/desktop/test/billing-mode.test.ts b/apps/desktop/test/billing-mode.test.ts
index 9ce4aee5..04f64900 100644
--- a/apps/desktop/test/billing-mode.test.ts
+++ b/apps/desktop/test/billing-mode.test.ts
@@ -1,61 +1,31 @@
 /**
  * @file billing-mode.test.ts
- * @description Parity + correctness tests for the canonical billing-mode engine.
+ * @description Correctness tests for the first-party billing-mode engine
+ * (`src/shared/billing-mode.ts`). FEA-1503 removed the vendor CJS twin
+ * (`scripts/agent-monitor-billing/billing-mode.js`); the first-party engine is
+ * now the single source of truth.
  *
- * There are TWO copies of the engine that must never diverge:
- *   • the desktop-main ESM twin  — src/shared/billing-mode.ts
- *   • the sidecar CJS engine     — scripts/agent-monitor-billing/billing-mode.js
- * They live in different module systems (the sidecar runs in a generated
- * CommonJS tree; desktop-main is ESM and must work with the sidecar disabled),
- * so the code is duplicated. This test imports BOTH and asserts identical
- * classification and detection output across a fixture matrix so a change to one
- * without the other fails CI.
- *
- * It also pins the exact ledger mapping (the reviewed invariant: which modes are
- * metered vs subscription vs unknown) and the existence-only detection rules,
- * and asserts detection never surfaces a secret value.
+ * Pins the exact ledger mapping (the reviewed invariant: which modes are metered
+ * vs subscription vs unknown) and the existence-only detection rules, and asserts
+ * detection never surfaces a secret value.
  */
 import assert from "node:assert/strict";
-import { createRequire } from "node:module";
 import { join } from "node:path";
 import { test } from "node:test";
 import {
   BILLING_MODES,
-  addLedgerCost as addLedgerCostTwin,
-  billingLedger as billingLedgerTwin,
-  detectBillingModeForHarness as detectTwin,
-  emptyLedgerTotals as emptyLedgerTotalsTwin,
-  headlineCost as headlineCostTwin,
-  isMeteredApi as isMeteredApiTwin,
-  isSubscription as isSubscriptionTwin,
-  normalizeBillingMode as normalizeTwin,
+  addLedgerCost,
+  billingLedger,
+  detectBillingModeForHarness as detect,
+  emptyLedgerTotals,
+  headlineCost,
+  isMeteredApi,
+  normalizeBillingMode,
   type BillingMode,
   type BillingModeDetectionDeps,
   type LedgerTotals,
 } from "../src/shared/billing-mode.js";
 
-// The sidecar engine is CommonJS (its dir is scoped type:commonjs). Load it via
-// createRequire so it resolves the same way it does inside the generated tree.
-const require = createRequire(import.meta.url);
-const engine = require("../scripts/agent-monitor-billing/billing-mode.js") as {
-  BILLING_MODES: string[];
-  billingLedger: (mode: string) => string;
-  isMeteredApi: (mode: string) => boolean;
-  isSubscription: (mode: string) => boolean;
-  emptyLedgerTotals: () => LedgerTotals;
-  addLedgerCost: (
-    totals: LedgerTotals,
-    billingMode: string,
-    costUsd: number,
-  ) => LedgerTotals;
-  headlineCost: (totals: LedgerTotals) => number;
-  normalizeBillingMode: (value: unknown) => string;
-  detectBillingModeForHarness: (
-    harness: string,
-    deps: BillingModeDetectionDeps,
-  ) => string;
-};
-
 const HOME = "/fake/home";
 
 /** Build detection deps with an injected env + a Set of "existing" file paths. */
@@ -75,20 +45,20 @@ function makeDeps(opts: {
 const ANTHROPIC_CRED = join(HOME, ".claude", ".credentials.json");
 const CODEX_AUTH = join(HOME, ".codex", "auth.json");
 
-test("twin and sidecar engine declare the same BILLING_MODES domain", () => {
-  assert.deepEqual([...BILLING_MODES].sort(), [...engine.BILLING_MODES].sort());
-});
-
-test("ledger classification is byte-equal between twin and engine for every mode", () => {
-  for (const mode of BILLING_MODES) {
-    assert.equal(
-      billingLedgerTwin(mode),
-      engine.billingLedger(mode),
-      `billingLedger drift for ${mode}`,
-    );
-    assert.equal(isMeteredApiTwin(mode), engine.isMeteredApi(mode));
-    assert.equal(isSubscriptionTwin(mode), engine.isSubscription(mode));
-  }
+test("BILLING_MODES declares the full stable domain", () => {
+  assert.deepEqual([...BILLING_MODES].sort(), [
+    "api",
+    "codex_subscription",
+    "copilot_seat",
+    "cursor_api",
+    "cursor_pro",
+    "max_20x",
+    "max_5x",
+    "opencode",
+    "pro",
+    "subscription_unknown",
+    "unknown",
+  ]);
 });
 
 test("ledger mapping pins the exact reviewed invariant", () => {
@@ -105,28 +75,24 @@ test("ledger mapping pins the exact reviewed invariant", () => {
     opencode: "unknown",
     unknown: "unknown",
   };
-  // Every declared mode is covered above (compile-time totality via Record),
-  // and every mapping is exactly as reviewed.
   for (const mode of BILLING_MODES) {
-    assert.equal(billingLedgerTwin(mode), expected[mode], `ledger for ${mode}`);
+    assert.equal(billingLedger(mode), expected[mode], `ledger for ${mode}`);
   }
   // A subscription mode must NEVER be classified as metered (the headline-spend
   // safety invariant: hypothetical cost can't leak into real spend).
   for (const mode of BILLING_MODES) {
-    if (billingLedgerTwin(mode) === "subscription") {
-      assert.equal(isMeteredApiTwin(mode), false, `${mode} must not be metered`);
+    if (billingLedger(mode) === "subscription") {
+      assert.equal(isMeteredApi(mode), false, `${mode} must not be metered`);
     }
   }
 });
 
 test("normalizeBillingMode coerces legacy/garbage to unknown, passes valid through", () => {
   for (const mode of BILLING_MODES) {
-    assert.equal(normalizeTwin(mode), mode);
-    assert.equal(engine.normalizeBillingMode(mode), mode);
+    assert.equal(normalizeBillingMode(mode), mode);
   }
   for (const junk of [null, undefined, "", "API", "max", 42, {}, []]) {
-    assert.equal(normalizeTwin(junk), "unknown");
-    assert.equal(engine.normalizeBillingMode(junk), "unknown");
+    assert.equal(normalizeBillingMode(junk), "unknown");
   }
 });
 
@@ -227,29 +193,17 @@ const DETECTION_FIXTURES: Array<{
   },
 ];
 
-test("detection is byte-equal between twin and engine and matches expected mode", () => {
+test("detection matches the expected mode across the fixture matrix", () => {
   for (const fx of DETECTION_FIXTURES) {
-    const twinDeps = makeDeps({
-      env: fx.env,
-      existingFiles: fx.existingFiles,
-    });
-    const engineDeps = makeDeps({
-      env: fx.env,
-      existingFiles: fx.existingFiles,
-    });
-    const twinMode = detectTwin(fx.harness, twinDeps);
-    const engineMode = engine.detectBillingModeForHarness(fx.harness, engineDeps);
-    assert.equal(twinMode, fx.expected, `twin: ${fx.name}`);
-    assert.equal(engineMode, fx.expected, `engine: ${fx.name}`);
-    assert.equal(twinMode, engineMode, `twin/engine drift: ${fx.name}`);
+    const deps = makeDeps({ env: fx.env, existingFiles: fx.existingFiles });
+    assert.equal(detect(fx.harness, deps), fx.expected, fx.name);
   }
 });
 
 test("detection never surfaces a secret value (existence-only)", () => {
   const secret = "sk-ant-this-is-a-secret-token-value";
   const deps = makeDeps({ env: { ANTHROPIC_API_KEY: secret } });
-  const mode = detectTwin("claude", deps);
-  // The output is an opaque mode, not the key; and never contains the secret.
+  const mode = detect("claude", deps);
   assert.equal(mode, "api");
   assert.ok(!String(mode).includes(secret));
 });
@@ -257,85 +211,66 @@ test("detection never surfaces a secret value (existence-only)", () => {
 // ── Ledger accounting (FEA-1434 two-ledger invariant) ────────────────────────
 
 test("emptyLedgerTotals is a fresh zeroed three-bucket accumulator", () => {
-  for (const empty of [emptyLedgerTotalsTwin(), engine.emptyLedgerTotals()]) {
-    assert.deepEqual(empty, { metered: 0, subscription: 0, unknown: 0 });
-  }
+  assert.deepEqual(emptyLedgerTotals(), { metered: 0, subscription: 0, unknown: 0 });
   // Independent instances — mutating one must not affect the next call.
-  const a = emptyLedgerTotalsTwin();
+  const a = emptyLedgerTotals();
   a.metered = 99;
-  assert.equal(emptyLedgerTotalsTwin().metered, 0);
+  assert.equal(emptyLedgerTotals().metered, 0);
 });
 
-test("addLedgerCost routes each mode's cost into its ledger bucket (twin + engine)", () => {
-  for (const add of [addLedgerCostTwin, engine.addLedgerCost]) {
-    const empty = emptyLedgerTotalsTwin;
-    assert.deepEqual(add(empty(), "api", 1.5), {
-      metered: 1.5,
-      subscription: 0,
-      unknown: 0,
-    });
-    assert.deepEqual(add(empty(), "cursor_api", 2), {
-      metered: 2,
-      subscription: 0,
-      unknown: 0,
-    });
-    assert.deepEqual(add(empty(), "max_20x", 3), {
-      metered: 0,
-      subscription: 3,
-      unknown: 0,
-    });
-    assert.deepEqual(add(empty(), "opencode", 4), {
-      metered: 0,
-      subscription: 0,
-      unknown: 4,
-    });
-    assert.deepEqual(add(empty(), "unknown", 5), {
-      metered: 0,
-      subscription: 0,
-      unknown: 5,
-    });
-  }
+test("addLedgerCost routes each mode's cost into its ledger bucket", () => {
+  assert.deepEqual(addLedgerCost(emptyLedgerTotals(), "api", 1.5), {
+    metered: 1.5,
+    subscription: 0,
+    unknown: 0,
+  });
+  assert.deepEqual(addLedgerCost(emptyLedgerTotals(), "cursor_api", 2), {
+    metered: 2,
+    subscription: 0,
+    unknown: 0,
+  });
+  assert.deepEqual(addLedgerCost(emptyLedgerTotals(), "max_20x", 3), {
+    metered: 0,
+    subscription: 3,
+    unknown: 0,
+  });
+  assert.deepEqual(addLedgerCost(emptyLedgerTotals(), "opencode", 4), {
+    metered: 0,
+    subscription: 0,
+    unknown: 4,
+  });
+  assert.deepEqual(addLedgerCost(emptyLedgerTotals(), "unknown", 5), {
+    metered: 0,
+    subscription: 0,
+    unknown: 5,
+  });
 });
 
 test("addLedgerCost ignores non-finite costs so an unpriced row never corrupts a total", () => {
-  for (const add of [addLedgerCostTwin, engine.addLedgerCost]) {
-    // null/undefined/NaN/Infinity are all dropped; the accumulator is untouched.
-    for (const bad of [null, undefined, NaN, Infinity, -Infinity, "1.5"]) {
-      const totals = emptyLedgerTotalsTwin();
-      add(totals, "api", bad as unknown as number);
-      assert.deepEqual(totals, { metered: 0, subscription: 0, unknown: 0 });
-    }
+  for (const bad of [null, undefined, NaN, Infinity, -Infinity, "1.5"]) {
+    const totals = emptyLedgerTotals();
+    addLedgerCost(totals, "api", bad as unknown as number);
+    assert.deepEqual(totals, { metered: 0, subscription: 0, unknown: 0 });
   }
 });
 
 test("addLedgerCost accumulates across many rows and returns the same object", () => {
-  const totals = emptyLedgerTotalsTwin();
-  const returned = addLedgerCostTwin(totals, "api", 1);
+  const totals = emptyLedgerTotals();
+  const returned = addLedgerCost(totals, "api", 1);
   assert.equal(returned, totals, "mutates and returns the same accumulator");
-  addLedgerCostTwin(totals, "api", 0.25);
-  addLedgerCostTwin(totals, "pro", 10);
-  addLedgerCostTwin(totals, "opencode", 0.5);
+  addLedgerCost(totals, "api", 0.25);
+  addLedgerCost(totals, "pro", 10);
+  addLedgerCost(totals, "opencode", 0.5);
   assert.deepEqual(totals, { metered: 1.25, subscription: 10, unknown: 0.5 });
 });
 
 test("headlineCost = metered + unknown and EXCLUDES subscription (the safety invariant)", () => {
   const totals: LedgerTotals = { metered: 7, subscription: 1000, unknown: 3 };
-  // Both implementations agree, and the headline never includes the $1000
-  // hypothetical subscription cost.
-  assert.equal(headlineCostTwin(totals), 10);
-  assert.equal(engine.headlineCost(totals), 10);
-  assert.equal(headlineCostTwin(totals), engine.headlineCost(totals));
-
-  // Adding subscription cost must not move the headline; adding metered/unknown
-  // must — proven by construction over the full mode domain.
+  assert.equal(headlineCost(totals), 10);
   for (const mode of BILLING_MODES) {
-    const t = emptyLedgerTotalsTwin();
-    addLedgerCostTwin(t, mode, 42);
-    const expectedHeadline = billingLedgerTwin(mode) === "subscription" ? 0 : 42;
-    assert.equal(
-      headlineCostTwin(t),
-      expectedHeadline,
-      `headline contribution for ${mode}`,
-    );
+    const t = emptyLedgerTotals();
+    addLedgerCost(t, mode, 42);
+    const expectedHeadline = billingLedger(mode) === "subscription" ? 0 : 42;
+    assert.equal(headlineCost(t), expectedHeadline, `headline contribution for ${mode}`);
   }
 });
diff --git a/apps/desktop/test/collectors-hook-handler.test.ts b/apps/desktop/test/collectors-hook-handler.test.ts
new file mode 100644
index 00000000..44b59fe0
--- /dev/null
+++ b/apps/desktop/test/collectors-hook-handler.test.ts
@@ -0,0 +1,128 @@
+/**
+ * @file collectors-hook-handler.test.ts
+ * @description Validates the first-party hook handlers (FEA-1503): they POST the
+ * `{ hook_type, data }` envelope to the in-process listener on the configured
+ * port. The Claude handler uses the legacy Claude route; the Codex handler uses
+ * a route-owned Codex attribution path and does not send provider hints in data.
+ *
+ * In production the handler runs from a userData COPY (outside the desktop's
+ * `type:module` package, so its `require()` resolves as CommonJS). The test
+ * mirrors that by copying the shipped script into a package.json-free temp dir
+ * before spawning it via the Node binary.
+ */
+import assert from "node:assert/strict";
+import { spawn } from "node:child_process";
+import { copyFileSync, mkdtempSync } from "node:fs";
+import http from "node:http";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { test } from "node:test";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const HOOKS_DIR = path.join(__dirname, "..", "resources", "hooks");
+
+interface HookEnvelope {
+  hook_type: string;
+  data: Record<string, unknown>;
+}
+
+interface CapturedHook {
+  path: string;
+  envelope: HookEnvelope;
+}
+
+/** Copy the shipped handler to a CJS-safe temp dir, run it, capture the POST. */
+function runHandler(
+  script: string,
+  hookType: string,
+  stdinPayload: string,
+): Promise<CapturedHook> {
+  return new Promise((resolve, reject) => {
+    const dir = mkdtempSync(path.join(tmpdir(), "hook-handler-"));
+    const handlerCopy = path.join(dir, script);
+    copyFileSync(path.join(HOOKS_DIR, script), handlerCopy);
+
+    let received: CapturedHook | null = null;
+    const server = http.createServer((req, res) => {
+      if (
+        req.method === "POST" &&
+        (req.url === "/api/hooks/event" ||
+          req.url === "/api/hooks/codex/event")
+      ) {
+        let body = "";
+        req.on("data", (chunk) => (body += chunk));
+        req.on("end", () => {
+          try {
+            received = {
+              path: req.url ?? "",
+              envelope: JSON.parse(body) as HookEnvelope,
+            };
+          } catch {
+            received = null;
+          }
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ ok: true }));
+        });
+      } else {
+        res.writeHead(404);
+        res.end();
+      }
+    });
+
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+      const port = typeof address === "object" && address ? address.port : 0;
+      const child = spawn(process.execPath, [handlerCopy, hookType], {
+        env: { ...process.env, CLAUDE_DASHBOARD_PORT: String(port) },
+      });
+      child.stdin.write(stdinPayload);
+      child.stdin.end();
+      child.on("error", (err) => {
+        server.close();
+        reject(err);
+      });
+      child.on("exit", () => {
+        setTimeout(() => {
+          server.close(() => {
+            if (received) resolve(received);
+            else reject(new Error("handler did not POST a hook event"));
+          });
+        }, 100);
+      });
+    });
+  });
+}
+
+test("Claude hook-handler.js forwards { hook_type, data } unchanged (no __provider)", async () => {
+  const captured = await runHandler(
+    "hook-handler.js",
+    "SessionStart",
+    JSON.stringify({ session_id: "abc-123", cwd: "/Users/dev/proj" }),
+  );
+  const { envelope } = captured;
+  assert.equal(captured.path, "/api/hooks/event");
+  assert.equal(envelope.hook_type, "SessionStart");
+  assert.equal(envelope.data.session_id, "abc-123");
+  assert.equal(envelope.data.cwd, "/Users/dev/proj");
+  assert.equal(envelope.data.__provider, undefined);
+});
+
+test("Codex codex-hook-handler.js uses the Codex route without payload provider hints", async () => {
+  const captured = await runHandler(
+    "codex-hook-handler.js",
+    "PreToolUse",
+    JSON.stringify({ session_id: "codex-1", tool_name: "shell" }),
+  );
+  const { envelope } = captured;
+  assert.equal(captured.path, "/api/hooks/codex/event");
+  assert.equal(envelope.hook_type, "PreToolUse");
+  assert.equal(envelope.data.session_id, "codex-1");
+  assert.equal(envelope.data.__provider, undefined);
+});
+
+test("hook handler tolerates non-JSON stdin without crashing", async () => {
+  const { envelope } = await runHandler("hook-handler.js", "Stop", "not json at all");
+  assert.equal(envelope.hook_type, "Stop");
+  assert.equal(envelope.data.raw, "not json at all");
+});
diff --git a/apps/desktop/test/collectors-import.test.ts b/apps/desktop/test/collectors-import.test.ts
new file mode 100644
index 00000000..74b54e7f
--- /dev/null
+++ b/apps/desktop/test/collectors-import.test.ts
@@ -0,0 +1,253 @@
+/**
+ * @file collectors-import.test.ts
+ * @description Tests the first-party importSession write-sink (FEA-1503): it
+ * writes a NormalizedSession into the in-process repository, is idempotent on
+ * re-import (the headline acceptance criterion), and the CollectorManager applies
+ * FEA-1407 sandbox gating (fail-closed) before any write.
+ */
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { test } from "node:test";
+
+import { openAgentDatabase } from "../src/main/database/index.js";
+import { createImporter } from "../src/main/collectors/import-session.js";
+import { CollectorManager } from "../src/main/collectors/collector-manager.js";
+import type { HarnessCollector, NormalizedSession } from "../src/main/collectors/types.js";
+
+const FIXED_NOW = "2024-03-09T17:00:00.000Z";
+
+function makeSession(overrides: Partial<NormalizedSession> = {}): NormalizedSession {
+  return {
+    sessionId: "s1",
+    name: "proj",
+    cwd: "/sandbox/proj",
+    model: "gpt-5",
+    version: null,
+    slug: null,
+    gitBranch: null,
+    startedAt: "2024-03-09T16:00:00.000Z",
+    endedAt: "2024-03-09T16:05:00.000Z",
+    teams: [],
+    userMessages: 1,
+    assistantMessages: 1,
+    tokensByModel: { "gpt-5": { input: 100, output: 50, cacheRead: 10, cacheWrite: 0 } },
+    messageTimestamps: ["2024-03-09T16:01:00.000Z", "2024-03-09T16:02:00.000Z"],
+    toolUses: [{ name: "Read", timestamp: "2024-03-09T16:01:30.000Z", input: { file: "x" } }],
+    plans: [],
+    compactions: [],
+    apiErrors: [],
+    fileModifiedAt: null, // not recently active ⇒ status "completed"
+    turnDurations: [],
+    entrypoint: "codex",
+    permissionMode: null,
+    thinkingBlockCount: 0,
+    toolResultErrors: [],
+    usageExtras: { service_tiers: [], speeds: [], inference_geos: [] },
+    ...overrides,
+  };
+}
+
+function openTempDb() {
+  const dir = mkdtempSync(path.join(tmpdir(), "collectors-import-"));
+  const db = openAgentDatabase(path.join(dir, "agent-dashboard.sqlite"));
+  return { db, dir, cleanup: () => { db.close(); rmSync(dir, { recursive: true, force: true }); } };
+}
+
+test("importSession writes session, main agent, events, and token rows", () => {
+  const { db, cleanup } = openTempDb();
+  try {
+    const importer = createImporter(db.connection, {
+      tokenUsage: db.tokenUsage,
+      detectBillingMode: () => "api",
+      now: () => FIXED_NOW,
+    });
+
+    const result = importer.importSession(makeSession(), "codex");
+    assert.equal(result.skipped, false);
+
+    const session = db.sessions.getById("s1");
+    assert.ok(session);
+    assert.equal(session.harness, "codex");
+    assert.equal(session.billingMode, "api");
+    assert.equal(session.status, "completed");
+
+    // main agent only (no Agent/Task tool use)
+    const agents = db.agents.getBySession("s1");
+    assert.equal(agents.length, 1);
+    assert.equal(agents[0].id, "s1-main");
+
+    // 2 Stop events + 1 PostToolUse event
+    const events = db.events.getBySession("s1");
+    assert.equal(events.filter((e) => e.eventType === "Stop").length, 2);
+    assert.equal(events.filter((e) => e.eventType === "PostToolUse").length, 1);
+
+    const tokens = db.tokenUsage.getBySession("s1");
+    assert.equal(tokens.length, 1);
+    assert.equal(tokens[0].inputTokens, 100);
+    assert.equal(tokens[0].outputTokens, 50);
+  } finally {
+    cleanup();
+  }
+});
+
+test("re-import is idempotent — no duplicate session/agent/event/token rows", () => {
+  const { db, cleanup } = openTempDb();
+  try {
+    const importer = createImporter(db.connection, {
+      tokenUsage: db.tokenUsage,
+      detectBillingMode: () => "api",
+      now: () => FIXED_NOW,
+    });
+
+    importer.importSession(makeSession(), "codex");
+    const eventsAfterFirst = db.events.getBySession("s1").length;
+    const tokensAfterFirst = db.tokenUsage.getBySession("s1")[0].inputTokens;
+
+    const second = importer.importSession(makeSession(), "codex");
+    assert.equal(second.skipped, true, "second import of an unchanged session is a no-op");
+
+    assert.equal(db.sessions.getAll().length, 1);
+    assert.equal(db.agents.getBySession("s1").length, 1);
+    assert.equal(db.events.getBySession("s1").length, eventsAfterFirst);
+    // token cumulative is reconciled, not doubled
+    assert.equal(db.tokenUsage.getBySession("s1")[0].inputTokens, tokensAfterFirst);
+  } finally {
+    cleanup();
+  }
+});
+
+test("a new event with a later timestamp backfills without duplicating prior events", () => {
+  const { db, cleanup } = openTempDb();
+  try {
+    const importer = createImporter(db.connection, {
+      tokenUsage: db.tokenUsage,
+      detectBillingMode: () => "api",
+      now: () => FIXED_NOW,
+    });
+
+    importer.importSession(makeSession(), "codex");
+    const before = db.events.getBySession("s1").filter((e) => e.eventType === "Stop").length;
+
+    // Same session, one additional later Stop timestamp.
+    importer.importSession(
+      makeSession({
+        messageTimestamps: [
+          "2024-03-09T16:01:00.000Z",
+          "2024-03-09T16:02:00.000Z",
+          "2024-03-09T16:03:00.000Z",
+        ],
+      }),
+      "codex",
+    );
+    const after = db.events.getBySession("s1").filter((e) => e.eventType === "Stop").length;
+    assert.equal(after, before + 1, "only the new Stop event is appended");
+  } finally {
+    cleanup();
+  }
+});
+
+test("Agent/Task tool use creates an idempotent subagent row", () => {
+  const { db, cleanup } = openTempDb();
+  try {
+    const importer = createImporter(db.connection, {
+      tokenUsage: db.tokenUsage,
+      detectBillingMode: () => "api",
+      now: () => FIXED_NOW,
+    });
+
+    const session = makeSession({
+      toolUses: [
+        {
+          name: "Task",
+          timestamp: "2024-03-09T16:01:30.000Z",
+          input: { subagent_type: "explorer", prompt: "go look" },
+        },
+      ],
+    });
+    importer.importSession(session, "codex");
+    importer.importSession(session, "codex"); // re-import
+
+    const agents = db.agents.getBySession("s1");
+    assert.equal(agents.length, 2, "main + one subagent, not duplicated on re-import");
+    const sub = agents.find((a) => a.type === "subagent");
+    assert.ok(sub);
+    assert.equal(sub.subagentType, "explorer");
+  } finally {
+    cleanup();
+  }
+});
+
+test("CollectorManager imports in-sandbox sessions and drops out-of-sandbox ones (FEA-1407)", async () => {
+  const { db, dir, cleanup } = openTempDb();
+  try {
+    let emitted = 0;
+    const fakeCollector: HarnessCollector = {
+      key: "codex",
+      cacheName: "codex",
+      watchRoots: () => [], // no real dirs to watch
+      watchMatch: () => false,
+      listSources: () => ["one-batch"],
+      parse: async () => [
+        makeSession({ sessionId: "in", cwd: "/sandbox/proj" }),
+        makeSession({ sessionId: "out", cwd: "/elsewhere/proj" }),
+      ],
+    };
+
+    const manager = new CollectorManager({
+      agentDatabase: db,
+      detectBillingMode: () => "api",
+      getSandboxBaseDirectory: () => "/sandbox",
+      stateDir: dir,
+      emit: () => { emitted++; },
+      shouldWatchClaude: () => false,
+      collectors: [fakeCollector],
+      now: () => FIXED_NOW,
+    });
+
+    manager.start();
+    // The initial boot import is scheduled via setImmediate; give it a few ticks.
+    await new Promise((resolve) => setTimeout(resolve, 50));
+    manager.stop();
+
+    assert.ok(db.sessions.getById("in"), "in-sandbox session is imported");
+    assert.equal(db.sessions.getById("out"), undefined, "out-of-sandbox session is dropped");
+    assert.ok(emitted > 0, "emits a live-update signal after writing");
+  } finally {
+    cleanup();
+  }
+});
+
+test("CollectorManager with an empty sandbox captures nothing (fail-closed)", async () => {
+  const { db, dir, cleanup } = openTempDb();
+  try {
+    const fakeCollector: HarnessCollector = {
+      key: "codex",
+      cacheName: "codex",
+      watchRoots: () => [],
+      watchMatch: () => false,
+      listSources: () => ["batch"],
+      parse: async () => [makeSession({ sessionId: "in", cwd: "/sandbox/proj" })],
+    };
+
+    const manager = new CollectorManager({
+      agentDatabase: db,
+      detectBillingMode: () => "api",
+      getSandboxBaseDirectory: () => "", // empty ⇒ capture nothing
+      stateDir: dir,
+      emit: () => {},
+      shouldWatchClaude: () => false,
+      collectors: [fakeCollector],
+      now: () => FIXED_NOW,
+    });
+
+    manager.start();
+    await new Promise((resolve) => setTimeout(resolve, 50));
+    manager.stop();
+
+    assert.equal(db.sessions.getAll().length, 0, "empty sandbox ⇒ nothing captured");
+  } finally {
+    cleanup();
+  }
+});
diff --git a/apps/desktop/test/collectors-parsers.test.ts b/apps/desktop/test/collectors-parsers.test.ts
new file mode 100644
index 00000000..90cb6e23
--- /dev/null
+++ b/apps/desktop/test/collectors-parsers.test.ts
@@ -0,0 +1,245 @@
+/**
+ * @file collectors-parsers.test.ts
+ * @description Validates the first-party harness parsers (FEA-1503) against
+ * synthetic transcripts in the documented on-disk formats. Fixtures are carried
+ * over from the prior vendor-parser tests so the CommonJS→TypeScript port is
+ * proven not to drift, plus a Claude transcript fixture for the new first-party
+ * Claude collector.
+ */
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { test } from "node:test";
+
+import { workspacePathFromUri } from "../src/main/collectors/copilot/copilot-home.js";
+import { parseChatSessionFile } from "../src/main/collectors/copilot/copilot-parser.js";
+import { loadSessionsFromDb } from "../src/main/collectors/opencode/opencode-parser.js";
+import { parseTranscriptFile } from "../src/main/collectors/cursor/cursor-parser.js";
+import { parseSessionFile as parseClaudeFile } from "../src/main/collectors/claude/claude-parser.js";
+
+test("Copilot workspace file URIs decode to filesystem paths", () => {
+  assert.equal(
+    workspacePathFromUri("file:///Users/dev/my%20project"),
+    "/Users/dev/my project",
+  );
+});
+
+test("Copilot Chat parser supports request-based session files", () => {
+  const dir = mkdtempSync(path.join(tmpdir(), "copilot-chat-"));
+  const filePath = path.join(dir, "session.json");
+  writeFileSync(
+    filePath,
+    JSON.stringify({
+      sessionId: "copilot-session-1",
+      creationDate: 1710000000000,
+      lastMessageDate: 1710000060000,
+      requests: [
+        {
+          id: "req-1",
+          timestamp: 1710000000000,
+          message: { text: "Summarize the repo" },
+          response: { markdown: "Here is the summary." },
+          toolCalls: [{ name: "search", arguments: '{"query":"repo"}' }],
+          reasoning: { summary: "think first" },
+        },
+      ],
+    }),
+    "utf8",
+  );
+
+  const parsed = parseChatSessionFile(filePath, "/Users/dev/my project");
+  assert.ok(parsed, "expected a parsed Copilot chat session");
+  assert.equal(parsed.sessionId, "copilot-chat-copilot-session-1");
+  assert.equal(parsed.name, "my project");
+  assert.equal(parsed.userMessages, 1);
+  assert.equal(parsed.assistantMessages, 1);
+  assert.equal(parsed.toolUses.length, 1);
+  assert.equal(parsed.toolUses[0].name, "search");
+  assert.equal(parsed.thinkingBlockCount, 1);
+  assert.deepEqual(parsed.turnDurations, [
+    { durationMs: 60_000, timestamp: "2024-03-09T16:01:00.000Z" },
+  ]);
+  assert.equal(parsed.entrypoint, "copilot");
+  assert.equal(parsed.startedAt, "2024-03-09T16:00:00.000Z");
+  assert.equal(parsed.endedAt, "2024-03-09T16:01:00.000Z");
+});
+
+test("OpenCode parser loads sessions from opencode.db", () => {
+  const dir = mkdtempSync(path.join(tmpdir(), "opencode-db-"));
+  const dbPath = path.join(dir, "opencode.db");
+  const db = new DatabaseSync(dbPath);
+  db.exec(`
+    CREATE TABLE session (
+      id TEXT PRIMARY KEY, slug TEXT, directory TEXT NOT NULL, title TEXT NOT NULL,
+      version TEXT NOT NULL, agent TEXT, model TEXT, permission TEXT,
+      time_created INTEGER NOT NULL, time_updated INTEGER NOT NULL,
+      tokens_input INTEGER DEFAULT 0 NOT NULL, tokens_output INTEGER DEFAULT 0 NOT NULL,
+      tokens_reasoning INTEGER DEFAULT 0 NOT NULL, tokens_cache_read INTEGER DEFAULT 0 NOT NULL,
+      tokens_cache_write INTEGER DEFAULT 0 NOT NULL
+    );
+    CREATE TABLE message (
+      id TEXT PRIMARY KEY, session_id TEXT NOT NULL, time_created INTEGER NOT NULL,
+      time_updated INTEGER NOT NULL, data TEXT NOT NULL
+    );
+    CREATE TABLE part (
+      id TEXT PRIMARY KEY, message_id TEXT NOT NULL, session_id TEXT NOT NULL,
+      time_created INTEGER NOT NULL, time_updated INTEGER NOT NULL, data TEXT NOT NULL
+    );
+  `);
+
+  db.prepare(`
+    INSERT INTO session (
+      id, slug, directory, title, version, agent, model, permission,
+      time_created, time_updated, tokens_input, tokens_output,
+      tokens_reasoning, tokens_cache_read, tokens_cache_write
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(
+    "ses_1", "quiet-orchid", "/Users/dev/my project", "Repo overview", "1.15.5",
+    "build", JSON.stringify({ id: "big-pickle", providerID: "opencode" }), "",
+    1710000000000, 1710000060000, 100, 20, 5, 40, 0,
+  );
+  db.prepare(`INSERT INTO message (id, session_id, time_created, time_updated, data) VALUES (?, ?, ?, ?, ?)`).run(
+    "msg_1", "ses_1", 1710000000000, 1710000000000,
+    JSON.stringify({ role: "user", time: { created: 1710000000000 } }),
+  );
+  db.prepare(`INSERT INTO message (id, session_id, time_created, time_updated, data) VALUES (?, ?, ?, ?, ?)`).run(
+    "msg_2", "ses_1", 1710000030000, 1710000030000,
+    JSON.stringify({
+      role: "assistant",
+      path: { cwd: "/Users/dev/my project", root: "/Users/dev/my project" },
+      time: { created: 1710000030000 },
+    }),
+  );
+  db.prepare(`INSERT INTO part (id, message_id, session_id, time_created, time_updated, data) VALUES (?, ?, ?, ?, ?, ?)`).run(
+    "part_2", "msg_2", "ses_1", 1710000025000, 1710000026000,
+    JSON.stringify({
+      type: "tool",
+      tool: "read",
+      state: { status: "completed", input: { filePath: "/Users/dev/my project/README.md" } },
+      time: { start: 1710000025000, end: 1710000026000 },
+    }),
+  );
+  db.close();
+
+  const sessions = loadSessionsFromDb(dbPath);
+  assert.equal(sessions.length, 1);
+  const parsed = sessions[0];
+  assert.equal(parsed.sessionId, "opencode-ses_1");
+  assert.equal(parsed.cwd, "/Users/dev/my project");
+  assert.equal(parsed.name, "my project");
+  assert.equal(parsed.model, "big-pickle");
+  assert.equal(parsed.version, "1.15.5");
+  assert.equal(parsed.toolUses.length, 1);
+  assert.equal(parsed.toolUses[0].name, "read");
+  assert.deepEqual(parsed.tokensByModel["big-pickle"], {
+    input: 100,
+    output: 25,
+    cacheRead: 40,
+    cacheWrite: 0,
+  });
+});
+
+test("Cursor parser derives turn durations from user/assistant timestamps", async () => {
+  const dir = mkdtempSync(path.join(tmpdir(), "cursor-transcript-"));
+  const sessionDir = path.join(dir, "session-123");
+  mkdirSync(sessionDir, { recursive: true });
+  const filePath = path.join(sessionDir, "rollout.jsonl");
+  writeFileSync(
+    filePath,
+    [
+      {
+        timestamp: "2024-03-09T16:00:00.000Z",
+        type: "session_meta",
+        payload: { cwd: "/Users/dev/cursor project", model: "claude-3-7-sonnet" },
+      },
+      {
+        timestamp: "2024-03-09T16:00:05.000Z",
+        type: "user_message",
+        payload: { message: "Investigate failing test" },
+      },
+      {
+        timestamp: "2024-03-09T16:00:11.500Z",
+        type: "assistant_message",
+        payload: { message: "Looking now" },
+      },
+    ]
+      .map((line) => JSON.stringify(line))
+      .join("\n"),
+    "utf8",
+  );
+
+  const parsed = await parseTranscriptFile(filePath);
+  assert.ok(parsed, "expected a parsed Cursor transcript");
+  assert.deepEqual(parsed.turnDurations, [
+    { durationMs: 6_500, timestamp: "2024-03-09T16:00:11.500Z" },
+  ]);
+});
+
+test("Claude parser extracts session metadata, tokens, tools, and thinking", async () => {
+  const dir = mkdtempSync(path.join(tmpdir(), "claude-proj-"));
+  const filePath = path.join(dir, "claude-sess-1.jsonl");
+  writeFileSync(
+    filePath,
+    [
+      {
+        type: "user",
+        timestamp: "2024-03-09T16:00:00.000Z",
+        cwd: "/Users/dev/proj",
+        gitBranch: "main",
+        version: "1.2.3",
+      },
+      {
+        type: "assistant",
+        timestamp: "2024-03-09T16:00:05.000Z",
+        message: {
+          model: "claude-opus-4-5",
+          usage: {
+            input_tokens: 100,
+            output_tokens: 50,
+            cache_read_input_tokens: 10,
+            cache_creation_input_tokens: 5,
+          },
+          content: [
+            { type: "thinking", thinking: "hmm" },
+            { type: "tool_use", name: "Read", input: { file_path: "x" } },
+          ],
+        },
+      },
+    ]
+      .map((line) => JSON.stringify(line))
+      .join("\n"),
+    "utf8",
+  );
+
+  const parsed = await parseClaudeFile(filePath);
+  assert.ok(parsed, "expected a parsed Claude transcript");
+  assert.equal(parsed.sessionId, "claude-sess-1");
+  assert.equal(parsed.cwd, "/Users/dev/proj");
+  assert.equal(parsed.gitBranch, "main");
+  assert.equal(parsed.version, "1.2.3");
+  assert.equal(parsed.model, "claude-opus-4-5");
+  assert.equal(parsed.userMessages, 1);
+  assert.equal(parsed.assistantMessages, 1);
+  assert.equal(parsed.thinkingBlockCount, 1);
+  assert.equal(parsed.toolUses.length, 1);
+  assert.equal(parsed.toolUses[0].name, "Read");
+  assert.deepEqual(parsed.messageTimestamps, ["2024-03-09T16:00:05.000Z"]);
+  assert.deepEqual(parsed.tokensByModel["claude-opus-4-5"], {
+    input: 100,
+    output: 50,
+    cacheRead: 10,
+    cacheWrite: 5,
+  });
+  assert.equal(parsed.startedAt, "2024-03-09T16:00:00.000Z");
+  assert.equal(parsed.endedAt, "2024-03-09T16:00:05.000Z");
+  assert.equal(parsed.entrypoint, "claude");
+});
+
+test("Claude parser returns null for a transcript with no timestamps", async () => {
+  const dir = mkdtempSync(path.join(tmpdir(), "claude-empty-"));
+  const filePath = path.join(dir, "empty.jsonl");
+  writeFileSync(filePath, `${JSON.stringify({ type: "summary" })}\n`, "utf8");
+  assert.equal(await parseClaudeFile(filePath), null);
+});
diff --git a/apps/desktop/test/db-ipc-validation.test.ts b/apps/desktop/test/db-ipc-validation.test.ts
new file mode 100644
index 00000000..0a34ed77
--- /dev/null
+++ b/apps/desktop/test/db-ipc-validation.test.ts
@@ -0,0 +1,28 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+
+import { coerceDbId, MAX_DB_ID_LENGTH } from "../src/main/database/ipc-validation.js";
+
+test("coerceDbId accepts a normal id string unchanged", () => {
+  assert.equal(coerceDbId("session-123"), "session-123");
+  assert.equal(coerceDbId("a"), "a");
+});
+
+test("coerceDbId rejects an empty string", () => {
+  assert.equal(coerceDbId(""), null);
+});
+
+test("coerceDbId rejects an oversized string", () => {
+  assert.equal(coerceDbId("x".repeat(MAX_DB_ID_LENGTH)), "x".repeat(MAX_DB_ID_LENGTH));
+  assert.equal(coerceDbId("x".repeat(MAX_DB_ID_LENGTH + 1)), null);
+});
+
+test("coerceDbId rejects non-string values that would corrupt SQLite bindings", () => {
+  // The exact "[object Object]" primary-key hazard the review flagged.
+  assert.equal(coerceDbId({ malicious: true }), null);
+  assert.equal(coerceDbId(["a", "b"]), null);
+  assert.equal(coerceDbId(42), null);
+  assert.equal(coerceDbId(true), null);
+  assert.equal(coerceDbId(null), null);
+  assert.equal(coerceDbId(undefined), null);
+});
diff --git a/apps/desktop/test/feature-flags.test.ts b/apps/desktop/test/feature-flags.test.ts
index 199afba7..561e94aa 100644
--- a/apps/desktop/test/feature-flags.test.ts
+++ b/apps/desktop/test/feature-flags.test.ts
@@ -3,6 +3,7 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { afterEach, test } from "node:test";
+import { resolveAgentDashboardMode } from "../src/main/agent-dashboard-mode.js";
 import { SettingsStore } from "../src/main/settings-store.js";
 import { FEATURE_FLAGS, type FlagKey } from "../src/shared/feature-flags.js";
 
@@ -38,6 +39,11 @@ function makeStore(seed: Record<string, unknown> = {}): SettingsStore {
 test("getFlag returns registry default when key is absent from store", () => {
   const store = makeStore();
   assert.equal(store.getFlag("agentMonitorEnabled"), true, "agentMonitorEnabled defaults to true");
+  assert.equal(
+    store.getFlag("agentDashboardDesignSystemEnabled"),
+    false,
+    "design-system dashboard is opt-in and defaults to false",
+  );
   assert.equal(store.getFlag("planExtractionEnabled"), false, "planExtractionEnabled defaults to false");
 });
 
@@ -120,6 +126,38 @@ test("legacy getters return same values as getFlag", () => {
   );
 });
 
+test("agent dashboard mode preserves legacy default and requires strict design flag true", () => {
+  assert.equal(
+    resolveAgentDashboardMode({
+      getAgentMonitorEnabled: () => true,
+      getFlag: () => false,
+    }),
+    "legacy",
+  );
+  assert.equal(
+    resolveAgentDashboardMode({
+      getAgentMonitorEnabled: () => true,
+      getFlag: () => true,
+    }),
+    "design-system",
+  );
+  assert.equal(
+    resolveAgentDashboardMode({
+      getAgentMonitorEnabled: () => false,
+      getFlag: () => true,
+    }),
+    "disabled",
+  );
+  assert.equal(
+    resolveAgentDashboardMode({
+      getAgentMonitorEnabled: () => true,
+      getFlag: () => "true" as unknown as boolean,
+    }),
+    "legacy",
+    "tampered non-boolean values must not opt into design-system mode",
+  );
+});
+
 test("legacy setters persist through getFlag", () => {
   const store = makeStore();
   store.setPlanExtractionEnabled(true);
diff --git a/apps/desktop/test/reconciliation-worker.test.ts b/apps/desktop/test/reconciliation-worker.test.ts
index 8b469b7e..3d1e73a1 100644
--- a/apps/desktop/test/reconciliation-worker.test.ts
+++ b/apps/desktop/test/reconciliation-worker.test.ts
@@ -442,9 +442,9 @@ test("persists reconciled rows into a real ReconciliationStore", async () => {
   assert.equal(listed[0].localEstimateMicroCents, local);
 });
 
-test("loadMeteredUsageRows sums effective (raw+baseline) tokens, metered only, within the cutoff", () => {
+test("loadMeteredUsageRows reads effective tokens, metered only, within the cutoff", () => {
   const dir = makeTempDir();
-  const dbPath = path.join(dir, "dashboard.db");
+  const dbPath = path.join(dir, "agent-dashboard.sqlite");
   const db = new DatabaseSync(dbPath);
   db.exec(
     `CREATE TABLE sessions (
@@ -453,13 +453,15 @@ test("loadMeteredUsageRows sums effective (raw+baseline) tokens, metered only, w
        metadata TEXT, harness TEXT, billing_mode TEXT
      )`,
   );
+  // FEA-1497 in-process schema: the plain columns already hold the effective
+  // reconciled counts (raw_* are write-time accumulators, not read here).
   db.exec(
     `CREATE TABLE token_usage (
        session_id TEXT, model TEXT DEFAULT 'unknown',
        input_tokens INTEGER, output_tokens INTEGER,
        cache_read_tokens INTEGER, cache_write_tokens INTEGER,
-       baseline_input INTEGER, baseline_output INTEGER,
-       baseline_cache_read INTEGER, baseline_cache_write INTEGER,
+       raw_input INTEGER, raw_output INTEGER,
+       raw_cache_read INTEGER, raw_cache_write INTEGER,
        PRIMARY KEY (session_id, model)
      )`,
   );
@@ -468,21 +470,19 @@ test("loadMeteredUsageRows sums effective (raw+baseline) tokens, metered only, w
   );
   const insertUsage = db.prepare(
     `INSERT INTO token_usage
-       (session_id, model, input_tokens, output_tokens, cache_read_tokens,
-        cache_write_tokens, baseline_input, baseline_output, baseline_cache_read,
-        baseline_cache_write)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+       (session_id, model, input_tokens, output_tokens, cache_read_tokens, cache_write_tokens)
+     VALUES (?, ?, ?, ?, ?, ?)`,
   );
 
-  // Metered, in-window session: effective tokens are raw + baseline.
+  // Metered, in-window session: effective tokens live in the plain columns.
   insertSession.run("s1", "2026-05-20T10:00:00Z", "claude", "api");
-  insertUsage.run("s1", "claude-opus-4-5", 1000, 200, 50, 10, 500, 100, 25, 5);
+  insertUsage.run("s1", "claude-opus-4-5", 1500, 300, 75, 15);
   // Subscription session — excluded by the metered filter.
   insertSession.run("s2", "2026-05-20T10:00:00Z", "claude", "subscription_unknown");
-  insertUsage.run("s2", "claude-opus-4-5", 1000, 200, 0, 0, 0, 0, 0, 0);
+  insertUsage.run("s2", "claude-opus-4-5", 1000, 200, 0, 0);
   // Metered but before the cutoff — excluded by the window.
   insertSession.run("s3", "2025-01-01T00:00:00Z", "claude", "api");
-  insertUsage.run("s3", "claude-opus-4-5", 1, 2, 3, 4, 0, 0, 0, 0);
+  insertUsage.run("s3", "claude-opus-4-5", 1, 2, 3, 4);
 
   const cutoff = reconciliationCutoffIso(new Date("2026-05-28T00:00:00Z"), 35);
   const rows = loadMeteredUsageRows(db, cutoff);
diff --git a/apps/desktop/test/renderer-logs-static.test.ts b/apps/desktop/test/renderer-logs-static.test.ts
index 40d5186c..5e862f27 100644
--- a/apps/desktop/test/renderer-logs-static.test.ts
+++ b/apps/desktop/test/renderer-logs-static.test.ts
@@ -3,55 +3,59 @@ import fs from "node:fs";
 import path from "node:path";
 import { describe, test } from "node:test";
 
-const rendererPath = path.resolve("src/renderer/index.html");
-
-function readRenderer(): string {
-  return fs.readFileSync(rendererPath, "utf8");
+function readSource(relativePath: string): string {
+  return fs.readFileSync(path.resolve(relativePath), "utf8");
 }
 
-describe("renderer Diagnostics and update banner wiring", () => {
-  test("Diagnostics uses incremental rendering controls instead of whole-list HTML replacement", () => {
-    const html = readRenderer();
-
-    assert.equal(html.includes("logsList.innerHTML"), false);
-    assert.match(html, /id="pauseLogsBtn"/);
-    assert.match(html, /id="openLogFileBtn"/);
-    assert.match(html, /Paused - \$\{queuedCount\} new entries queued/);
-    assert.match(html, /entry\.session === "previous"/);
-    assert.match(html, /previous session/);
-    assert.match(html, /api\.openLogFile/);
-    assert.match(html, /api\.getLogFilePath/);
-    assert.match(html, /void pollLogs\(\);/);
-    assert.match(html, /function renderLogs\(entries = \[\]\)/);
+// FEA-1497: PR #264 replaced the monolithic inline-JS index.html shell (which
+// hosted the Diagnostics log viewer, the packaged update banner, and the
+// security-settings copy) with a first-party React renderer. The update banner
+// and API-key controls are now delivered as React components, so the previous
+// string guards against index.html are superseded. These guards instead assert
+// that the React components wire the real IPC channels/events. Behavior of the
+// banner's visibility/apply gate is unit-tested in update-banner-state.test.ts.
+describe("React renderer update banner wiring", () => {
+  test("UpdateBanner subscribes to update events and gates apply on download", () => {
+    const banner = readSource("src/renderer/components/UpdateBanner.tsx");
+
+    assert.match(banner, /desktop:update-status/);
+    assert.match(banner, /desktop:update-available/);
+    assert.match(banner, /window\.desktopApi\.applyUpdate\(\)/);
+    assert.match(banner, /isUpdateApplyEnabled/);
+    assert.match(banner, /Update & restart/);
   });
 
-  test("packaged update banner listens for update-status and gates on downloaded readiness", () => {
-    const html = readRenderer();
+  test("UpdateBanner is mounted in the app shell", () => {
+    const app = readSource("src/renderer/App.tsx");
 
-    assert.match(html, /desktop:update-status/);
-    assert.match(html, /status\?\.status === "downloaded"/);
-    assert.match(html, /status\?\.readyToInstall === true/);
-    assert.match(html, /status\?\.status === "available"/);
-    assert.match(html, /status\?\.status === "downloading"/);
-    assert.match(html, /hideUpdateBanner\(\)/);
-    assert.match(html, /Update &amp; restart/);
+    assert.match(app, /import \{ UpdateBanner \} from "\.\/components\/UpdateBanner"/);
+    assert.match(app, /<UpdateBanner\s*\/>/);
   });
+});
 
-  test("Security settings copy covers command signing enforcement states", () => {
-    const html = readRenderer();
-
-    assert.match(html, /id="commandSigningEnforcementEnabled"/);
-    assert.match(html, /<section class="sec-section" hidden id="browserCommandKeysSection">/);
-    assert.match(html, /const serverSupported = state\.serverSupported === true;/);
-    assert.match(html, /browserCommandKeysSection\.hidden = !serverSupported;/);
-    assert.match(html, /updateSigningPostureUnavailable\(\);/);
-    assert.match(html, /Current server does not support trusted browser keys/);
-    assert.match(html, /Browser command keys let this Desktop trust specific web browsers/);
-    assert.match(html, /signed-in browser sessions with access to this Desktop can send commands without an approved key/);
-    assert.match(html, /If you require trusted keys before approving one, browser commands will be rejected/);
-    assert.match(html, /Only trusted browser keys can send cloud commands to this Desktop/);
-    assert.match(html, /Requiring trusted keys before approving a browser key will reject browser commands/);
-    assert.match(html, /\.sec-toggle input\s*{[^}]*margin: 0;/s);
-    assert.match(html, /desktop:command-keys-changed/);
+describe("React renderer Security tab API-key controls", () => {
+  test("SecurityTab wires set/clear/status IPC for the desktop API key", () => {
+    const panel = readSource("src/renderer/components/settings/SettingsPanel.tsx");
+
+    assert.match(panel, /window\.desktopApi\.getApiKeyStatus\(/);
+    assert.match(panel, /window\.desktopApi\.setApiKey\(/);
+    assert.match(panel, /window\.desktopApi\.clearApiKey\(/);
+    // Set and Clear buttons must be present and refresh status after mutating.
+    assert.match(panel, /onClick=\{handleSetApiKey\}/);
+    assert.match(panel, /onClick=\{handleClearApiKey\}/);
+    assert.match(panel, /refreshApiKeyStatus\(\)/);
   });
 });
+
+// Still deferred beyond PR #264's settings slice: the React Diagnostics
+// incremental-rendering controls (LogsPanel) and the security command-signing /
+// browser-command-key management UI. These were covered by the old inline-JS
+// index.html guards; re-guard them when the corresponding React work lands.
+describe(
+  "deferred React renderer guards (Diagnostics incremental render, command-signing UI)",
+  { skip: "deferred beyond PR #264 settings slice; not yet implemented in React renderer" },
+  () => {
+    test("Diagnostics incremental log rendering controls (deferred)", () => {});
+    test("Security command-signing / browser-command-key UI copy (deferred)", () => {});
+  },
+);
diff --git a/apps/desktop/test/token-cost.test.ts b/apps/desktop/test/token-cost.test.ts
index 4820186d..b74b4700 100644
--- a/apps/desktop/test/token-cost.test.ts
+++ b/apps/desktop/test/token-cost.test.ts
@@ -1,28 +1,19 @@
 /**
  * @file token-cost.test.ts
- * @description Parity + correctness tests for the canonical token-cost engine.
+ * @description Correctness tests for the first-party token-cost engine
+ * (`src/shared/token-cost.ts`). FEA-1503 removed the vendor CJS twin
+ * (`scripts/agent-monitor-cost/cost-pricing.js`); the first-party engine is now
+ * the single source of truth, so this exercises it directly.
  *
- * There are TWO copies of the engine that must never diverge:
- *   • the desktop-main ESM twin  — src/shared/token-cost.ts
- *   • the sidecar CJS engine     — scripts/agent-monitor-cost/cost-pricing.js
- * They live in different module systems (the sidecar runs in a generated
- * CommonJS tree; desktop-main is ESM and must work with the sidecar disabled),
- * so the code is duplicated. This test imports BOTH and asserts byte-equal
- * output across a fixture matrix so a change to one without the other fails CI.
- *
- * It also pins a handful of known dollar values (against the pinned
+ * It pins a handful of known dollar values (against the pinned
  * @pydantic/genai-prices version) and verifies CACHE_ADDITIVE_PROVIDERS matches
  * the library's OWN extractUsage summing behavior — so if a future library
  * version changes which providers report cache additively, this test fails and
  * we update the Set deliberately rather than silently misprice.
  */
 import assert from "node:assert/strict";
-import { createRequire } from "node:module";
 import { test } from "node:test";
-import {
-  extractUsage,
-  findProvider,
-} from "@pydantic/genai-prices";
+import { extractUsage, findProvider } from "@pydantic/genai-prices";
 import {
   buildUsage as buildUsageTwin,
   CACHE_ADDITIVE_PROVIDERS as ADDITIVE_TWIN,
@@ -30,24 +21,6 @@ import {
   type TokenCostInput,
 } from "../src/shared/token-cost.js";
 
-// The sidecar engine is CommonJS (its dir is scoped type:commonjs). Load it via
-// createRequire so the require("@pydantic/genai-prices") inside it resolves the
-// same way it does inside the generated sidecar tree.
-const require = createRequire(import.meta.url);
-const engine = require("../scripts/agent-monitor-cost/cost-pricing.js") as {
-  computeTokenCost: (input: TokenCostInput) => unknown;
-  buildUsage: (
-    providerId: string | null,
-    counts: {
-      input: number;
-      output: number;
-      cacheRead: number;
-      cacheWrite: number;
-    },
-  ) => unknown;
-  CACHE_ADDITIVE_PROVIDERS: Set<string>;
-};
-
 // Fixture matrix exercising every code path: provider-aware normalization,
 // cache combos, unpriced models, empty model, zero/negative/string coercion,
 // and timestamped historical pricing.
@@ -145,17 +118,23 @@ const FIXTURES: Array<{ name: string; input: TokenCostInput }> = [
   },
 ];
 
-test("twin and sidecar engine return byte-equal results across the fixture matrix", () => {
+test("computeTokenCost returns a well-formed result across the fixture matrix", () => {
   for (const { name, input } of FIXTURES) {
-    const twin = computeTokenCostTwin(input);
-    const cjs = engine.computeTokenCost(input);
-    assert.deepEqual(
-      twin,
-      cjs,
-      `twin/engine drift for fixture: ${name}\n` +
-        `  twin:   ${JSON.stringify(twin)}\n` +
-        `  engine: ${JSON.stringify(cjs)}`,
-    );
+    const result = computeTokenCostTwin(input);
+    assert.equal(typeof result.priced, "boolean", `priced shape for: ${name}`);
+    if (result.priced) {
+      assert.equal(typeof result.costUsd, "number", `costUsd for: ${name}`);
+      assert.ok(
+        (result.costUsd ?? -1) >= 0,
+        `costUsd non-negative for: ${name}`,
+      );
+    } else {
+      assert.equal(result.costUsd, null, `unpriced costUsd null for: ${name}`);
+      assert.ok(
+        typeof result.reason === "string" && result.reason.length > 0,
+        `unpriced reason for: ${name}`,
+      );
+    }
   }
 });
 
@@ -242,8 +221,7 @@ test("buildUsage applies the provider-aware input convention", () => {
 
   // Anthropic → additive grand total.
   assert.equal(
-    (buildUsageTwin("anthropic", counts) as { input_tokens: number })
-      .input_tokens,
+    (buildUsageTwin("anthropic", counts) as { input_tokens: number }).input_tokens,
     1800,
   );
   // OpenAI → input passes through (cache is a subset).
@@ -257,22 +235,9 @@ test("buildUsage applies the provider-aware input convention", () => {
     (buildUsageTwin(null, counts) as { input_tokens: number }).input_tokens,
     1000,
   );
-
-  // Twin and engine buildUsage agree.
-  for (const providerId of ["anthropic", "openai", null] as const) {
-    assert.deepEqual(
-      buildUsageTwin(providerId, counts),
-      engine.buildUsage(providerId, counts),
-    );
-  }
 });
 
 test("CACHE_ADDITIVE_PROVIDERS matches the library's own extractUsage summing", () => {
-  // Twin and engine declare the same set.
-  assert.deepEqual([...ADDITIVE_TWIN].sort(), [
-    ...engine.CACHE_ADDITIVE_PROVIDERS,
-  ].sort());
-
   // Anthropic: extractUsage SUMS input + cache → additive, so it MUST be in the
   // set. Raw input_tokens is fresh; cache fields are separate/additive.
   const anthropic = findProvider({ modelId: "claude-opus-4-5" });
@@ -294,10 +259,7 @@ test("CACHE_ADDITIVE_PROVIDERS matches the library's own extractUsage summing",
     1800,
     "anthropic extractUsage should SUM cache into input_tokens",
   );
-  assert.ok(
-    ADDITIVE_TWIN.has("anthropic"),
-    "anthropic sums → must be additive",
-  );
+  assert.ok(ADDITIVE_TWIN.has("anthropic"), "anthropic sums → must be additive");
 
   // OpenAI: extractUsage does NOT sum (cached is a subset of input) → inclusive,
   // so it MUST NOT be in the set.
@@ -319,8 +281,5 @@ test("CACHE_ADDITIVE_PROVIDERS matches the library's own extractUsage summing",
     1000,
     "openai extractUsage should NOT sum cache into input_tokens",
   );
-  assert.ok(
-    !ADDITIVE_TWIN.has("openai"),
-    "openai does not sum → must be inclusive",
-  );
+  assert.ok(!ADDITIVE_TWIN.has("openai"), "openai does not sum → must be inclusive");
 });
diff --git a/apps/desktop/test/update-banner-state.test.ts b/apps/desktop/test/update-banner-state.test.ts
new file mode 100644
index 00000000..7c8e5847
--- /dev/null
+++ b/apps/desktop/test/update-banner-state.test.ts
@@ -0,0 +1,141 @@
+import assert from "node:assert/strict";
+import { describe, test } from "node:test";
+import {
+  INITIAL_UPDATE_BANNER_STATE,
+  isUpdateApplyEnabled,
+  isUpdateBannerVisible,
+  reduceUpdateAvailableEvent,
+  reduceUpdateStatusEvent,
+  updateBannerMessage,
+} from "../src/renderer/components/update-banner-state.js";
+
+// FEA-1497: behavior guards for the React UpdateBanner's decision logic.
+// PR #264 replaced the old inline-JS update banner; the renderer no longer
+// renders raw HTML, so we unit-test the pure visibility/apply reducers that
+// drive the component instead of string-matching index.html.
+describe("update banner state (desktop:update-status / desktop:update-available)", () => {
+  test("initial idle state hides the banner and disables apply", () => {
+    assert.equal(isUpdateBannerVisible(INITIAL_UPDATE_BANNER_STATE), false);
+    assert.equal(isUpdateApplyEnabled(INITIAL_UPDATE_BANNER_STATE), false);
+  });
+
+  test("not-available status keeps the banner hidden", () => {
+    const next = reduceUpdateStatusEvent(INITIAL_UPDATE_BANNER_STATE, {
+      status: "not-available",
+      updateAvailable: false,
+      readyToInstall: false,
+    });
+    assert.equal(isUpdateBannerVisible(next), false);
+  });
+
+  test("available status shows the banner but does not enable apply", () => {
+    const next = reduceUpdateStatusEvent(INITIAL_UPDATE_BANNER_STATE, {
+      status: "available",
+      updateAvailable: true,
+      readyToInstall: false,
+      version: "0.14.30",
+    });
+    assert.equal(next.status, "available");
+    assert.equal(isUpdateBannerVisible(next), true);
+    assert.equal(isUpdateApplyEnabled(next), false);
+    assert.match(updateBannerMessage(next), /0\.14\.30/);
+  });
+
+  test("downloading status surfaces progress and stays non-installable", () => {
+    const next = reduceUpdateStatusEvent(INITIAL_UPDATE_BANNER_STATE, {
+      status: "downloading",
+      updateAvailable: true,
+      readyToInstall: false,
+      version: "0.14.30",
+      percent: 42.6,
+    });
+    assert.equal(isUpdateBannerVisible(next), true);
+    assert.equal(isUpdateApplyEnabled(next), false);
+    assert.match(updateBannerMessage(next), /43%/);
+  });
+
+  test("downloaded + readyToInstall enables the Apply / Restart action", () => {
+    const next = reduceUpdateStatusEvent(INITIAL_UPDATE_BANNER_STATE, {
+      status: "downloaded",
+      updateAvailable: true,
+      readyToInstall: true,
+      version: "0.14.30",
+      percent: 100,
+    });
+    assert.equal(isUpdateBannerVisible(next), true);
+    assert.equal(isUpdateApplyEnabled(next), true);
+    assert.match(updateBannerMessage(next), /ready to install/i);
+  });
+
+  test("readyToInstall must require the downloaded status (defensive gate)", () => {
+    // A spoofed/stale payload claiming readiness without the downloaded status
+    // must not enable apply, mirroring the main-process invariant.
+    const spoofed = reduceUpdateStatusEvent(INITIAL_UPDATE_BANNER_STATE, {
+      status: "available",
+      updateAvailable: true,
+      readyToInstall: true,
+    });
+    assert.equal(isUpdateApplyEnabled(spoofed), false);
+  });
+
+  test("error status shows the banner with a bounded message", () => {
+    const next = reduceUpdateStatusEvent(INITIAL_UPDATE_BANNER_STATE, {
+      status: "error",
+      updateAvailable: false,
+      readyToInstall: false,
+      error: "download failed",
+    });
+    assert.equal(isUpdateBannerVisible(next), true);
+    assert.equal(isUpdateApplyEnabled(next), false);
+    assert.match(updateBannerMessage(next), /download failed/);
+  });
+
+  test("malformed update-status payloads are ignored (untrusted boundary)", () => {
+    const base = reduceUpdateStatusEvent(INITIAL_UPDATE_BANNER_STATE, {
+      status: "downloaded",
+      updateAvailable: true,
+      readyToInstall: true,
+      version: "0.14.30",
+    });
+    assert.equal(reduceUpdateStatusEvent(base, null), base);
+    assert.equal(reduceUpdateStatusEvent(base, { status: "bogus" }), base);
+    assert.equal(reduceUpdateStatusEvent(base, "downloaded"), base);
+  });
+
+  test("update-available nudge escalates idle to available with version", () => {
+    const next = reduceUpdateAvailableEvent(INITIAL_UPDATE_BANNER_STATE, {
+      updateAvailable: true,
+      version: "0.14.30",
+      readyToInstall: false,
+    });
+    assert.equal(next.status, "available");
+    assert.equal(next.updateAvailable, true);
+    assert.equal(next.version, "0.14.30");
+    assert.equal(isUpdateBannerVisible(next), true);
+  });
+
+  test("update-available nudge never regresses a downloaded state", () => {
+    const downloaded = reduceUpdateStatusEvent(INITIAL_UPDATE_BANNER_STATE, {
+      status: "downloaded",
+      updateAvailable: true,
+      readyToInstall: true,
+      version: "0.14.30",
+    });
+    const afterNudge = reduceUpdateAvailableEvent(downloaded, {
+      updateAvailable: true,
+      version: "0.14.30",
+      readyToInstall: false,
+    });
+    assert.equal(afterNudge.status, "downloaded");
+    assert.equal(isUpdateApplyEnabled(afterNudge), true);
+  });
+
+  test("update-available with updateAvailable falsey is a no-op", () => {
+    assert.equal(
+      reduceUpdateAvailableEvent(INITIAL_UPDATE_BANNER_STATE, {
+        updateAvailable: false,
+      }),
+      INITIAL_UPDATE_BANNER_STATE,
+    );
+  });
+});
diff --git a/apps/desktop/tsconfig.json b/apps/desktop/tsconfig.json
index af86f2f1..1d7507e1 100644
--- a/apps/desktop/tsconfig.json
+++ b/apps/desktop/tsconfig.json
@@ -1,9 +1,13 @@
 {
   "extends": "../../tsconfig.base.json",
   "compilerOptions": {
-    "outDir": "dist"
+    "outDir": "dist",
+    "verbatimModuleSyntax": true
   },
   "include": [
     "src/**/*.ts"
+  ],
+  "exclude": [
+    "src/renderer"
   ]
 }
diff --git a/apps/desktop/tsconfig.renderer.json b/apps/desktop/tsconfig.renderer.json
new file mode 100644
index 00000000..56274154
--- /dev/null
+++ b/apps/desktop/tsconfig.renderer.json
@@ -0,0 +1,16 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "noEmit": true,
+    "jsx": "react-jsx",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "verbatimModuleSyntax": true,
+    "lib": ["ES2023", "DOM", "DOM.Iterable"],
+    "types": []
+  },
+  "include": [
+    "src/renderer/**/*.ts",
+    "src/renderer/**/*.tsx"
+  ]
+}
diff --git a/apps/desktop/vite.renderer.config.ts b/apps/desktop/vite.renderer.config.ts
new file mode 100644
index 00000000..ea9798d6
--- /dev/null
+++ b/apps/desktop/vite.renderer.config.ts
@@ -0,0 +1,61 @@
+import { defineConfig, type Plugin } from "vite";
+import react from "@vitejs/plugin-react";
+import tailwindcss from "@tailwindcss/vite";
+import path from "node:path";
+
+function stripCrossorigin(): Plugin {
+  return {
+    name: "strip-crossorigin",
+    transformIndexHtml: {
+      order: "post",
+      handler(html) {
+        return html.replace(/\s+crossorigin(=["\'][^"\']*["\'])?/g, "");
+      },
+    },
+  };
+}
+
+export default defineConfig({
+  root: "src/renderer",
+  base: "./",
+  plugins: [tailwindcss(), react(), stripCrossorigin()],
+  resolve: {
+    alias: {
+      "@": path.resolve("src/renderer"),
+    },
+  },
+  build: {
+    outDir: path.resolve("dist/renderer"),
+    emptyOutDir: true,
+    sourcemap: true,
+    chunkSizeWarningLimit: 1000,
+    rollupOptions: {
+      input: path.resolve("src/renderer/design-system/index.html"),
+      onLog(level, log) {
+        if (
+          level === "warn" &&
+          log.code === "MODULE_LEVEL_DIRECTIVE" &&
+          log.message.includes("use client")
+        ) {
+          return;
+        }
+      },
+      output: {
+        manualChunks(id) {
+          if (id.includes("recharts") || id.includes("d3-") || id.includes("d3/")) {
+            return "vendor-charts";
+          }
+          if (id.includes("lucide-react")) {
+            return "vendor-icons";
+          }
+          if (id.includes("radix-ui") || id.includes("@radix-ui")) {
+            return "vendor-radix";
+          }
+          if (id.includes("@closedloop-ai/design-system")) {
+            return "vendor-ds";
+          }
+        },
+      },
+    },
+  },
+});
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index d9c7a6ec..2ae7e33a 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -10,9 +10,12 @@ importers:
 
   apps/desktop:
     dependencies:
+      '@closedloop-ai/design-system':
+        specifier: 0.1.1-dev.26892521643.1
+        version: 0.1.1-dev.26892521643.1(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(next-themes@0.4.6(react-dom@19.2.6(react@19.2.6))(react@19.2.6))(next@16.2.6(@babel/core@7.29.0)(@playwright/test@1.60.0)(react-dom@19.2.6(react@19.2.6))(react@19.2.6))(react-day-picker@9.14.0(react@19.2.6))(react-dom@19.2.6(react@19.2.6))(react-hook-form@7.76.1(react@19.2.6))(react-is@19.2.6)(react-resizable-panels@3.0.6(react-dom@19.2.6(react@19.2.6))(react@19.2.6))(react@19.2.6)(redux@5.0.1)
       '@closedloop-ai/loops-api':
-        specifier: 0.2.11
-        version: 0.2.11(zod@4.3.6)
+        specifier: '>=0.3.1'
+        version: 0.3.1(zod@4.3.6)
       '@pydantic/genai-prices':
         specifier: 0.0.62
         version: 0.0.62
@@ -34,6 +37,24 @@ importers:
       glob:
         specifier: ^11.0.1
         version: 11.1.0
+      lucide-react:
+        specifier: ^0.556.0
+        version: 0.556.0(react@19.2.6)
+      react:
+        specifier: ^19.2.6
+        version: 19.2.6
+      react-day-picker:
+        specifier: ^9.14.0
+        version: 9.14.0(react@19.2.6)
+      react-dom:
+        specifier: ^19.2.6
+        version: 19.2.6(react@19.2.6)
+      react-hook-form:
+        specifier: ^7.76.1
+        version: 7.76.1(react@19.2.6)
+      react-resizable-panels:
+        specifier: ^3.0.6
+        version: 3.0.6(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
       socket.io-client:
         specifier: ^4.8.1
         version: 4.8.3
@@ -44,12 +65,24 @@ importers:
       '@playwright/test':
         specifier: ^1.60.0
         version: 1.60.0
+      '@tailwindcss/typography':
+        specifier: ^0.5.19
+        version: 0.5.19(tailwindcss@4.3.0)
+      '@tailwindcss/vite':
+        specifier: ^4.3.0
+        version: 4.3.0(vite@6.1.0(@types/node@22.19.13)(jiti@2.6.1)(lightningcss@1.32.0)(tsx@4.21.0)(yaml@2.9.0))
       '@types/busboy':
         specifier: ^1.5.4
         version: 1.5.4
       '@types/node':
         specifier: ^22.13.8
         version: 22.19.13
+      '@types/react':
+        specifier: ^19.2.0
+        version: 19.2.15
+      '@types/react-dom':
+        specifier: ^19.2.0
+        version: 19.2.3(@types/react@19.2.15)
       '@typescript-eslint/eslint-plugin':
         specifier: ^8.57.1
         version: 8.57.1(@typescript-eslint/parser@8.57.1(eslint@10.0.3(jiti@2.6.1))(typescript@5.9.3))(eslint@10.0.3(jiti@2.6.1))(typescript@5.9.3)
@@ -58,7 +91,7 @@ importers:
         version: 8.57.1(eslint@10.0.3(jiti@2.6.1))(typescript@5.9.3)
       '@vitejs/plugin-react':
         specifier: 4.3.4
-        version: 4.3.4(vite@6.1.0(@types/node@22.19.13)(jiti@2.6.1)(tsx@4.21.0)(yaml@2.9.0))
+        version: 4.3.4(vite@6.1.0(@types/node@22.19.13)(jiti@2.6.1)(lightningcss@1.32.0)(tsx@4.21.0)(yaml@2.9.0))
       agent-dashboard-client:
         specifier: github:hoangsonww/Claude-Code-Agent-Monitor#840c518d7fa69231de049e41b893938228b67e40&path:/client
         version: https://codeload.github.com/hoangsonww/Claude-Code-Agent-Monitor/tar.gz/840c518d7fa69231de049e41b893938228b67e40#path:/client(typescript@5.9.3)
@@ -78,11 +111,17 @@ importers:
         specifier: 8.5.1
         version: 8.5.1
       tailwindcss:
-        specifier: 3.4.17
-        version: 3.4.17
+        specifier: 4.3.0
+        version: 4.3.0
+      tailwindcss-legacy:
+        specifier: npm:tailwindcss@3.4.17
+        version: tailwindcss@3.4.17
       tsx:
         specifier: ^4.19.3
         version: 4.21.0
+      tw-animate-css:
+        specifier: ^1.4.0
+        version: 1.4.0
       typescript:
         specifier: ^5.8.2
         version: 5.9.3
@@ -91,7 +130,7 @@ importers:
         version: 8.57.1(eslint@10.0.3(jiti@2.6.1))(typescript@5.9.3)
       vite:
         specifier: 6.1.0
-        version: 6.1.0(@types/node@22.19.13)(jiti@2.6.1)(tsx@4.21.0)(yaml@2.9.0)
+        version: 6.1.0(@types/node@22.19.13)(jiti@2.6.1)(lightningcss@1.32.0)(tsx@4.21.0)(yaml@2.9.0)
 
 packages:
 
@@ -173,8 +212,8 @@ packages:
     peerDependencies:
       '@babel/core': ^7.0.0-0
 
-  '@babel/runtime@7.29.2':
-    resolution: {integrity: sha512-JiDShH45zKHWyGe4ZNVRrCjBz8Nh9TMmZG1kh4QTK8hCBTWBi8Da+i7s1fJw7/lYpM4ccepSNfqzZ/QvABBi5g==}
+  '@babel/runtime@7.29.7':
+    resolution: {integrity: sha512-Nq8OhGWiZIZGV6hLHoyAKLLcJihP/xFeBMGJoUrxTX2psI8dCifzLhZISFb+VWS3wFMRDmCGw5R+dOySCqPLhw==}
     engines: {node: '>=6.9.0'}
 
   '@babel/template@7.28.6':
@@ -189,15 +228,45 @@ packages:
     resolution: {integrity: sha512-LwdZHpScM4Qz8Xw2iKSzS+cfglZzJGvofQICy7W7v4caru4EaAmyUuO6BGrbyQ2mYV11W0U8j5mBhd14dd3B0A==}
     engines: {node: '>=6.9.0'}
 
-  '@closedloop-ai/loops-api@0.2.11':
-    resolution: {integrity: sha512-PccBKMv2lOxxLFy8yc+Ebvf4n9nUZSvv5hUjc6VnSeqiqDFL8vEDPZE0gHoqKNgFw0fk/YGXk5dYX/j0Gz13ZA==, tarball: https://npm.pkg.github.com/download/@closedloop-ai/loops-api/0.2.11/4a90f1a3f20bbdc45a9b7da66704f73f7ce65d37}
+  '@cfcs/core@0.0.6':
+    resolution: {integrity: sha512-FxfJMwoLB8MEMConeXUCqtMGqxdtePQxRBOiGip9ULcYYam3WfCgoY6xdnMaSkYvRvmosp5iuG+TiPofm65+Pw==}
+
+  '@closedloop-ai/design-system@0.1.1-dev.26892521643.1':
+    resolution: {integrity: sha512-EkV2teCRT1NNsbOw3ZDHnt9uYbEkAaP+JufCcYTX91+fnvaM1hD0dMDFeGOvSYIhVeQiJc1mWoZbBFXVqKSDnw==, tarball: https://npm.pkg.github.com/download/@closedloop-ai/design-system/0.1.1-dev.26892521643.1/894a9bcb0520623ac0aaee4affd825fd7d6e955d}
+    peerDependencies:
+      next-themes: ^0.4.0
+      react: ^19.0.0
+      react-day-picker: ^9.0.0
+      react-hook-form: ^7.0.0
+      react-resizable-panels: ^3.0.0
+
+  '@closedloop-ai/loops-api@0.3.1':
+    resolution: {integrity: sha512-HWk7pduuO/BE1DknTvjf3TQKLo4aIPo5Pw6S/4R9S/V4Fxap/cDiaqQ89M5ExhwkyUjVRubrMmsaQHQSAhDI+g==, tarball: https://npm.pkg.github.com/download/@closedloop-ai/loops-api/0.3.1/2ac94c43a5e1926282487acde10865449787bde4}
     peerDependencies:
       zod: ^4.0.0
 
+  '@date-fns/tz@1.5.0':
+    resolution: {integrity: sha512-lwYN/vDPeNRULcepoE/LO2Pgx+7/RV+S9ARfbc9lr2DtGkOD7pAiruHvbR1RX3Qyf6ja47EWJDMsNK5vK08DJg==}
+
+  '@daybrush/utils@1.13.0':
+    resolution: {integrity: sha512-ALK12C6SQNNHw1enXK+UO8bdyQ+jaWNQ1Af7Z3FNxeAwjYhQT7do+TRE4RASAJ3ObaS2+TJ7TXR3oz2Gzbw0PQ==}
+
   '@develar/schema-utils@2.6.5':
     resolution: {integrity: sha512-0cp4PsWQ/9avqTVMCtZ+GirikIA36ikvjtHweU4/j8yLtgObI0+JUPhYFScgwlteveGB1rt3Cm8UhN04XayDig==}
     engines: {node: '>= 8.9.0'}
 
+  '@egjs/agent@2.4.4':
+    resolution: {integrity: sha512-cvAPSlUILhBBOakn2krdPnOGv5hAZq92f1YHxYcfu0p7uarix2C6Ia3AVizpS1SGRZGiEkIS5E+IVTLg1I2Iog==}
+
+  '@egjs/children-differ@1.0.1':
+    resolution: {integrity: sha512-DRvyqMf+CPCOzAopQKHtW+X8iN6Hy6SFol+/7zCUiE5y4P/OB8JP8FtU4NxtZwtafvSL4faD5KoQYPj3JHzPFQ==}
+
+  '@egjs/component@3.0.5':
+    resolution: {integrity: sha512-cLcGizTrrUNA2EYE3MBmEDt2tQv1joVP1Q3oDisZ5nw0MZDx2kcgEXM+/kZpfa/PAkFvYVhRUZwytIQWoN3V/w==}
+
+  '@egjs/list-differ@1.0.1':
+    resolution: {integrity: sha512-OTFTDQcWS+1ZREOdCWuk5hCBgYO4OsD30lXcOCyVOAjXMhgL5rBRDnt/otb6Nz8CzU0L/igdcaQBDLWc4t9gvg==}
+
   '@electron/asar@3.4.1':
     resolution: {integrity: sha512-i4/rNPRS84t0vSRa2HorerGRXWyF4vThfHesw0dmcWHp+cspK743UanA0suA5Q5y8kzY2y6YKrvbIUn69BCAiA==}
     engines: {node: '>=10.12.0'}
@@ -238,6 +307,9 @@ packages:
     engines: {node: '>=14.14'}
     hasBin: true
 
+  '@emnapi/runtime@1.10.0':
+    resolution: {integrity: sha512-ewvYlk86xUoGI0zQRNq/mC+16R1QeDlKQy21Ki3oSYXNgLb45GV1P6A0M+/s6nyCuNDqe5VpaY84BzXGwVbwFA==}
+
   '@esbuild/aix-ppc64@0.24.2':
     resolution: {integrity: sha512-thpVCb/rhxE/BnMLQ7GReQLLN8q9qbHmI55F4489/ByVg2aQaQ6kbcLb6FHkocZzQhxc4gx0sCk0tJkKBFzDhA==}
     engines: {node: '>=18'}
@@ -574,6 +646,26 @@ packages:
     resolution: {integrity: sha512-iH1B076HoAshH1mLpHMgwdGeTs0CYwL0SPMkGuSebZrwBp16v415e9NZXg2jtrqPVQjf6IANe2Vtlr5KswtcZQ==}
     engines: {node: ^20.19.0 || ^22.13.0 || >=24}
 
+  '@floating-ui/core@1.7.5':
+    resolution: {integrity: sha512-1Ih4WTWyw0+lKyFMcBHGbb5U5FtuHJuujoyyr5zTaWS5EYMeT6Jb2AuDeftsCsEuchO+mM2ij5+q9crhydzLhQ==}
+
+  '@floating-ui/dom@1.7.6':
+    resolution: {integrity: sha512-9gZSAI5XM36880PPMm//9dfiEngYoC6Am2izES1FF406YFsjvyBMmeJ2g4SAju3xWwtuynNRFL2s9hgxpLI5SQ==}
+
+  '@floating-ui/react-dom@2.1.8':
+    resolution: {integrity: sha512-cC52bHwM/n/CxS87FH0yWdngEZrjdtLW/qVruo68qg+prK7ZQ4YGdut2GyDVpoGeAYe/h899rVeOVm6Oi40k2A==}
+    peerDependencies:
+      react: '>=16.8.0'
+      react-dom: '>=16.8.0'
+
+  '@floating-ui/utils@0.2.11':
+    resolution: {integrity: sha512-RiB/yIh78pcIxl6lLMG0CgBXAZ2Y0eVHqMPYugu+9U0AeT6YBeiJpf7lbdJNIugFP5SIjwNRgo4DhR1Qxi26Gg==}
+
+  '@hookform/resolvers@5.4.0':
+    resolution: {integrity: sha512-EIsqr/t/qbinPIhGjMdtvutIN1Kk4uwbROE9/UQ93CAVGR7GkA7Y92+fX80OzXi/OB67jVFYwKGO1WzkxmkFZw==}
+    peerDependencies:
+      react-hook-form: ^7.55.0
+
   '@humanfs/core@0.19.1':
     resolution: {integrity: sha512-5DyQ4+1JEUzejeK1JGICcideyfUbGixgS9jNgex5nqkW+cY7WZhxBigmieN5Qnw9ZosSNVC9KQKyb+GUaGyKUA==}
     engines: {node: '>=18.18.0'}
@@ -590,6 +682,159 @@ packages:
     resolution: {integrity: sha512-bV0Tgo9K4hfPCek+aMAn81RppFKv2ySDQeMoSZuvTASywNTnVJCArCZE2FWqpvIatKu7VMRLWlR1EazvVhDyhQ==}
     engines: {node: '>=18.18'}
 
+  '@img/colour@1.1.0':
+    resolution: {integrity: sha512-Td76q7j57o/tLVdgS746cYARfSyxk8iEfRxewL9h4OMzYhbW4TAcppl0mT4eyqXddh6L/jwoM75mo7ixa/pCeQ==}
+    engines: {node: '>=18'}
+
+  '@img/sharp-darwin-arm64@0.34.5':
+    resolution: {integrity: sha512-imtQ3WMJXbMY4fxb/Ndp6HBTNVtWCUI0WdobyheGf5+ad6xX8VIDO8u2xE4qc/fr08CKG/7dDseFtn6M6g/r3w==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@img/sharp-darwin-x64@0.34.5':
+    resolution: {integrity: sha512-YNEFAF/4KQ/PeW0N+r+aVVsoIY0/qxxikF2SWdp+NRkmMB7y9LBZAVqQ4yhGCm/H3H270OSykqmQMKLBhBJDEw==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [x64]
+    os: [darwin]
+
+  '@img/sharp-libvips-darwin-arm64@1.2.4':
+    resolution: {integrity: sha512-zqjjo7RatFfFoP0MkQ51jfuFZBnVE2pRiaydKJ1G/rHZvnsrHAOcQALIi9sA5co5xenQdTugCvtb1cuf78Vf4g==}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@img/sharp-libvips-darwin-x64@1.2.4':
+    resolution: {integrity: sha512-1IOd5xfVhlGwX+zXv2N93k0yMONvUlANylbJw1eTah8K/Jtpi15KC+WSiaX/nBmbm2HxRM1gZ0nSdjSsrZbGKg==}
+    cpu: [x64]
+    os: [darwin]
+
+  '@img/sharp-libvips-linux-arm64@1.2.4':
+    resolution: {integrity: sha512-excjX8DfsIcJ10x1Kzr4RcWe1edC9PquDRRPx3YVCvQv+U5p7Yin2s32ftzikXojb1PIFc/9Mt28/y+iRklkrw==}
+    cpu: [arm64]
+    os: [linux]
+    libc: [glibc]
+
+  '@img/sharp-libvips-linux-arm@1.2.4':
+    resolution: {integrity: sha512-bFI7xcKFELdiNCVov8e44Ia4u2byA+l3XtsAj+Q8tfCwO6BQ8iDojYdvoPMqsKDkuoOo+X6HZA0s0q11ANMQ8A==}
+    cpu: [arm]
+    os: [linux]
+    libc: [glibc]
+
+  '@img/sharp-libvips-linux-ppc64@1.2.4':
+    resolution: {integrity: sha512-FMuvGijLDYG6lW+b/UvyilUWu5Ayu+3r2d1S8notiGCIyYU/76eig1UfMmkZ7vwgOrzKzlQbFSuQfgm7GYUPpA==}
+    cpu: [ppc64]
+    os: [linux]
+    libc: [glibc]
+
+  '@img/sharp-libvips-linux-riscv64@1.2.4':
+    resolution: {integrity: sha512-oVDbcR4zUC0ce82teubSm+x6ETixtKZBh/qbREIOcI3cULzDyb18Sr/Wcyx7NRQeQzOiHTNbZFF1UwPS2scyGA==}
+    cpu: [riscv64]
+    os: [linux]
+    libc: [glibc]
+
+  '@img/sharp-libvips-linux-s390x@1.2.4':
+    resolution: {integrity: sha512-qmp9VrzgPgMoGZyPvrQHqk02uyjA0/QrTO26Tqk6l4ZV0MPWIW6LTkqOIov+J1yEu7MbFQaDpwdwJKhbJvuRxQ==}
+    cpu: [s390x]
+    os: [linux]
+    libc: [glibc]
+
+  '@img/sharp-libvips-linux-x64@1.2.4':
+    resolution: {integrity: sha512-tJxiiLsmHc9Ax1bz3oaOYBURTXGIRDODBqhveVHonrHJ9/+k89qbLl0bcJns+e4t4rvaNBxaEZsFtSfAdquPrw==}
+    cpu: [x64]
+    os: [linux]
+    libc: [glibc]
+
+  '@img/sharp-libvips-linuxmusl-arm64@1.2.4':
+    resolution: {integrity: sha512-FVQHuwx1IIuNow9QAbYUzJ+En8KcVm9Lk5+uGUQJHaZmMECZmOlix9HnH7n1TRkXMS0pGxIJokIVB9SuqZGGXw==}
+    cpu: [arm64]
+    os: [linux]
+    libc: [musl]
+
+  '@img/sharp-libvips-linuxmusl-x64@1.2.4':
+    resolution: {integrity: sha512-+LpyBk7L44ZIXwz/VYfglaX/okxezESc6UxDSoyo2Ks6Jxc4Y7sGjpgU9s4PMgqgjj1gZCylTieNamqA1MF7Dg==}
+    cpu: [x64]
+    os: [linux]
+    libc: [musl]
+
+  '@img/sharp-linux-arm64@0.34.5':
+    resolution: {integrity: sha512-bKQzaJRY/bkPOXyKx5EVup7qkaojECG6NLYswgktOZjaXecSAeCWiZwwiFf3/Y+O1HrauiE3FVsGxFg8c24rZg==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [arm64]
+    os: [linux]
+    libc: [glibc]
+
+  '@img/sharp-linux-arm@0.34.5':
+    resolution: {integrity: sha512-9dLqsvwtg1uuXBGZKsxem9595+ujv0sJ6Vi8wcTANSFpwV/GONat5eCkzQo/1O6zRIkh0m/8+5BjrRr7jDUSZw==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [arm]
+    os: [linux]
+    libc: [glibc]
+
+  '@img/sharp-linux-ppc64@0.34.5':
+    resolution: {integrity: sha512-7zznwNaqW6YtsfrGGDA6BRkISKAAE1Jo0QdpNYXNMHu2+0dTrPflTLNkpc8l7MUP5M16ZJcUvysVWWrMefZquA==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [ppc64]
+    os: [linux]
+    libc: [glibc]
+
+  '@img/sharp-linux-riscv64@0.34.5':
+    resolution: {integrity: sha512-51gJuLPTKa7piYPaVs8GmByo7/U7/7TZOq+cnXJIHZKavIRHAP77e3N2HEl3dgiqdD/w0yUfiJnII77PuDDFdw==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [riscv64]
+    os: [linux]
+    libc: [glibc]
+
+  '@img/sharp-linux-s390x@0.34.5':
+    resolution: {integrity: sha512-nQtCk0PdKfho3eC5MrbQoigJ2gd1CgddUMkabUj+rBevs8tZ2cULOx46E7oyX+04WGfABgIwmMC0VqieTiR4jg==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [s390x]
+    os: [linux]
+    libc: [glibc]
+
+  '@img/sharp-linux-x64@0.34.5':
+    resolution: {integrity: sha512-MEzd8HPKxVxVenwAa+JRPwEC7QFjoPWuS5NZnBt6B3pu7EG2Ge0id1oLHZpPJdn3OQK+BQDiw9zStiHBTJQQQQ==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [x64]
+    os: [linux]
+    libc: [glibc]
+
+  '@img/sharp-linuxmusl-arm64@0.34.5':
+    resolution: {integrity: sha512-fprJR6GtRsMt6Kyfq44IsChVZeGN97gTD331weR1ex1c1rypDEABN6Tm2xa1wE6lYb5DdEnk03NZPqA7Id21yg==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [arm64]
+    os: [linux]
+    libc: [musl]
+
+  '@img/sharp-linuxmusl-x64@0.34.5':
+    resolution: {integrity: sha512-Jg8wNT1MUzIvhBFxViqrEhWDGzqymo3sV7z7ZsaWbZNDLXRJZoRGrjulp60YYtV4wfY8VIKcWidjojlLcWrd8Q==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [x64]
+    os: [linux]
+    libc: [musl]
+
+  '@img/sharp-wasm32@0.34.5':
+    resolution: {integrity: sha512-OdWTEiVkY2PHwqkbBI8frFxQQFekHaSSkUIJkwzclWZe64O1X4UlUjqqqLaPbUpMOQk6FBu/HtlGXNblIs0huw==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [wasm32]
+
+  '@img/sharp-win32-arm64@0.34.5':
+    resolution: {integrity: sha512-WQ3AgWCWYSb2yt+IG8mnC6Jdk9Whs7O0gxphblsLvdhSpSTtmu69ZG1Gkb6NuvxsNACwiPV6cNSZNzt0KPsw7g==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [arm64]
+    os: [win32]
+
+  '@img/sharp-win32-ia32@0.34.5':
+    resolution: {integrity: sha512-FV9m/7NmeCmSHDD5j4+4pNI8Cp3aW+JvLoXcTUo0IqyjSfAZJ8dIUmijx1qaJsIiU+Hosw6xM5KijAWRJCSgNg==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [ia32]
+    os: [win32]
+
+  '@img/sharp-win32-x64@0.34.5':
+    resolution: {integrity: sha512-+29YMsqY2/9eFEiW93eqWnuLcWcufowXewwSNIT6UwZdUUCrM3oFjMWH/Z6/TMmb4hlFenmfAVbpWeup2jryCw==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [x64]
+    os: [win32]
+
   '@isaacs/cliui@8.0.2':
     resolution: {integrity: sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA==}
     engines: {node: '>=12'}
@@ -626,6 +871,61 @@ packages:
     resolution: {integrity: sha512-9QOtNffcOF/c1seMCDnjckb3R9WHcG34tky+FHpNKKCW0wc/scYLwMtO+ptyGUfMW0/b/n4qRiALlaFHc9Oj7Q==}
     engines: {node: '>= 10.0.0'}
 
+  '@next/env@16.2.6':
+    resolution: {integrity: sha512-gd8HoHN4ufj73WmR3JmVolrpJR47ILK6LouP5xElPglaVxir6e1a7VzvTvDWkOoPXT9rkkTzyCxBu4yeZfZwcw==}
+
+  '@next/swc-darwin-arm64@16.2.6':
+    resolution: {integrity: sha512-ZJGkkcNfYgrrMkqOdZ7zoLa1TOy0qpcMfk/z4Mh/FKUz40gVO+HNQWqmLxf67Z5WB64DRp0dhEbyHfel+6sJUg==}
+    engines: {node: '>= 10'}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@next/swc-darwin-x64@16.2.6':
+    resolution: {integrity: sha512-v/YLBHIY132Ced3puBJ7YJKw1lqsCrgcNo2aRJlCEyQrrCeRJlvGlnmxhPxNQI3KE3N1DN5r9TPNPvka3nq5RQ==}
+    engines: {node: '>= 10'}
+    cpu: [x64]
+    os: [darwin]
+
+  '@next/swc-linux-arm64-gnu@16.2.6':
+    resolution: {integrity: sha512-RPOvqlYBbcQjkz9VQQDZ2T2bARIjXZV1KFlt+V2Mr6SW/e4I9fcKsaA0hdyf2FHoTlsV2xnBd5Y912rP/1Ce6w==}
+    engines: {node: '>= 10'}
+    cpu: [arm64]
+    os: [linux]
+    libc: [glibc]
+
+  '@next/swc-linux-arm64-musl@16.2.6':
+    resolution: {integrity: sha512-URUTu1+dMkxJsPFgm+OeEvq9wf5sujw0EvgYy80TDGHTSLTnIHeqb0Eu8A3sC95IRgjejQL+kC4mw+4yPxiAXA==}
+    engines: {node: '>= 10'}
+    cpu: [arm64]
+    os: [linux]
+    libc: [musl]
+
+  '@next/swc-linux-x64-gnu@16.2.6':
+    resolution: {integrity: sha512-DOj182mPV8G3UkrayLoREM5YEYI+Dk5wv7Ox9xl1fFibAELEsFD0lDPfHIeILlutMMfdyhlzYPELG3peuKaurw==}
+    engines: {node: '>= 10'}
+    cpu: [x64]
+    os: [linux]
+    libc: [glibc]
+
+  '@next/swc-linux-x64-musl@16.2.6':
+    resolution: {integrity: sha512-HKQ5SP/V/ub73UvF7n/zeJlxk2kLmtL7Wzrg4WfmkjmNos5onJ2tKu7yZOPdL18A6Svfn3max29ym+ry7NkK4g==}
+    engines: {node: '>= 10'}
+    cpu: [x64]
+    os: [linux]
+    libc: [musl]
+
+  '@next/swc-win32-arm64-msvc@16.2.6':
+    resolution: {integrity: sha512-LZXpTlPyS5v7HhSmnvsLGP3iIYgYOBnc8r8ArlT55sGHV89bR2HlDdBjWQ+PY6SJMmk8TuVGFuxalnP3k/0Dwg==}
+    engines: {node: '>= 10'}
+    cpu: [arm64]
+    os: [win32]
+
+  '@next/swc-win32-x64-msvc@16.2.6':
+    resolution: {integrity: sha512-F0+4i0h9J6C4eE3EAPWsoCk7UW/dbzOjyzxY0qnDUOYFu6FFmdZ6l97/XdV3/Nz3VYyO7UWjyEJUXkGqcoXfMA==}
+    engines: {node: '>= 10'}
+    cpu: [x64]
+    os: [win32]
+
   '@nodelib/fs.scandir@2.1.5':
     resolution: {integrity: sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==}
     engines: {node: '>= 8'}
@@ -655,10 +955,738 @@ packages:
     engines: {node: '>=18'}
     hasBin: true
 
-  '@pydantic/genai-prices@0.0.62':
-    resolution: {integrity: sha512-n7pX9Xkrt8Hx+ztUU1qXdFTv2DYyiK3PwuWyIZiYpPWvCkKkb2c+oENmF+/iLitbNWQNANAhBs9aSKOg36obzQ==}
-    engines: {node: '>=20'}
-    hasBin: true
+  '@pydantic/genai-prices@0.0.62':
+    resolution: {integrity: sha512-n7pX9Xkrt8Hx+ztUU1qXdFTv2DYyiK3PwuWyIZiYpPWvCkKkb2c+oENmF+/iLitbNWQNANAhBs9aSKOg36obzQ==}
+    engines: {node: '>=20'}
+    hasBin: true
+
+  '@radix-ui/number@1.1.1':
+    resolution: {integrity: sha512-MkKCwxlXTgz6CFoJx3pCwn07GKp36+aZyu/u2Ln2VrA5DcdyCZkASEDBTd8x5whTQQL5CiYf4prXKLcgQdv29g==}
+
+  '@radix-ui/primitive@1.1.3':
+    resolution: {integrity: sha512-JTF99U/6XIjCBo0wqkU5sK10glYe27MRRsfwoiq5zzOEZLHU3A3KCMa5X/azekYRCJ0HlwI0crAXS/5dEHTzDg==}
+
+  '@radix-ui/react-accessible-icon@1.1.7':
+    resolution: {integrity: sha512-XM+E4WXl0OqUJFovy6GjmxxFyx9opfCAIUku4dlKRd5YEPqt4kALOkQOp0Of6reHuUkJuiPBEc5k0o4z4lTC8A==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-accordion@1.2.12':
+    resolution: {integrity: sha512-T4nygeh9YE9dLRPhAHSeOZi7HBXo+0kYIPJXayZfvWOWA0+n3dESrZbjfDPUABkUNym6Hd+f2IR113To8D2GPA==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-alert-dialog@1.1.15':
+    resolution: {integrity: sha512-oTVLkEw5GpdRe29BqJ0LSDFWI3qu0vR1M0mUkOQWDIUnY/QIkLpgDMWuKxP94c2NAC2LGcgVhG1ImF3jkZ5wXw==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-arrow@1.1.7':
+    resolution: {integrity: sha512-F+M1tLhO+mlQaOWspE8Wstg+z6PwxwRd8oQ8IXceWz92kfAmalTRf0EjrouQeo7QssEPfCn05B4Ihs1K9WQ/7w==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-aspect-ratio@1.1.7':
+    resolution: {integrity: sha512-Yq6lvO9HQyPwev1onK1daHCHqXVLzPhSVjmsNjCa2Zcxy2f7uJD2itDtxknv6FzAKCwD1qQkeVDmX/cev13n/g==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-avatar@1.1.10':
+    resolution: {integrity: sha512-V8piFfWapM5OmNCXTzVQY+E1rDa53zY+MQ4Y7356v4fFz6vqCyUtIz2rUD44ZEdwg78/jKmMJHj07+C/Z/rcog==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-checkbox@1.3.3':
+    resolution: {integrity: sha512-wBbpv+NQftHDdG86Qc0pIyXk5IR3tM8Vd0nWLKDcX8nNn4nXFOFwsKuqw2okA/1D/mpaAkmuyndrPJTYDNZtFw==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-collapsible@1.1.12':
+    resolution: {integrity: sha512-Uu+mSh4agx2ib1uIGPP4/CKNULyajb3p92LsVXmH2EHVMTfZWpll88XJ0j4W0z3f8NK1eYl1+Mf/szHPmcHzyA==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-collection@1.1.7':
+    resolution: {integrity: sha512-Fh9rGN0MoI4ZFUNyfFVNU4y9LUz93u9/0K+yLgA2bwRojxM8JU1DyvvMBabnZPBgMWREAJvU2jjVzq+LrFUglw==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-compose-refs@1.1.2':
+    resolution: {integrity: sha512-z4eqJvfiNnFMHIIvXP3CY57y2WJs5g2v3X0zm9mEJkrkNv4rDxu+sg9Jh8EkXyeqBkB7SOcboo9dMVqhyrACIg==}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  '@radix-ui/react-context-menu@2.2.16':
+    resolution: {integrity: sha512-O8morBEW+HsVG28gYDZPTrT9UUovQUlJue5YO836tiTJhuIWBm/zQHc7j388sHWtdH/xUZurK9olD2+pcqx5ww==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-context@1.1.2':
+    resolution: {integrity: sha512-jCi/QKUM2r1Ju5a3J64TH2A5SpKAgh0LpknyqdQ4m6DCV0xJ2HG1xARRwNGPQfi1SLdLWZ1OJz6F4OMBBNiGJA==}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  '@radix-ui/react-dialog@1.1.15':
+    resolution: {integrity: sha512-TCglVRtzlffRNxRMEyR36DGBLJpeusFcgMVD9PZEzAKnUs1lKCgX5u9BmC2Yg+LL9MgZDugFFs1Vl+Jp4t/PGw==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-direction@1.1.1':
+    resolution: {integrity: sha512-1UEWRX6jnOA2y4H5WczZ44gOOjTEmlqv1uNW4GAJEO5+bauCBhv8snY65Iw5/VOS/ghKN9gr2KjnLKxrsvoMVw==}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  '@radix-ui/react-dismissable-layer@1.1.11':
+    resolution: {integrity: sha512-Nqcp+t5cTB8BinFkZgXiMJniQH0PsUt2k51FUhbdfeKvc4ACcG2uQniY/8+h1Yv6Kza4Q7lD7PQV0z0oicE0Mg==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-dropdown-menu@2.1.16':
+    resolution: {integrity: sha512-1PLGQEynI/3OX/ftV54COn+3Sud/Mn8vALg2rWnBLnRaGtJDduNW/22XjlGgPdpcIbiQxjKtb7BkcjP00nqfJw==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-focus-guards@1.1.3':
+    resolution: {integrity: sha512-0rFg/Rj2Q62NCm62jZw0QX7a3sz6QCQU0LpZdNrJX8byRGaGVTqbrW9jAoIAHyMQqsNpeZ81YgSizOt5WXq0Pw==}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  '@radix-ui/react-focus-scope@1.1.7':
+    resolution: {integrity: sha512-t2ODlkXBQyn7jkl6TNaw/MtVEVvIGelJDCG41Okq/KwUsJBwQ4XVZsHAVUkK4mBv3ewiAS3PGuUWuY2BoK4ZUw==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-form@0.1.8':
+    resolution: {integrity: sha512-QM70k4Zwjttifr5a4sZFts9fn8FzHYvQ5PiB19O2HsYibaHSVt9fH9rzB0XZo/YcM+b7t/p7lYCT/F5eOeF5yQ==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-hover-card@1.1.15':
+    resolution: {integrity: sha512-qgTkjNT1CfKMoP0rcasmlH2r1DAiYicWsDsufxl940sT2wHNEWWv6FMWIQXWhVdmC1d/HYfbhQx60KYyAtKxjg==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-icons@1.3.2':
+    resolution: {integrity: sha512-fyQIhGDhzfc9pK2kH6Pl9c4BDJGfMkPqkyIgYDthyNYoNg3wVhoJMMh19WS4Up/1KMPFVpNsT2q3WmXn2N1m6g==}
+    peerDependencies:
+      react: ^16.x || ^17.x || ^18.x || ^19.0.0 || ^19.0.0-rc
+
+  '@radix-ui/react-id@1.1.1':
+    resolution: {integrity: sha512-kGkGegYIdQsOb4XjsfM97rXsiHaBwco+hFI66oO4s9LU+PLAC5oJ7khdOVFxkhsmlbpUqDAvXw11CluXP+jkHg==}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  '@radix-ui/react-label@2.1.7':
+    resolution: {integrity: sha512-YT1GqPSL8kJn20djelMX7/cTRp/Y9w5IZHvfxQTVHrOqa2yMl7i/UfMqKRU5V7mEyKTrUVgJXhNQPVCG8PBLoQ==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-menu@2.1.16':
+    resolution: {integrity: sha512-72F2T+PLlphrqLcAotYPp0uJMr5SjP5SL01wfEspJbru5Zs5vQaSHb4VB3ZMJPimgHHCHG7gMOeOB9H3Hdmtxg==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-menubar@1.1.16':
+    resolution: {integrity: sha512-EB1FktTz5xRRi2Er974AUQZWg2yVBb1yjip38/lgwtCVRd3a+maUoGHN/xs9Yv8SY8QwbSEb+YrxGadVWbEutA==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-navigation-menu@1.2.14':
+    resolution: {integrity: sha512-YB9mTFQvCOAQMHU+C/jVl96WmuWeltyUEpRJJky51huhds5W2FQr1J8D/16sQlf0ozxkPK8uF3niQMdUwZPv5w==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-one-time-password-field@0.1.8':
+    resolution: {integrity: sha512-ycS4rbwURavDPVjCb5iS3aG4lURFDILi6sKI/WITUMZ13gMmn/xGjpLoqBAalhJaDk8I3UbCM5GzKHrnzwHbvg==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-password-toggle-field@0.1.3':
+    resolution: {integrity: sha512-/UuCrDBWravcaMix4TdT+qlNdVwOM1Nck9kWx/vafXsdfj1ChfhOdfi3cy9SGBpWgTXwYCuboT/oYpJy3clqfw==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-popover@1.1.15':
+    resolution: {integrity: sha512-kr0X2+6Yy/vJzLYJUPCZEc8SfQcf+1COFoAqauJm74umQhta9M7lNJHP7QQS3vkvcGLQUbWpMzwrXYwrYztHKA==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-popper@1.2.8':
+    resolution: {integrity: sha512-0NJQ4LFFUuWkE7Oxf0htBKS6zLkkjBH+hM1uk7Ng705ReR8m/uelduy1DBo0PyBXPKVnBA6YBlU94MBGXrSBCw==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-portal@1.1.9':
+    resolution: {integrity: sha512-bpIxvq03if6UNwXZ+HTK71JLh4APvnXntDc6XOX8UVq4XQOVl7lwok0AvIl+b8zgCw3fSaVTZMpAPPagXbKmHQ==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-presence@1.1.5':
+    resolution: {integrity: sha512-/jfEwNDdQVBCNvjkGit4h6pMOzq8bHkopq458dPt2lMjx+eBQUohZNG9A7DtO/O5ukSbxuaNGXMjHicgwy6rQQ==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-primitive@2.1.3':
+    resolution: {integrity: sha512-m9gTwRkhy2lvCPe6QJp4d3G1TYEUHn/FzJUtq9MjH46an1wJU+GdoGC5VLof8RX8Ft/DlpshApkhswDLZzHIcQ==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-primitive@2.1.4':
+    resolution: {integrity: sha512-9hQc4+GNVtJAIEPEqlYqW5RiYdrr8ea5XQ0ZOnD6fgru+83kqT15mq2OCcbe8KnjRZl5vF3ks69AKz3kh1jrhg==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-progress@1.1.7':
+    resolution: {integrity: sha512-vPdg/tF6YC/ynuBIJlk1mm7Le0VgW6ub6J2UWnTQ7/D23KXcPI1qy+0vBkgKgd38RCMJavBXpB83HPNFMTb0Fg==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-radio-group@1.3.8':
+    resolution: {integrity: sha512-VBKYIYImA5zsxACdisNQ3BjCBfmbGH3kQlnFVqlWU4tXwjy7cGX8ta80BcrO+WJXIn5iBylEH3K6ZTlee//lgQ==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-roving-focus@1.1.11':
+    resolution: {integrity: sha512-7A6S9jSgm/S+7MdtNDSb+IU859vQqJ/QAtcYQcfFC6W8RS4IxIZDldLR0xqCFZ6DCyrQLjLPsxtTNch5jVA4lA==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-scroll-area@1.2.10':
+    resolution: {integrity: sha512-tAXIa1g3sM5CGpVT0uIbUx/U3Gs5N8T52IICuCtObaos1S8fzsrPXG5WObkQN3S6NVl6wKgPhAIiBGbWnvc97A==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-select@2.2.6':
+    resolution: {integrity: sha512-I30RydO+bnn2PQztvo25tswPH+wFBjehVGtmagkU78yMdwTwVf12wnAOF+AeP8S2N8xD+5UPbGhkUfPyvT+mwQ==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-separator@1.1.7':
+    resolution: {integrity: sha512-0HEb8R9E8A+jZjvmFCy/J4xhbXy3TV+9XSnGJ3KvTtjlIUy/YQ/p6UYZvi7YbeoeXdyU9+Y3scizK6hkY37baA==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-slider@1.3.6':
+    resolution: {integrity: sha512-JPYb1GuM1bxfjMRlNLE+BcmBC8onfCi60Blk7OBqi2MLTFdS+8401U4uFjnwkOr49BLmXxLC6JHkvAsx5OJvHw==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-slot@1.2.3':
+    resolution: {integrity: sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A==}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  '@radix-ui/react-slot@1.2.4':
+    resolution: {integrity: sha512-Jl+bCv8HxKnlTLVrcDE8zTMJ09R9/ukw4qBs/oZClOfoQk/cOTbDn+NceXfV7j09YPVQUryJPHurafcSg6EVKA==}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  '@radix-ui/react-switch@1.2.6':
+    resolution: {integrity: sha512-bByzr1+ep1zk4VubeEVViV592vu2lHE2BZY5OnzehZqOOgogN80+mNtCqPkhn2gklJqOpxWgPoYTSnhBCqpOXQ==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-tabs@1.1.13':
+    resolution: {integrity: sha512-7xdcatg7/U+7+Udyoj2zodtI9H/IIopqo+YOIcZOq1nJwXWBZ9p8xiu5llXlekDbZkca79a/fozEYQXIA4sW6A==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-toast@1.2.15':
+    resolution: {integrity: sha512-3OSz3TacUWy4WtOXV38DggwxoqJK4+eDkNMl5Z/MJZaoUPaP4/9lf81xXMe1I2ReTAptverZUpbPY4wWwWyL5g==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-toggle-group@1.1.11':
+    resolution: {integrity: sha512-5umnS0T8JQzQT6HbPyO7Hh9dgd82NmS36DQr+X/YJ9ctFNCiiQd6IJAYYZ33LUwm8M+taCz5t2ui29fHZc4Y6Q==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-toggle@1.1.10':
+    resolution: {integrity: sha512-lS1odchhFTeZv3xwHH31YPObmJn8gOg7Lq12inrr0+BH/l3Tsq32VfjqH1oh80ARM3mlkfMic15n0kg4sD1poQ==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-toolbar@1.1.11':
+    resolution: {integrity: sha512-4ol06/1bLoFu1nwUqzdD4Y5RZ9oDdKeiHIsntug54Hcr1pgaHiPqHFEaXI1IFP/EsOfROQZ8Mig9VTIRza6Tjg==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-tooltip@1.2.8':
+    resolution: {integrity: sha512-tY7sVt1yL9ozIxvmbtN5qtmH2krXcBCfjEiCgKGLqunJHvgvZG2Pcl2oQ3kbcZARb1BGEHdkLzcYGO8ynVlieg==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-use-callback-ref@1.1.1':
+    resolution: {integrity: sha512-FkBMwD+qbGQeMu1cOHnuGB6x4yzPjho8ap5WtbEJ26umhgqVXbhekKUQO+hZEL1vU92a3wHwdp0HAcqAUF5iDg==}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  '@radix-ui/react-use-controllable-state@1.2.2':
+    resolution: {integrity: sha512-BjasUjixPFdS+NKkypcyyN5Pmg83Olst0+c6vGov0diwTEo6mgdqVR6hxcEgFuh4QrAs7Rc+9KuGJ9TVCj0Zzg==}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  '@radix-ui/react-use-effect-event@0.0.2':
+    resolution: {integrity: sha512-Qp8WbZOBe+blgpuUT+lw2xheLP8q0oatc9UpmiemEICxGvFLYmHm9QowVZGHtJlGbS6A6yJ3iViad/2cVjnOiA==}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  '@radix-ui/react-use-escape-keydown@1.1.1':
+    resolution: {integrity: sha512-Il0+boE7w/XebUHyBjroE+DbByORGR9KKmITzbR7MyQ4akpORYP/ZmbhAr0DG7RmmBqoOnZdy2QlvajJ2QA59g==}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  '@radix-ui/react-use-is-hydrated@0.1.0':
+    resolution: {integrity: sha512-U+UORVEq+cTnRIaostJv9AGdV3G6Y+zbVd+12e18jQ5A3c0xL03IhnHuiU4UV69wolOQp5GfR58NW/EgdQhwOA==}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  '@radix-ui/react-use-layout-effect@1.1.1':
+    resolution: {integrity: sha512-RbJRS4UWQFkzHTTwVymMTUv8EqYhOp8dOOviLj2ugtTiXRaRQS7GLGxZTLL1jWhMeoSCf5zmcZkqTl9IiYfXcQ==}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  '@radix-ui/react-use-previous@1.1.1':
+    resolution: {integrity: sha512-2dHfToCj/pzca2Ck724OZ5L0EVrr3eHRNsG/b3xQJLA2hZpVCS99bLAX+hm1IHXDEnzU6by5z/5MIY794/a8NQ==}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  '@radix-ui/react-use-rect@1.1.1':
+    resolution: {integrity: sha512-QTYuDesS0VtuHNNvMh+CjlKJ4LJickCMUAqjlE3+j8w+RlRpwyX3apEQKGFzbZGdo7XNG1tXa+bQqIE7HIXT2w==}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  '@radix-ui/react-use-size@1.1.1':
+    resolution: {integrity: sha512-ewrXRDTAqAXlkl6t/fkXWNAhFX9I+CkKlw6zjEwk86RSPKwZr3xpBRso655aqYafwtnbpHLj6toFzmd6xdVptQ==}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  '@radix-ui/react-visually-hidden@1.2.3':
+    resolution: {integrity: sha512-pzJq12tEaaIhqjbzpCuv/OypJY/BPavOofm+dbab+MHLajy277+1lLm6JFcGgF5eskJ6mquGirhXY2GD/8u8Ug==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/rect@1.1.1':
+    resolution: {integrity: sha512-HPwpGIzkl28mWyZqG52jiqDJ12waP11Pa1lGoiyUkIEuMLBP0oeK/C89esbXrxsky5we7dfd8U58nm0SgAWpVw==}
+
+  '@reduxjs/toolkit@2.12.0':
+    resolution: {integrity: sha512-KiT+RzZbp6mQET+Mg+h2c97+9j1sNflUxQkIHI7Yuzf6Peu+OYpmkn6nbHWmLLWj+1ZODUJFwGZ7gx3L9R9EOw==}
+    peerDependencies:
+      react: ^16.9.0 || ^17.0.0 || ^18 || ^19
+      react-redux: ^7.2.1 || ^8.1.3 || ^9.0.0
+    peerDependenciesMeta:
+      react:
+        optional: true
+      react-redux:
+        optional: true
 
   '@remix-run/router@1.23.2':
     resolution: {integrity: sha512-Ic6m2U/rMjTkhERIa/0ZtXJP17QUi2CbWE7cqx4J58M8aA3QTfW+2UlQ4psvTX9IO1RfNVhK3pcpdjej7L+t2w==}
@@ -805,6 +1833,15 @@ packages:
   '@scarf/scarf@1.4.0':
     resolution: {integrity: sha512-xxeapPiUXdZAE3che6f3xogoJPeZgig6omHEy1rIY5WVsB3H2BHNnZH+gHG6x91SCWyQCzWGsuL2Hh3ClO5/qQ==}
 
+  '@scena/dragscroll@1.4.0':
+    resolution: {integrity: sha512-3O8daaZD9VXA9CP3dra6xcgt/qrm0mg0xJCwiX6druCteQ9FFsXffkF8PrqxY4Z4VJ58fFKEa0RlKqbsi/XnRA==}
+
+  '@scena/event-emitter@1.0.5':
+    resolution: {integrity: sha512-AzY4OTb0+7ynefmWFQ6hxDdk0CySAq/D4efljfhtRHCOP7MBF9zUfhKG3TJiroVjASqVgkRJFdenS8ArZo6Olg==}
+
+  '@scena/matrix@1.1.1':
+    resolution: {integrity: sha512-JVKBhN0tm2Srl+Yt+Ywqu0oLgLcdemDQlD1OxmN9jaCTwaFPZ7tY8n6dhVgMEaR9qcR7r+kAlMXnSfNyYdE+Vg==}
+
   '@sindresorhus/is@4.6.0':
     resolution: {integrity: sha512-t09vSN3MdfsyCHoFcTRCH/iUtG7OJ0CsjzB8cjAmKc/va/kIgeDI/TxsigdncE/4be734m0cvIYwNaV4i2XqAw==}
     engines: {node: '>=10'}
@@ -812,10 +1849,122 @@ packages:
   '@socket.io/component-emitter@3.1.2':
     resolution: {integrity: sha512-9BCxFwvbGg/RsZK9tjXd8s4UcwR0MWeFQ1XEKIQVVvAGJyINdrqKMcTRyLoK8Rse1GjzLV9cwjWV1olXRWEXVA==}
 
+  '@standard-schema/spec@1.1.0':
+    resolution: {integrity: sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==}
+
+  '@standard-schema/utils@0.3.0':
+    resolution: {integrity: sha512-e7Mew686owMaPJVNNLs55PUvgz371nKgwsc4vxE49zsODpJEnxgxRo2y/OKrqueavXgZNMDVj3DdHFlaSAeU8g==}
+
+  '@swc/helpers@0.5.15':
+    resolution: {integrity: sha512-JQ5TuMi45Owi4/BIMAJBoSQoOJu12oOk/gADqlcUL9JEdHB8vyjUSsxqeNXnmXHjYKMi2WcYtezGEEhqUI/E2g==}
+
   '@szmarczak/http-timer@4.0.6':
     resolution: {integrity: sha512-4BAffykYOgO+5nzBWYwE3W90sBgLJoUPRWWcL8wlyiM8IB8ipJz3UMJ9KXQd1RKQXpKp8Tutn80HZtWsu2u76w==}
     engines: {node: '>=10'}
 
+  '@tabby_ai/hijri-converter@1.0.5':
+    resolution: {integrity: sha512-r5bClKrcIusDoo049dSL8CawnHR6mRdDwhlQuIgZRNty68q0x8k3Lf1BtPAMxRf/GgnHBnIO4ujd3+GQdLWzxQ==}
+    engines: {node: '>=16.0.0'}
+
+  '@tailwindcss/node@4.3.0':
+    resolution: {integrity: sha512-aFb4gUhFOgdh9AXo4IzBEOzBkkAxm9VigwDJnMIYv3lcfXCJVesNfbEaBl4BNgVRyid92AmdviqwBUBRKSeY3g==}
+
+  '@tailwindcss/oxide-android-arm64@4.3.0':
+    resolution: {integrity: sha512-TJPiq67tKlLuObP6RkwvVGDoxCMBVtDgKkLfa/uyj7/FyxvQwHS+UOnVrXXgbEsfUaMgiVvC4KbJnRr26ho4Ng==}
+    engines: {node: '>= 20'}
+    cpu: [arm64]
+    os: [android]
+
+  '@tailwindcss/oxide-darwin-arm64@4.3.0':
+    resolution: {integrity: sha512-oMN/WZRb+SO37BmUElEgeEWuU8E/HXRkiODxJxLe1UTHVXLrdVSgfaJV7pSlhRGMSOiXLuxTIjfsF3wYvz8cgQ==}
+    engines: {node: '>= 20'}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@tailwindcss/oxide-darwin-x64@4.3.0':
+    resolution: {integrity: sha512-N6CUmu4a6bKVADfw77p+iw6Yd9Q3OBhe0veaDX+QazfuVYlQsHfDgxBrsjQ/IW+zywL8mTrNd0SdJT/zgtvMdA==}
+    engines: {node: '>= 20'}
+    cpu: [x64]
+    os: [darwin]
+
+  '@tailwindcss/oxide-freebsd-x64@4.3.0':
+    resolution: {integrity: sha512-zDL5hBkQdH5C6MpqbK3gQAgP80tsMwSI26vjOzjJtNCMUo0lFgOItzHKBIupOZNQxt3ouPH7RPhvNhiTfCe5CQ==}
+    engines: {node: '>= 20'}
+    cpu: [x64]
+    os: [freebsd]
+
+  '@tailwindcss/oxide-linux-arm-gnueabihf@4.3.0':
+    resolution: {integrity: sha512-R06HdNi7A7OEoMsf6d4tjZ71RCWnZQPHj2mnotSFURjNLdBC+cIgXQ7l81CqeoiQftjf6OOblxXMInMgN2VzMA==}
+    engines: {node: '>= 20'}
+    cpu: [arm]
+    os: [linux]
+
+  '@tailwindcss/oxide-linux-arm64-gnu@4.3.0':
+    resolution: {integrity: sha512-qTJHELX8jetjhRQHCLilkVLmybpzNQAtaI/gaoVoidn/ufbNDbAo8KlK2J+yPoc8wQxvDxCmh/5lr8nC1+lTbg==}
+    engines: {node: '>= 20'}
+    cpu: [arm64]
+    os: [linux]
+    libc: [glibc]
+
+  '@tailwindcss/oxide-linux-arm64-musl@4.3.0':
+    resolution: {integrity: sha512-Z6sukiQsngnWO+l39X4pPbiWT81IC+PLKF+PHxIlyZbGNb9MODfYlXEVlFvej5BOZInWX01kVyzeLvHsXhfczQ==}
+    engines: {node: '>= 20'}
+    cpu: [arm64]
+    os: [linux]
+    libc: [musl]
+
+  '@tailwindcss/oxide-linux-x64-gnu@4.3.0':
+    resolution: {integrity: sha512-DRNdQRpSGzRGfARVuVkxvM8Q12nh19l4BF/G7zGA1oe+9wcC6saFBHTISrpIcKzhiXtSrlSrluCfvMuledoCTQ==}
+    engines: {node: '>= 20'}
+    cpu: [x64]
+    os: [linux]
+    libc: [glibc]
+
+  '@tailwindcss/oxide-linux-x64-musl@4.3.0':
+    resolution: {integrity: sha512-Z0IADbDo8bh6I7h2IQMx601AdXBLfFpEdUotft86evd/8ZPflZe9COPO8Q1vw+pfLWIUo9zN/JGZvwuAJqduqg==}
+    engines: {node: '>= 20'}
+    cpu: [x64]
+    os: [linux]
+    libc: [musl]
+
+  '@tailwindcss/oxide-wasm32-wasi@4.3.0':
+    resolution: {integrity: sha512-HNZGOUxEmElksYR7S6sC5jTeNGpobAsy9u7Gu0AskJ8/20FR9GqebUyB+HBcU/ax6BHuiuJi+Oda4B+YX6H1yA==}
+    engines: {node: '>=14.0.0'}
+    cpu: [wasm32]
+    bundledDependencies:
+      - '@napi-rs/wasm-runtime'
+      - '@emnapi/core'
+      - '@emnapi/runtime'
+      - '@tybys/wasm-util'
+      - '@emnapi/wasi-threads'
+      - tslib
+
+  '@tailwindcss/oxide-win32-arm64-msvc@4.3.0':
+    resolution: {integrity: sha512-Pe+RPVTi1T+qymuuRpcdvwSVZjnll/f7n8gBxMMh3xLTctMDKqpdfGimbMyioqtLhUYZxdJ9wGNhV7MKHvgZsQ==}
+    engines: {node: '>= 20'}
+    cpu: [arm64]
+    os: [win32]
+
+  '@tailwindcss/oxide-win32-x64-msvc@4.3.0':
+    resolution: {integrity: sha512-Mvrf2kXW/yeW/OTezZlCGOirXRcUuLIBx/5Y12BaPM7wJoryG6dfS/NJL8aBPqtTEx/Vm4T4vKzFUcKDT+TKUA==}
+    engines: {node: '>= 20'}
+    cpu: [x64]
+    os: [win32]
+
+  '@tailwindcss/oxide@4.3.0':
+    resolution: {integrity: sha512-F7HZGBeN9I0/AuuJS5PwcD8xayx5ri5GhjYUDBEVYUkexyA/giwbDNjRVrxSezE3T250OU2K/wp/ltWx3UOefg==}
+    engines: {node: '>= 20'}
+
+  '@tailwindcss/typography@0.5.19':
+    resolution: {integrity: sha512-w31dd8HOx3k9vPtcQh5QHP9GwKcgbMp87j58qi6xgiBnFFtKEAgCWnDw4qUT8aHwkCp8bKvb/KGKWWHedP0AAg==}
+    peerDependencies:
+      tailwindcss: '>=3.0.0 || insiders || >=4.0.0-alpha.20 || >=4.0.0-beta.1'
+
+  '@tailwindcss/vite@4.3.0':
+    resolution: {integrity: sha512-t6J3OrB5Fc0ExuhohouH0fWUGMYL6PTLhW+E7zIk/pdbnJARZDCwjBznFnkh5ynRnIRSI4YjtTH0t6USjJISrw==}
+    peerDependencies:
+      vite: ^5.2.0 || ^6 || ^7 || ^8
+
   '@types/babel__core@7.20.5':
     resolution: {integrity: sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA==}
 
@@ -834,18 +1983,57 @@ packages:
   '@types/cacheable-request@6.0.3':
     resolution: {integrity: sha512-IQ3EbTzGxIigb1I3qPZc1rWJnH0BmSKv5QYTalEwweFvyBDLSAe24zP0le/hyi7ecGfZVlIVAg4BZqb8WBwKqw==}
 
+  '@types/d3-array@3.2.2':
+    resolution: {integrity: sha512-hOLWVbm7uRza0BYXpIIW5pxfrKe0W+D5lrFiAEYR+pb6w3N2SwSMaJbXdUfSEv+dT4MfHBLtn5js0LAWaO6otw==}
+
+  '@types/d3-color@3.1.3':
+    resolution: {integrity: sha512-iO90scth9WAbmgv7ogoq57O9YpKmFBbmoEoCHDB2xMBY0+/KVrqAaCDyCE16dUspeOvIxFFRI+0sEtqDqy2b4A==}
+
+  '@types/d3-ease@3.0.2':
+    resolution: {integrity: sha512-NcV1JjO5oDzoK26oMzbILE6HW7uVXOHLQvHshBUW4UMdZGfiY6v5BeQwh9a9tCzv+CeefZQHJt5SRgK154RtiA==}
+
+  '@types/d3-interpolate@3.0.4':
+    resolution: {integrity: sha512-mgLPETlrpVV1YRJIglr4Ez47g7Yxjl1lj7YKsiMCb27VJH9W8NVM6Bb9d8kkpG/uAQS5AmbA48q2IAolKKo1MA==}
+
+  '@types/d3-path@3.1.1':
+    resolution: {integrity: sha512-VMZBYyQvbGmWyWVea0EHs/BwLgxc+MKi1zLDCONksozI4YJMcTt8ZEuIR4Sb1MMTE8MMW49v0IwI5+b7RmfWlg==}
+
+  '@types/d3-scale@4.0.9':
+    resolution: {integrity: sha512-dLmtwB8zkAeO/juAMfnV+sItKjlsw2lKdZVVy6LRr0cBmegxSABiLEpGVmSJJ8O08i4+sGR6qQtb6WtuwJdvVw==}
+
+  '@types/d3-shape@3.1.8':
+    resolution: {integrity: sha512-lae0iWfcDeR7qt7rA88BNiqdvPS5pFVPpo5OfjElwNaT2yyekbM0C9vK+yqBqEmHr6lDkRnYNoTBYlAgJa7a4w==}
+
+  '@types/d3-time@3.0.4':
+    resolution: {integrity: sha512-yuzZug1nkAAaBlBBikKZTgzCeA+k1uy4ZFwWANOfKw5z5LRhV0gNA7gNkKm7HoK+HRN0wX3EkxGk0fpbWhmB7g==}
+
+  '@types/d3-timer@3.0.2':
+    resolution: {integrity: sha512-Ps3T8E8dZDam6fUyNiMkekK3XUsaUEik+idO9/YjPtfj2qruF8tFBXS7XhtE4iIXBLxhmLjP3SXpLhVf21I9Lw==}
+
   '@types/debug@4.1.12':
     resolution: {integrity: sha512-vIChWdVG3LG1SMxEvI/AK+FWJthlrqlTu7fbrlywTkkaONwk/UAGaULXRlf8vkzFBLVm0zkMdCquhL5aOjhXPQ==}
 
+  '@types/debug@4.1.13':
+    resolution: {integrity: sha512-KSVgmQmzMwPlmtljOomayoR89W4FynCAi3E8PPs7vmDVPe84hT+vGPKkJfThkmXs0x0jAaa9U8uW8bbfyS2fWw==}
+
   '@types/esrecurse@4.3.1':
     resolution: {integrity: sha512-xJBAbDifo5hpffDBuHl0Y8ywswbiAp/Wi7Y/GtAgSlZyIABppyurxVueOPE8LUQOxdlgi6Zqce7uoEpqNTeiUw==}
 
+  '@types/estree-jsx@1.0.5':
+    resolution: {integrity: sha512-52CcUVNFyfb1A2ALocQw/Dd1BQFNmSdkuC3BkZ6iqhdMfQz7JWOFRuJFloOzjk+6WijU56m9oKXFAXc7o3Towg==}
+
   '@types/estree@1.0.8':
     resolution: {integrity: sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==}
 
+  '@types/estree@1.0.9':
+    resolution: {integrity: sha512-GhdPgy1el4/ImP05X05Uw4cw2/M93BCUmnEvWZNStlCzEKME4Fkk+YpoA5OiHNQmoS7Cafb8Xa3Pya8m1Qrzeg==}
+
   '@types/fs-extra@9.0.13':
     resolution: {integrity: sha512-nEnwB++1u5lVDM2UI4c1+5R+FYaKfaAzS4OococimjVm3nQw3TuzH5UNsocrcTBbhnerblyHj4A49qXbIiZdpA==}
 
+  '@types/hast@3.0.4':
+    resolution: {integrity: sha512-WPs+bbQw5aCj+x6laNGWLH3wviHtoCv/P3+otBhbOhJgG8qtpdAMlTCxLtsTWA7LH1Oh/bFCHsBn0TPS5m30EQ==}
+
   '@types/http-cache-semantics@4.2.0':
     resolution: {integrity: sha512-L3LgimLHXtGkWikKnsPg0/VFx9OGZaC+eN1u4r+OB1XRqH3meBIAVC2zr1WdMH+RHmnRkqliQAOHNJ/E0j/e0Q==}
 
@@ -855,6 +2043,9 @@ packages:
   '@types/keyv@3.1.4':
     resolution: {integrity: sha512-BQ5aZNSCpj7D6K2ksrRCTmKRLEpnPvWDiLPfoGyhZ++8YtiK9d/3DBKPJgry359X/P1PfruyYwvnvwFjuEiEIg==}
 
+  '@types/mdast@4.0.4':
+    resolution: {integrity: sha512-kGaNbPh1k7AFzgpud/gMdvIm5xuECykRR+JnWKQno9TAXVa6WIVCGTPvYGekIDL4uwCZQSYbUxNBSb1aUo79oA==}
+
   '@types/ms@2.1.0':
     resolution: {integrity: sha512-GsCCIZDE/p3i96vtEqx+7dBUGXrc7zeSK3wwPHIaRThS+9OhWIXRqzs4d6k1SVU8g91DrNRWxWUGhp5KXQb2VA==}
 
@@ -864,9 +2055,29 @@ packages:
   '@types/plist@3.0.5':
     resolution: {integrity: sha512-E6OCaRmAe4WDmWNsL/9RMqdkkzDCY1etutkflWk4c+AcjDU07Pcz1fQwTX0TQz+Pxqn9i4L1TU3UFpjnrcDgxA==}
 
+  '@types/prismjs@1.26.6':
+    resolution: {integrity: sha512-vqlvI7qlMvcCBbVe0AKAb4f97//Hy0EBTaiW8AalRnG/xAN5zOiWWyrNqNXeq8+KAuvRewjCVY1+IPxk4RdNYw==}
+
+  '@types/react-dom@19.2.3':
+    resolution: {integrity: sha512-jp2L/eY6fn+KgVVQAOqYItbF0VY/YApe5Mz2F0aykSO8gx31bYCZyvSeYxCHKvzHG5eZjc+zyaS5BrBWya2+kQ==}
+    peerDependencies:
+      '@types/react': ^19.2.0
+
+  '@types/react@19.2.15':
+    resolution: {integrity: sha512-eRwcGNHve+E8qtEQSSRl6urh+rFop4v8gm6O8rGv25CodbvFdLjA1vVQ1KkiFE0w0UPOnb8tDiFKL5lp0rtY5Q==}
+
   '@types/responselike@1.0.3':
     resolution: {integrity: sha512-H/+L+UkTV33uf49PH5pCAUBVPNj2nDBXTN+qS1dOwyyg24l3CcicicCA7ca+HMvJBZcFgl5r8e+RR6elsb4Lyw==}
 
+  '@types/unist@2.0.11':
+    resolution: {integrity: sha512-CmBKiL6NNo/OqgmMn95Fk9Whlp2mtvIv+KNpQKN2F4SjvrEesubTRWGYSg+BnWZOnlCaSTU1sMpsBOzgbYhnsA==}
+
+  '@types/unist@3.0.3':
+    resolution: {integrity: sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q==}
+
+  '@types/use-sync-external-store@0.0.6':
+    resolution: {integrity: sha512-zFDAD+tlpf2r4asuHEj0XH6pY6i0g5NeAHPn+15wk3BV6JA69eERFXC1gyGThDkVa1zCyKr5jox1+2LbV/AMLg==}
+
   '@types/verror@1.10.11':
     resolution: {integrity: sha512-RlDm9K7+o5stv0Co8i8ZRGxDbrTxhJtgjqjFyVh/tXQyl/rYtTKlnTvZ88oSTeYREWurwx20Js4kTuKCsFkUtg==}
 
@@ -932,6 +2143,9 @@ packages:
     resolution: {integrity: sha512-YWnmJkXbofiz9KbnbbwuA2rpGkFPLbAIetcCNO6mJ8gdhdZ/v7WDXsoGFAJuM6ikUFKTlSQnjWnVO4ux+UzS6A==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
 
+  '@ungap/structured-clone@1.3.1':
+    resolution: {integrity: sha512-mUFwbeTqrVgDQxFveS+df2yfap6iuP20NAKAsBt5jDEoOTDew+zwLAOilHCeQJOVSvmgCX4ogqIrA0mnyr08yQ==}
+
   '@vitejs/plugin-react@4.3.4':
     resolution: {integrity: sha512-SCCPBJtYLdE8PX/7ZQAs1QAZ8Jqwih+0VBLum1EGqmCCQal+MIUqLCzj3ZUy8ufbC0cAM4LRlSTm7IQJwWT4ug==}
     engines: {node: ^14.18.0 || >=16.0.0}
@@ -1039,6 +2253,10 @@ packages:
   argparse@2.0.1:
     resolution: {integrity: sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==}
 
+  aria-hidden@1.2.6:
+    resolution: {integrity: sha512-ik3ZgC9dY/lYVVM++OISsaYDeg1tb0VtP5uL3ouh1koGOaUMDPpbFIei4JkFimWUFPn90sbMNMXQAIVOlnYKJA==}
+    engines: {node: '>=10'}
+
   array-flatten@1.1.1:
     resolution: {integrity: sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg==}
 
@@ -1078,6 +2296,9 @@ packages:
     peerDependencies:
       postcss: ^8.1.0
 
+  bail@2.0.2:
+    resolution: {integrity: sha512-0xO6mYd7JB2YesxDKplafRpsiOzPt9V02ddPCLbY1xYGPOX24NTyN50qnUxgCPcSoYMhKpAuBTjQoRZCAkUDRw==}
+
   balanced-match@1.0.2:
     resolution: {integrity: sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==}
 
@@ -1088,8 +2309,8 @@ packages:
   base64-js@1.5.1:
     resolution: {integrity: sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==}
 
-  baseline-browser-mapping@2.10.31:
-    resolution: {integrity: sha512-MujYO3eP72uvmSE0i4wltsodRfIpZATP3jvzRNRGGxgzId7aVocVJJV3nf01qnzzKFGxQVC9bpWxl5cjxTr/7Q==}
+  baseline-browser-mapping@2.10.32:
+    resolution: {integrity: sha512-wbPvpyjJPC0zdfdKXxqEL3Ea+bOMD/87X4lftiJkkaBiuG6ALQy1SLmEd7BSmVCuwCQsBrCamgBoLyfFDD1EPg==}
     engines: {node: '>=6.0.0'}
     hasBin: true
 
@@ -1190,10 +2411,25 @@ packages:
   caniuse-lite@1.0.30001793:
     resolution: {integrity: sha512-iwSsYWaCOoh26cV8NwNRViHlrfUvYsHDfRVcbtmw0Kg6PJIZZXwMkj1442FYLBGkeUf1juAsU3DTfxW579mrPA==}
 
+  ccount@2.0.1:
+    resolution: {integrity: sha512-eyrF0jiFpY+3drT6383f1qhkbGsLSifNAjA61IUjZjmLCWjItY6LB9ft9YhoDgwfmclB2zhu51Lc7+95b8NRAg==}
+
   chalk@4.1.2:
     resolution: {integrity: sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==}
     engines: {node: '>=10'}
 
+  character-entities-html4@2.1.0:
+    resolution: {integrity: sha512-1v7fgQRj6hnSwFpq1Eu0ynr/CDEw0rXo2B61qXrLNdHZmPKgb7fqS1a2JwF0rISo9q77jDI8VMEHoApn8qDoZA==}
+
+  character-entities-legacy@3.0.0:
+    resolution: {integrity: sha512-RpPp0asT/6ufRm//AJVwpViZbGM/MkjQFxJccQRHmISF/22NBtsHqAWmL+/pmkPWoIUJdWyeVleTl1wydHATVQ==}
+
+  character-entities@2.0.2:
+    resolution: {integrity: sha512-shx7oQ0Awen/BRIdkjkvz54PnEEI/EjwXDSIZp86/KKdbafHh1Df/RYGBhn4hbe2+uKC9FnT5UCEdyPz3ai9hQ==}
+
+  character-reference-invalid@2.0.1:
+    resolution: {integrity: sha512-iBZ4F4wRbyORVsu0jPV7gXkOsGYjGHPmAyv+HiHG8gi5PtC9KI2j1+v8/tlibRvjoWX027ypmG/n0HtO5t7unw==}
+
   chokidar@3.6.0:
     resolution: {integrity: sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==}
     engines: {node: '>= 8.10.0'}
@@ -1216,6 +2452,9 @@ packages:
     resolution: {integrity: sha512-77PSwercCZU2Fc4sX94eF8k8Pxte6JAwL4/ICZLFjJLqegs7kCuAsqqj/70NQF6TvDpgFjkubQB2FW2ZZddvQg==}
     engines: {node: '>=8'}
 
+  class-variance-authority@0.7.1:
+    resolution: {integrity: sha512-Ka+9Trutv7G8M6WT6SeiRWz792K5qEqIGEGzXKhAE6xOWAY6pPH8U+9IY3oCMv6kqTmLsv7Xh/2w2RigkePMsg==}
+
   cli-cursor@3.1.0:
     resolution: {integrity: sha512-I/zHAwsKf9FqGoXM4WWRACob9+SNukZTd94DWF57E4toouRulbCxcUh6RKUEOQlYTHJnzkPMySvPNaaSLNfLZw==}
     engines: {node: '>=8'}
@@ -1228,6 +2467,9 @@ packages:
     resolution: {integrity: sha512-n8fOixwDD6b/ObinzTrp1ZKFzbgvKZvuz/TvejnLn1aQfC6r52XEx85FmuC+3HI+JM7coBRXUvNqEU2PHVrHpg==}
     engines: {node: '>=8'}
 
+  client-only@0.0.1:
+    resolution: {integrity: sha512-IV3Ou0jSMzZrd3pZ48nLkT9DA7Ag1pnPzaiQhpW7c3RbcqqzvzzVu+L8gfqMp/8IM2MQtSiqaCxrrcfu8I8rMA==}
+
   cliui@8.0.1:
     resolution: {integrity: sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==}
     engines: {node: '>=12'}
@@ -1239,6 +2481,16 @@ packages:
     resolution: {integrity: sha512-JQHZ2QMW6l3aH/j6xCqQThY/9OH4D/9ls34cgkUBiEeocRTU04tHfKPBsUK1PqZCUQM7GiA0IIXJSuXHI64Kbg==}
     engines: {node: '>=0.8'}
 
+  clsx@2.1.1:
+    resolution: {integrity: sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA==}
+    engines: {node: '>=6'}
+
+  cmdk@1.1.1:
+    resolution: {integrity: sha512-Vsv7kFaXm+ptHDMZ7izaRsP70GgrW9NBNGswt9OZaVBLlE0SNpDq8eu/VGXyF9r7M0azK3Wy7OlYXsuyYLFzHg==}
+    peerDependencies:
+      react: ^18 || ^19 || ^19.0.0-rc
+      react-dom: ^18 || ^19 || ^19.0.0-rc
+
   color-convert@2.0.1:
     resolution: {integrity: sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==}
     engines: {node: '>=7.0.0'}
@@ -1250,6 +2502,9 @@ packages:
     resolution: {integrity: sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==}
     engines: {node: '>= 0.8'}
 
+  comma-separated-tokens@2.0.3:
+    resolution: {integrity: sha512-Fu4hJdvzeylCfQPp9SGWidpzrMs7tTrlu6Vb8XGaRGck8QSNZJJp538Wrb60Lax4fPwR64ViY468OIUTbRlGZg==}
+
   commander@4.1.1:
     resolution: {integrity: sha512-NOKm8xhkzAjzFx8B2v5OAHT+u5pRQc2UCa2Vq9jYL/31o2wi9mxBA7LIFs3sV5VSC49z6pEhfbMULvShKj26WA==}
     engines: {node: '>= 6'}
@@ -1316,11 +2571,20 @@ packages:
     resolution: {integrity: sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==}
     engines: {node: '>= 8'}
 
+  css-styled@1.0.8:
+    resolution: {integrity: sha512-tCpP7kLRI8dI95rCh3Syl7I+v7PP+2JYOzWkl0bUEoSbJM+u8ITbutjlQVf0NC2/g4ULROJPi16sfwDIO8/84g==}
+
+  css-to-mat@1.1.1:
+    resolution: {integrity: sha512-kvpxFYZb27jRd2vium35G7q5XZ2WJ9rWjDUMNT36M3Hc41qCrLXFM5iEKMGXcrPsKfXEN+8l/riB4QzwwwiEyQ==}
+
   cssesc@3.0.0:
     resolution: {integrity: sha512-/Tb/JcjK111nNScGob5MNtsntNM1aCNUDipB/TkwZFhyDrrE47SOx/18wF2bbjgc3ZzCSKW1T5nt5EbFoAz/Vg==}
     engines: {node: '>=4'}
     hasBin: true
 
+  csstype@3.2.3:
+    resolution: {integrity: sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==}
+
   d3-array@2.12.1:
     resolution: {integrity: sha512-B0ErZK/66mHtEsR1TkPEEkwdy+WDesimkM5gpZr5Dsg54BiTA5RXtYW5qTLIAcekaS9xfZrzBLF/OAkB3Qn1YQ==}
 
@@ -1460,6 +2724,12 @@ packages:
     resolution: {integrity: sha512-e1U46jVP+w7Iut8Jt8ri1YsPOvFpg46k+K8TpCb0P+zjCkjkPnV7WzfDJzMHy1LnA+wj5pLT1wjO901gLXeEhA==}
     engines: {node: '>=12'}
 
+  date-fns-jalali@4.1.0-0:
+    resolution: {integrity: sha512-hTIP/z+t+qKwBDcmmsnmjWTduxCg+5KfdqWQvb2X/8C9+knYY6epN/pfxdDuyVlSVeFz0sM5eEfwIUQ70U4ckg==}
+
+  date-fns@4.3.0:
+    resolution: {integrity: sha512-OYcL+3N/jyWbYdFGqoMAhytDgxP9pbYPUUiRCOgn4Fewaadk9l/Wam4Avciiyp2BgkpfQyBV9B+ehnVJych+eQ==}
+
   debounce-fn@4.0.0:
     resolution: {integrity: sha512-8pYCQiL9Xdcg0UPSD3d+0KMlOjp+KGU5EPwYddgzQ7DATsg4fuUDjQtsYLmWjnk2obnNHgV3vE2Y4jejSOJVBQ==}
     engines: {node: '>=10'}
@@ -1481,6 +2751,12 @@ packages:
       supports-color:
         optional: true
 
+  decimal.js-light@2.5.1:
+    resolution: {integrity: sha512-qIMFpTMZmny+MMIitAB6D7iVPEorVw6YQRWkvarTkT4tBeSLLiHzcwj6q0MmYSFCiVpiqPJTJEYIrpcPzVEIvg==}
+
+  decode-named-character-reference@1.3.0:
+    resolution: {integrity: sha512-GtpQYB283KrPp6nRw50q3U9/VfOutZOe103qlN7BPP6Ad27xYnOIWv4lPzo8HCAL+mMZofJ9KEy30fq6MfaK6Q==}
+
   decompress-response@6.0.0:
     resolution: {integrity: sha512-aW35yZM6Bb/4oJlZncMH2LCoZtJXTRxES17vE3hoRiowU2kWHaJKFkSBDnDR+cm9J+9QhXmREyIfv0pji9ejCQ==}
     engines: {node: '>=10'}
@@ -1518,6 +2794,10 @@ packages:
     resolution: {integrity: sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==}
     engines: {node: '>= 0.8'}
 
+  dequal@2.0.3:
+    resolution: {integrity: sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA==}
+    engines: {node: '>=6'}
+
   destroy@1.2.0:
     resolution: {integrity: sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg==}
     engines: {node: '>= 0.8', npm: 1.2.8000 || >= 1.4.16}
@@ -1526,9 +2806,15 @@ packages:
     resolution: {integrity: sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==}
     engines: {node: '>=8'}
 
+  detect-node-es@1.1.0:
+    resolution: {integrity: sha512-ypdmJU/TbBby2Dxibuv7ZLW3Bs1QEmM7nHjEANfohJLvE0XVujisn1qPJcZxg+qDucsr+bP6fLD1rPS3AhJ7EQ==}
+
   detect-node@2.1.0:
     resolution: {integrity: sha512-T0NIuQpnTvFDATNuHN5roPwSBG83rFsuO+MXXH9/3N1eFbn4wcPjttvjMLEPWJ0RGUYgQE7cGgS3tNxbqCGM7g==}
 
+  devlop@1.1.0:
+    resolution: {integrity: sha512-RWmIqhcFf1lRYBvNmr7qTNuyCt/7/ns2jbpp1+PalgE/rDQcBT0fioSMUpJ93irlUhC5hrg4cYqe6U+0ImW0rA==}
+
   didyoumean@1.2.2:
     resolution: {integrity: sha512-gxtyfqMg7GKyhQmb056K7M3xszy/myH8w+B4RT+QXBQsvAOdc3XymqDDPHx1BgPgsdAA5SIifona89YtRATDzw==}
 
@@ -1610,6 +2896,19 @@ packages:
     engines: {node: '>= 12.20.55'}
     hasBin: true
 
+  embla-carousel-react@8.6.0:
+    resolution: {integrity: sha512-0/PjqU7geVmo6F734pmPqpyHqiM99olvyecY7zdweCw+6tKEXnrE90pBiBbMMU8s5tICemzpQ3hi5EpxzGW+JA==}
+    peerDependencies:
+      react: ^16.8.0 || ^17.0.1 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc
+
+  embla-carousel-reactive-utils@8.6.0:
+    resolution: {integrity: sha512-fMVUDUEx0/uIEDM0Mz3dHznDhfX+znCCDCeIophYb1QGVM7YThSWX+wz11zlYwWFOr74b4QLGg0hrGPJeG2s4A==}
+    peerDependencies:
+      embla-carousel: 8.6.0
+
+  embla-carousel@8.6.0:
+    resolution: {integrity: sha512-SjWyZBHJPbqxHOzckOfo8lHisEaJWmwd23XppYFYVh10bU66/Pn5tkVkbkCMZVdbUE5eTCI2nD8OyIP4Z+uwkA==}
+
   emoji-regex@8.0.0:
     resolution: {integrity: sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==}
 
@@ -1633,6 +2932,10 @@ packages:
     resolution: {integrity: sha512-HqD3yTBfnBxIrbnM1DoD6Pcq8NECnh8d4As1Qgh0z5Gg3jRRIqijury0CL3ghu/edArpUYiYqQiDUQBIs4np3Q==}
     engines: {node: '>=10.0.0'}
 
+  enhanced-resolve@5.22.0:
+    resolution: {integrity: sha512-xYcDWrpELkFzz9SpZ3PlI6Eu6eD93Yf0WLDRxikGhWJ3MAir2SNZTIVCVZqZ/NUyx8AdMc2gT9C0gPiw18kG+A==}
+    engines: {node: '>=10.13.0'}
+
   env-paths@2.2.1:
     resolution: {integrity: sha512-+h1lkLKhZMTYjog1VEpJNG7NZJWcuc2DDk/qsqSTRRCOXiLjeQ1d1/udrUGhqMxUgAlwKNZ0cf2uqan5GLuS2A==}
     engines: {node: '>=6'}
@@ -1656,6 +2959,9 @@ packages:
     resolution: {integrity: sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==}
     engines: {node: '>= 0.4'}
 
+  es-toolkit@1.47.0:
+    resolution: {integrity: sha512-n1GuoD0WEQZMBk5tttoZSqwgyLx01oqa5XsBmCHwPyNe1S9jPBEmtR2pSgp2kJuWE3ciFZ6yRHmY4pM4C3OOkw==}
+
   es6-error@4.1.1:
     resolution: {integrity: sha512-Um/+FxMr9CISWh0bi5Zv0iOD+4cFh5qLeks1qhAopKVAJw3drgKbKySikp7wGhDL0HPeaja0P5ULZrxLkniUVg==}
 
@@ -1680,6 +2986,10 @@ packages:
     resolution: {integrity: sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==}
     engines: {node: '>=10'}
 
+  escape-string-regexp@5.0.0:
+    resolution: {integrity: sha512-/veY75JbMK4j1yjvuUxuVsiS/hr/4iHs9FTT6cgTexxdE0Ly/glccBAkloH/DofkjRbZU3bnoj38mOmhkZ0lHw==}
+    engines: {node: '>=12'}
+
   eslint-scope@9.1.2:
     resolution: {integrity: sha512-xS90H51cKw0jltxmvmHy2Iai1LIqrfbw57b79w/J7MfvDfkIkFZ+kj6zC3BjtUwh150HsSSdxXZcsuv72miDFQ==}
     engines: {node: ^20.19.0 || ^22.13.0 || >=24}
@@ -1718,6 +3028,9 @@ packages:
     resolution: {integrity: sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==}
     engines: {node: '>=4.0'}
 
+  estree-util-is-identifier-name@3.0.0:
+    resolution: {integrity: sha512-hFtqIDZTIUZ9BXLb8y4pYGyk6+wekIivNVTcmvk8NoOh+VeRn5y6cEHzbURrWbfp1fIqdVipilzj+lfaadNZmg==}
+
   esutils@2.0.3:
     resolution: {integrity: sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==}
     engines: {node: '>=0.10.0'}
@@ -1726,6 +3039,9 @@ packages:
     resolution: {integrity: sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==}
     engines: {node: '>= 0.6'}
 
+  eventemitter3@5.0.4:
+    resolution: {integrity: sha512-mlsTRyGaPBjPedk6Bvw+aqbsXDtoAyAzm5MO7JgU+yVRyMQ5O8bD4Kcci7BS85f93veegeCPkL8R4GLClnjLFw==}
+
   expand-template@2.0.3:
     resolution: {integrity: sha512-XYfuKMvj4O35f/pOXLObndIRvyQ+/+6AhODh+OKWj9S9498pHHn/IMszH+gt0fBCRWMNfk1ZSp5x3AifmnI2vg==}
     engines: {node: '>=6'}
@@ -1737,6 +3053,9 @@ packages:
     resolution: {integrity: sha512-IuL+Elrou2ZvCFHs18/CIzy2Nzvo25nZ1/D2eIZlz7c+QUayAcYoiM2BthCjs+EBHVpjYjcuLDAiCWgeIX3X1Q==}
     engines: {node: '>= 0.10.0'}
 
+  extend@3.0.2:
+    resolution: {integrity: sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==}
+
   extract-zip@2.0.1:
     resolution: {integrity: sha512-GDhU9ntwuKyGXdZBUgTIe+vXnWj0fppUEtMDL0+idd5Sta8TGpHssn/eusA9mrPr9qNDym6SxAYZjNvCn/9RBg==}
     engines: {node: '>= 10.17.0'}
@@ -1765,6 +3084,9 @@ packages:
   fastq@1.20.1:
     resolution: {integrity: sha512-GGToxJ/w1x32s/D2EKND7kTil4n8OVk/9mycTc4VDza13lOvpUZTGX3mFSCtV9ksdGBVzvsyAVLM6mHFThxXxw==}
 
+  fault@1.0.4:
+    resolution: {integrity: sha512-CJ0HCB5tL5fYTEA7ToAq5+kTwd++Borf1/bifxd9iT70QcXr4MRrO3Llf8Ifs70q+SJcGHFtnIE/Nw6giCtECA==}
+
   fd-slicer@1.1.0:
     resolution: {integrity: sha512-cE1qsB/VwyQozZ+q1dGxR8LBYNZeofhEdUNGSMbQD3Gw2lAzX9Zb3uIU6Ebc/Fmyjo9AWWfnn0AUCHqtevs/8g==}
 
@@ -1818,6 +3140,10 @@ packages:
     resolution: {integrity: sha512-8RipRLol37bNs2bhoV67fiTEvdTrbMUYcFTiy3+wuuOnUog2QBHCZWXDRijWQfAkhBj2Uf5UnVaiWwA5vdd82w==}
     engines: {node: '>= 6'}
 
+  format@0.2.2:
+    resolution: {integrity: sha512-wzsgA6WOq+09wrU1tsJ09udeR/YZRaeArL9e1wPbFg3GG2yDnC2ldKpxs4xunpFF9DgqCqOIra3bc1HWrJ37Ww==}
+    engines: {node: '>=0.4.x'}
+
   forwarded@0.2.0:
     resolution: {integrity: sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==}
     engines: {node: '>= 0.6'}
@@ -1825,6 +3151,9 @@ packages:
   fraction.js@4.3.7:
     resolution: {integrity: sha512-ZsDfxO51wGAXREY55a7la9LScWpwv9RxIrYABrlvOFBlH/ShPnrtsXeuUIfXKKOVicNxQ+o8JTbJvjS4M89yew==}
 
+  framework-utils@1.1.0:
+    resolution: {integrity: sha512-KAfqli5PwpFJ8o3psRNs8svpMGyCSAe8nmGcjQ0zZBWN2H6dZDnq+ABp3N3hdUmFeMrLtjOCTXD4yplUJIWceg==}
+
   fresh@0.5.2:
     resolution: {integrity: sha512-zJ2mQYM18rEFOudeV4GShTGIQ7RbzA7ozbU9I/XBpm7kqgMywgmylMwXHxZJmkVoYkna9d2pVXVXPdYTP9ej8Q==}
     engines: {node: '>= 0.6'}
@@ -1876,10 +3205,18 @@ packages:
   function-bind@1.1.2:
     resolution: {integrity: sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==}
 
+  geist@1.7.1:
+    resolution: {integrity: sha512-XF8DM30ODhDu0Ng5S2kOS8j4ZkG/6z2fKWAiFJA7wG0Hc92ZXgjYLrwbD9bVU4nGVzwboPtG+QtaPGsfgnXLaA==}
+    peerDependencies:
+      next: '>=13.2.0'
+
   gensync@1.0.0-beta.2:
     resolution: {integrity: sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==}
     engines: {node: '>=6.9.0'}
 
+  gesto@1.19.4:
+    resolution: {integrity: sha512-hfr/0dWwh0Bnbb88s3QVJd1ZRJeOWcgHPPwmiH6NnafDYvhTsxg+SLYu+q/oPNh9JS3V+nlr6fNs8kvPAtcRDQ==}
+
   get-caller-file@2.0.5:
     resolution: {integrity: sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==}
     engines: {node: 6.* || 8.* || >= 10.*}
@@ -1888,6 +3225,10 @@ packages:
     resolution: {integrity: sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==}
     engines: {node: '>= 0.4'}
 
+  get-nonce@1.0.1:
+    resolution: {integrity: sha512-FJhYRoDaiatfEkUK8HKlicmu/3SGFD51q3itKDGoSTysQJBnfOcxU5GxnhE1E6soB76MbT0MBtnKJuXyAx+96Q==}
+    engines: {node: '>=6'}
+
   get-proto@1.0.1:
     resolution: {integrity: sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==}
     engines: {node: '>= 0.4'}
@@ -1959,13 +3300,27 @@ packages:
     resolution: {integrity: sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==}
     engines: {node: '>= 0.4'}
 
-  hasown@2.0.2:
-    resolution: {integrity: sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==}
+  hasown@2.0.4:
+    resolution: {integrity: sha512-T2UbfbBEF32wiepXIsMlTW9+dDYC6wMh/t/vYA4tuOMKqWz/n3vr1NFSxQiyP+zk2mXsoMA/i/7qV6LKut1t1A==}
     engines: {node: '>= 0.4'}
 
-  hasown@2.0.3:
-    resolution: {integrity: sha512-ej4AhfhfL2Q2zpMmLo7U1Uv9+PyhIZpgQLGT1F9miIGmiCJIoCgSmczFdrc97mWT4kVY72KA+WnnhJ5pghSvSg==}
-    engines: {node: '>= 0.4'}
+  hast-util-parse-selector@4.0.0:
+    resolution: {integrity: sha512-wkQCkSYoOGCRKERFWcxMVMOcYE2K1AaNLU8DXS9arxnLOUEWbOXKXiJUNzEpqZ3JOKpnha3jkFrumEjVliDe7A==}
+
+  hast-util-to-jsx-runtime@2.3.6:
+    resolution: {integrity: sha512-zl6s8LwNyo1P9uw+XJGvZtdFF1GdAkOg8ujOw+4Pyb76874fLps4ueHXDhXWdk6YHQ6OgUtinliG7RsYvCbbBg==}
+
+  hast-util-whitespace@3.0.0:
+    resolution: {integrity: sha512-88JUN06ipLwsnv+dVn+OIYOvAuvBMy/Qoi6O7mQHxdPXpjy+Cd6xRkWwux7DKO+4sYILtLBRIKgsdpS2gQc7qw==}
+
+  hastscript@9.0.1:
+    resolution: {integrity: sha512-g7df9rMFX/SPi34tyGCyUBREQoKkapwdY/T04Qn9TDWfHhAYt4/I0gMVirzK5wEzeUqIjEB+LXC/ypb7Aqno5w==}
+
+  highlight.js@10.7.3:
+    resolution: {integrity: sha512-tzcUFauisWKNHaRkN4Wjl/ZA07gENAjFl3J/c480dprkGTg5EQstgaNFqBfUqCq54kZRIEcreTsAgF/m2quD7A==}
+
+  highlightjs-vue@1.0.0:
+    resolution: {integrity: sha512-PDEfEF102G23vHmPhLyPboFCD+BkMGu+GuJe2d9/eH4FsCwvgBpnc9n0pGE+ffKdph38s6foEZiEjdgHdzp+IA==}
 
   hosted-git-info@4.1.0:
     resolution: {integrity: sha512-kyCuEOWjJqZuDbRHzL8V93NzQhwIB71oFWSyzVo+KPZI+pnQPPxucdkrOZvkLRnrf5URsQM+IJ09Dw29cRALIA==}
@@ -1974,6 +3329,9 @@ packages:
   html-parse-stringify@3.0.1:
     resolution: {integrity: sha512-KknJ50kTInJ7qIScF3jeaFRpMpE8/lfiTdzf/twXyPBLAGrLRTmkz3AdTnKeh40X8k9L2fdYwEp/42WGXIRGcg==}
 
+  html-url-attributes@3.0.1:
+    resolution: {integrity: sha512-ol6UPyBWqsrO6EJySPz2O7ZSr856WDrEzM5zMqp+FJJLGMW35cLYmmZnl0vztAZxRUoNZJFTCohfjuIJ8I4QBQ==}
+
   http-cache-semantics@4.2.0:
     resolution: {integrity: sha512-dTxcvPXqPvXBQpq5dUr6mEMJX4oIEFv6bwom3FDwKRDsuIjjJGANqhBuoAn9c1RQJIdAKav33ED65E2ys+87QQ==}
 
@@ -2000,8 +3358,8 @@ packages:
   i18next-browser-languagedetector@8.2.1:
     resolution: {integrity: sha512-bZg8+4bdmaOiApD7N7BPT9W8MLZG+nPTOFlLiJiT8uzKXFjhxw4v2ierCXOwB5sFDMtuA5G4kgYZ0AznZxQ/cw==}
 
-  i18next@26.2.0:
-    resolution: {integrity: sha512-zwBHldHdTmwN7r6UNc7lC6GWNN+YYg3DrRSeHR5PRRBf5QnJZcYHrQc0uaU26qZeYxR7iFZD+Y315dPnKP47wA==}
+  i18next@26.3.0:
+    resolution: {integrity: sha512-gHSgGpUXVmuqE2El1W61DmxeyeTlFfZgdJRWMo9jScAn5pu7TuTuiccb1zh3E2J9hEBVGJ23+96x0ieBhfuIHA==}
     peerDependencies:
       typescript: ^5 || ^6
     peerDependenciesMeta:
@@ -2032,6 +3390,12 @@ packages:
     resolution: {integrity: sha512-Hs59xBNfUIunMFgWAbGX5cq6893IbWg4KnrjbYwX3tx0ztorVgTDA6B2sxf8ejHJ4wz8BqGUMYlnzNBer5NvGg==}
     engines: {node: '>= 4'}
 
+  immer@10.2.0:
+    resolution: {integrity: sha512-d/+XTN3zfODyjr89gM3mPq1WNX2B8pYsu7eORitdwyA2sBubnTl3laYlBk4sXY5FUa5qTZGBDPJICVbvqzjlbw==}
+
+  immer@11.1.8:
+    resolution: {integrity: sha512-/tbkHMW7y10Lx6i1crLjD4/OhNkRG+Fo7byZHtah0547nIeXYcpIXaUh0IAQY6gO5459qpGGYapcEOHtFXkIuA==}
+
   imurmurhash@0.1.4:
     resolution: {integrity: sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==}
     engines: {node: '>=0.8.19'}
@@ -2046,6 +3410,15 @@ packages:
   ini@1.3.8:
     resolution: {integrity: sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==}
 
+  inline-style-parser@0.2.7:
+    resolution: {integrity: sha512-Nb2ctOyNR8DqQoR0OwRG95uNWIC0C1lCgf5Naz5H6Ji72KZ8OcFZLz2P5sNgwlyoJ8Yif11oMuYs5pBQa86csA==}
+
+  input-otp@1.4.2:
+    resolution: {integrity: sha512-l3jWwYNvrEa6NTCt7BECfCm48GvwuZzkoeG3gBL2w4CHeOXW3eKFmf9UNYkNfYc3mxMrthMnxjIE07MT0zLBQA==}
+    peerDependencies:
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0.0 || ^19.0.0-rc
+
   internmap@1.0.1:
     resolution: {integrity: sha512-lDB5YccMydFBtasVtxnZ3MRBHuaoE8GKsppq+EchKL2U4nK/DmEpPHNH8MZe5HkMtpSiTSOZwfN0tzYjO/lJEw==}
 
@@ -2061,6 +3434,12 @@ packages:
     resolution: {integrity: sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==}
     engines: {node: '>= 0.10'}
 
+  is-alphabetical@2.0.1:
+    resolution: {integrity: sha512-FWyyY60MeTNyeSRpkM2Iry0G9hpr7/9kD40mD/cGQEuilcZYS4okz8SN2Q6rLCJ8gbCt6fN+rC+6tMGS99LaxQ==}
+
+  is-alphanumerical@2.0.1:
+    resolution: {integrity: sha512-hmbYhX/9MUMF5uh7tOXyK/n0ZvWpad5caBA17GsC6vyuCqaWliRG5K1qS9inmUhEMaOBIW7/whAnSwveW/LtZw==}
+
   is-binary-path@2.1.0:
     resolution: {integrity: sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==}
     engines: {node: '>=8'}
@@ -2069,6 +3448,9 @@ packages:
     resolution: {integrity: sha512-evOr8xfXKxE6qSR0hSXL2r3sd7ALj8+7jQEUvPYcm5sgZFdJ+AYzT6yNmJenvIYQBgIGwfwz08sL8zoL7yq2BA==}
     engines: {node: '>= 0.4'}
 
+  is-decimal@2.0.1:
+    resolution: {integrity: sha512-AAB9hiomQs5DXWcRB1rqsxGUstbRroFOPPVAomNk/3XHR5JyEZChOyTWe2oayKnsSsr/kcGqF+z6yuH6HHpN0A==}
+
   is-extglob@2.1.1:
     resolution: {integrity: sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==}
     engines: {node: '>=0.10.0'}
@@ -2081,6 +3463,9 @@ packages:
     resolution: {integrity: sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==}
     engines: {node: '>=0.10.0'}
 
+  is-hexadecimal@2.0.1:
+    resolution: {integrity: sha512-DgZQp241c8oO6cA1SbTEWiXeoxV42vlcJxgH+B3hi1AiqqKruZR3ZGF8In3fj4+/y/7rHvlOZLZtgJ/4ttYGZg==}
+
   is-interactive@1.0.0:
     resolution: {integrity: sha512-2HvIEKRoqS62guEC+qBjpvRubdX910WCMuJTZ+I9yvqKU2/12eSL549HMwtabb4oupdj2sMP50k+XJfB/8JE6w==}
     engines: {node: '>=8'}
@@ -2093,6 +3478,10 @@ packages:
     resolution: {integrity: sha512-drqDG3cbczxxEJRoOXcOjtdp1J/lyp1mNn0xaznRs8+muBhgQcrnbspox5X5fOw0HnMnbfDzvnEMEtqDEJEo8w==}
     engines: {node: '>=8'}
 
+  is-plain-obj@4.1.0:
+    resolution: {integrity: sha512-+Pgi+vMuUNkJyExiMBt5IlFoMyKnr5zhJ4Uspz58WOhBF5QoIZkFyNHIbBAtHwzVAgk5RtndVNsDRN61/mmDqg==}
+    engines: {node: '>=12'}
+
   is-unicode-supported@0.1.0:
     resolution: {integrity: sha512-knxG2q4UC3u8stRGyAVJCOdxFmv5DZiRcdlIaAQXAbSfJya+OhopNotLQrstBhququ4ZpuKbDc/8S6mgXgPFPw==}
     engines: {node: '>=10'}
@@ -2182,6 +3571,12 @@ packages:
   jws@4.0.1:
     resolution: {integrity: sha512-EKI/M/yqPncGUUh44xz0PxSidXFr/+r0pA70+gIYhjv+et7yxM+s29Y+VGDkovRofQem0fs7Uvf4+YmAdyRduA==}
 
+  keycode@2.2.1:
+    resolution: {integrity: sha512-Rdgz9Hl9Iv4QKi8b0OlCRQEzp4AgVxyCtz5S/+VIHezDmrDhkp2N2TqBWOLz0/gbeREXOOiI9/4b8BY9uw2vFg==}
+
+  keycon@1.4.0:
+    resolution: {integrity: sha512-p1NAIxiRMH3jYfTeXRs2uWbVJ1WpEjpi8ktzUyBJsX7/wn2qu2VRXktneBLNtKNxJmlUYxRi9gOJt1DuthXR7A==}
+
   keyv@4.5.4:
     resolution: {integrity: sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==}
 
@@ -2192,6 +3587,80 @@ packages:
     resolution: {integrity: sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==}
     engines: {node: '>= 0.8.0'}
 
+  lightningcss-android-arm64@1.32.0:
+    resolution: {integrity: sha512-YK7/ClTt4kAK0vo6w3X+Pnm0D2cf2vPHbhOXdoNti1Ga0al1P4TBZhwjATvjNwLEBCnKvjJc2jQgHXH0NEwlAg==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [arm64]
+    os: [android]
+
+  lightningcss-darwin-arm64@1.32.0:
+    resolution: {integrity: sha512-RzeG9Ju5bag2Bv1/lwlVJvBE3q6TtXskdZLLCyfg5pt+HLz9BqlICO7LZM7VHNTTn/5PRhHFBSjk5lc4cmscPQ==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [arm64]
+    os: [darwin]
+
+  lightningcss-darwin-x64@1.32.0:
+    resolution: {integrity: sha512-U+QsBp2m/s2wqpUYT/6wnlagdZbtZdndSmut/NJqlCcMLTWp5muCrID+K5UJ6jqD2BFshejCYXniPDbNh73V8w==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [x64]
+    os: [darwin]
+
+  lightningcss-freebsd-x64@1.32.0:
+    resolution: {integrity: sha512-JCTigedEksZk3tHTTthnMdVfGf61Fky8Ji2E4YjUTEQX14xiy/lTzXnu1vwiZe3bYe0q+SpsSH/CTeDXK6WHig==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [x64]
+    os: [freebsd]
+
+  lightningcss-linux-arm-gnueabihf@1.32.0:
+    resolution: {integrity: sha512-x6rnnpRa2GL0zQOkt6rts3YDPzduLpWvwAF6EMhXFVZXD4tPrBkEFqzGowzCsIWsPjqSK+tyNEODUBXeeVHSkw==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [arm]
+    os: [linux]
+
+  lightningcss-linux-arm64-gnu@1.32.0:
+    resolution: {integrity: sha512-0nnMyoyOLRJXfbMOilaSRcLH3Jw5z9HDNGfT/gwCPgaDjnx0i8w7vBzFLFR1f6CMLKF8gVbebmkUN3fa/kQJpQ==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [arm64]
+    os: [linux]
+    libc: [glibc]
+
+  lightningcss-linux-arm64-musl@1.32.0:
+    resolution: {integrity: sha512-UpQkoenr4UJEzgVIYpI80lDFvRmPVg6oqboNHfoH4CQIfNA+HOrZ7Mo7KZP02dC6LjghPQJeBsvXhJod/wnIBg==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [arm64]
+    os: [linux]
+    libc: [musl]
+
+  lightningcss-linux-x64-gnu@1.32.0:
+    resolution: {integrity: sha512-V7Qr52IhZmdKPVr+Vtw8o+WLsQJYCTd8loIfpDaMRWGUZfBOYEJeyJIkqGIDMZPwPx24pUMfwSxxI8phr/MbOA==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [x64]
+    os: [linux]
+    libc: [glibc]
+
+  lightningcss-linux-x64-musl@1.32.0:
+    resolution: {integrity: sha512-bYcLp+Vb0awsiXg/80uCRezCYHNg1/l3mt0gzHnWV9XP1W5sKa5/TCdGWaR/zBM2PeF/HbsQv/j2URNOiVuxWg==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [x64]
+    os: [linux]
+    libc: [musl]
+
+  lightningcss-win32-arm64-msvc@1.32.0:
+    resolution: {integrity: sha512-8SbC8BR40pS6baCM8sbtYDSwEVQd4JlFTOlaD3gWGHfThTcABnNDBda6eTZeqbofalIJhFx0qKzgHJmcPTnGdw==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [arm64]
+    os: [win32]
+
+  lightningcss-win32-x64-msvc@1.32.0:
+    resolution: {integrity: sha512-Amq9B/SoZYdDi1kFrojnoqPLxYhQ4Wo5XiL8EVJrVsB8ARoC1PWW6VGtT0WKCemjy8aC+louJnjS7U18x3b06Q==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [x64]
+    os: [win32]
+
+  lightningcss@1.32.0:
+    resolution: {integrity: sha512-NXYBzinNrblfraPGyrbPoD19C1h9lfI/1mzgWYvXUTe414Gz/X1FD2XBZSZM7rRTrMA8JL3OtAaGifrIKhQ5yQ==}
+    engines: {node: '>= 12.0.0'}
+
   lilconfig@3.1.3:
     resolution: {integrity: sha512-/vlFKAoH5Cgt3Ie+JLhRbwOsCQePABiU3tJ1egGvyQ+33R/vcwM2Zl2QR/LzjsBeItPt3oSVXapn+m4nQDvpzw==}
     engines: {node: '>=14'}
@@ -2224,6 +3693,9 @@ packages:
     resolution: {integrity: sha512-8XPvpAA8uyhfteu8pIvQxpJZ7SYYdpUivZpGy6sFsBuKRY/7rQGavedeB8aK+Zkyq6upMFVL/9AW6vOYzfRyLg==}
     engines: {node: '>=10'}
 
+  longest-streak@3.1.0:
+    resolution: {integrity: sha512-9Ri+o0JYgehTaVBBDoMqIl8GXtbWg711O3srftcHhZ0dqnETqLaoIK0x17fUw9rFSlK/0NlsKe0Ahhyl5pXE2g==}
+
   loose-envify@1.4.0:
     resolution: {integrity: sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==}
     hasBin: true
@@ -2232,6 +3704,9 @@ packages:
     resolution: {integrity: sha512-tqNXrS78oMOE73NMxK4EMLQsQowWf8jKooH9g7xPavRT706R6bkQJ6DY2Te7QukaZsulxa30wQ7bk0pm4XiHmA==}
     engines: {node: '>=8'}
 
+  lowlight@1.20.0:
+    resolution: {integrity: sha512-8Ktj+prEb1RoCPkEOrPMYUN/nCggB7qAWe3a7OpMjWQkh3l2RD5wKRQ+o8Q8YuI9RG/xs95waaI/E6ym/7NsTw==}
+
   lru-cache@10.4.3:
     resolution: {integrity: sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==}
 
@@ -2251,32 +3726,172 @@ packages:
     peerDependencies:
       react: ^16.5.1 || ^17.0.0 || ^18.0.0 || ^19.0.0
 
-  make-fetch-happen@14.0.3:
-    resolution: {integrity: sha512-QMjGbFTP0blj97EeidG5hk/QhKQ3T4ICckQGLgz38QF7Vgbk6e6FTARN8KhKxyBbWn8R0HU+bnw8aSoFPD4qtQ==}
-    engines: {node: ^18.17.0 || >=20.5.0}
+  lucide-react@0.556.0:
+    resolution: {integrity: sha512-iOb8dRk7kLaYBZhR2VlV1CeJGxChBgUthpSP8wom9jfj79qovgG6qcSdiy6vkoREKPnbUYzJsCn4o4PtG3Iy+A==}
+    peerDependencies:
+      react: ^16.5.1 || ^17.0.0 || ^18.0.0 || ^19.0.0
+
+  magic-string@0.30.21:
+    resolution: {integrity: sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==}
+
+  make-fetch-happen@14.0.3:
+    resolution: {integrity: sha512-QMjGbFTP0blj97EeidG5hk/QhKQ3T4ICckQGLgz38QF7Vgbk6e6FTARN8KhKxyBbWn8R0HU+bnw8aSoFPD4qtQ==}
+    engines: {node: ^18.17.0 || >=20.5.0}
+
+  markdown-table@3.0.4:
+    resolution: {integrity: sha512-wiYz4+JrLyb/DqW2hkFJxP7Vd7JuTDm77fvbM8VfEQdmSMqcImWeeRbHwZjBjIFki/VaMK2BhFi7oUUZeM5bqw==}
+
+  matcher@3.0.0:
+    resolution: {integrity: sha512-OkeDaAZ/bQCxeFAozM55PKcKU0yJMPGifLwV4Qgjitu+5MoAfSQN4lsLJeXZ1b8w0x+/Emda6MZgXS1jvsapng==}
+    engines: {node: '>=10'}
+
+  math-intrinsics@1.1.0:
+    resolution: {integrity: sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==}
+    engines: {node: '>= 0.4'}
+
+  mdast-util-find-and-replace@3.0.2:
+    resolution: {integrity: sha512-Tmd1Vg/m3Xz43afeNxDIhWRtFZgM2VLyaf4vSTYwudTyeuTneoL3qtWMA5jeLyz/O1vDJmmV4QuScFCA2tBPwg==}
+
+  mdast-util-from-markdown@2.0.3:
+    resolution: {integrity: sha512-W4mAWTvSlKvf8L6J+VN9yLSqQ9AOAAvHuoDAmPkz4dHf553m5gVj2ejadHJhoJmcmxEnOv6Pa8XJhpxE93kb8Q==}
+
+  mdast-util-gfm-autolink-literal@2.0.1:
+    resolution: {integrity: sha512-5HVP2MKaP6L+G6YaxPNjuL0BPrq9orG3TsrZ9YXbA3vDw/ACI4MEsnoDpn6ZNm7GnZgtAcONJyPhOP8tNJQavQ==}
+
+  mdast-util-gfm-footnote@2.1.0:
+    resolution: {integrity: sha512-sqpDWlsHn7Ac9GNZQMeUzPQSMzR6Wv0WKRNvQRg0KqHh02fpTz69Qc1QSseNX29bhz1ROIyNyxExfawVKTm1GQ==}
+
+  mdast-util-gfm-strikethrough@2.0.0:
+    resolution: {integrity: sha512-mKKb915TF+OC5ptj5bJ7WFRPdYtuHv0yTRxK2tJvi+BDqbkiG7h7u/9SI89nRAYcmap2xHQL9D+QG/6wSrTtXg==}
+
+  mdast-util-gfm-table@2.0.0:
+    resolution: {integrity: sha512-78UEvebzz/rJIxLvE7ZtDd/vIQ0RHv+3Mh5DR96p7cS7HsBhYIICDBCu8csTNWNO6tBWfqXPWekRuj2FNOGOZg==}
+
+  mdast-util-gfm-task-list-item@2.0.0:
+    resolution: {integrity: sha512-IrtvNvjxC1o06taBAVJznEnkiHxLFTzgonUdy8hzFVeDun0uTjxxrRGVaNFqkU1wJR3RBPEfsxmU6jDWPofrTQ==}
+
+  mdast-util-gfm@3.1.0:
+    resolution: {integrity: sha512-0ulfdQOM3ysHhCJ1p06l0b0VKlhU0wuQs3thxZQagjcjPrlFRqY215uZGHHJan9GEAXd9MbfPjFJz+qMkVR6zQ==}
+
+  mdast-util-mdx-expression@2.0.1:
+    resolution: {integrity: sha512-J6f+9hUp+ldTZqKRSg7Vw5V6MqjATc+3E4gf3CFNcuZNWD8XdyI6zQ8GqH7f8169MM6P7hMBRDVGnn7oHB9kXQ==}
+
+  mdast-util-mdx-jsx@3.2.0:
+    resolution: {integrity: sha512-lj/z8v0r6ZtsN/cGNNtemmmfoLAFZnjMbNyLzBafjzikOM+glrjNHPlf6lQDOTccj9n5b0PPihEBbhneMyGs1Q==}
+
+  mdast-util-mdxjs-esm@2.0.1:
+    resolution: {integrity: sha512-EcmOpxsZ96CvlP03NghtH1EsLtr0n9Tm4lPUJUBccV9RwUOneqSycg19n5HGzCf+10LozMRSObtVr3ee1WoHtg==}
+
+  mdast-util-phrasing@4.1.0:
+    resolution: {integrity: sha512-TqICwyvJJpBwvGAMZjj4J2n0X8QWp21b9l0o7eXyVJ25YNWYbJDVIyD1bZXE6WtV6RmKJVYmQAKWa0zWOABz2w==}
+
+  mdast-util-to-hast@13.2.1:
+    resolution: {integrity: sha512-cctsq2wp5vTsLIcaymblUriiTcZd0CwWtCbLvrOzYCDZoWyMNV8sZ7krj09FSnsiJi3WVsHLM4k6Dq/yaPyCXA==}
+
+  mdast-util-to-markdown@2.1.2:
+    resolution: {integrity: sha512-xj68wMTvGXVOKonmog6LwyJKrYXZPvlwabaryTjLh9LuvovB/KAH+kvi8Gjj+7rJjsFi23nkUxRQv1KqSroMqA==}
+
+  mdast-util-to-string@4.0.0:
+    resolution: {integrity: sha512-0H44vDimn51F0YwvxSJSm0eCDOJTRlmN0R1yBh4HLj9wiV1Dn0QoXGbvFAWj2hSItVTlCmBF1hqKlIyUBVFLPg==}
+
+  media-typer@0.3.0:
+    resolution: {integrity: sha512-dq+qelQ9akHpcOl/gUVRTxVIOkAJ1wR3QAvb4RsVjS8oVoFjDGTc679wJYmUmknUF5HwMLOgb5O+a3KxfWapPQ==}
+    engines: {node: '>= 0.6'}
+
+  merge-descriptors@1.0.3:
+    resolution: {integrity: sha512-gaNvAS7TZ897/rVaZ0nMtAyxNyi/pdbjbAwUpFQpN70GqnVfOiXpeUUMKRBmzXaSQ8DdTX4/0ms62r2K+hE6mQ==}
+
+  merge2@1.4.1:
+    resolution: {integrity: sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==}
+    engines: {node: '>= 8'}
+
+  methods@1.1.2:
+    resolution: {integrity: sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w==}
+    engines: {node: '>= 0.6'}
+
+  micromark-core-commonmark@2.0.3:
+    resolution: {integrity: sha512-RDBrHEMSxVFLg6xvnXmb1Ayr2WzLAWjeSATAoxwKYJV94TeNavgoIdA0a9ytzDSVzBy2YKFK+emCPOEibLeCrg==}
+
+  micromark-extension-gfm-autolink-literal@2.1.0:
+    resolution: {integrity: sha512-oOg7knzhicgQ3t4QCjCWgTmfNhvQbDDnJeVu9v81r7NltNCVmhPy1fJRX27pISafdjL+SVc4d3l48Gb6pbRypw==}
+
+  micromark-extension-gfm-footnote@2.1.0:
+    resolution: {integrity: sha512-/yPhxI1ntnDNsiHtzLKYnE3vf9JZ6cAisqVDauhp4CEHxlb4uoOTxOCJ+9s51bIB8U1N1FJ1RXOKTIlD5B/gqw==}
+
+  micromark-extension-gfm-strikethrough@2.1.0:
+    resolution: {integrity: sha512-ADVjpOOkjz1hhkZLlBiYA9cR2Anf8F4HqZUO6e5eDcPQd0Txw5fxLzzxnEkSkfnD0wziSGiv7sYhk/ktvbf1uw==}
+
+  micromark-extension-gfm-table@2.1.1:
+    resolution: {integrity: sha512-t2OU/dXXioARrC6yWfJ4hqB7rct14e8f7m0cbI5hUmDyyIlwv5vEtooptH8INkbLzOatzKuVbQmAYcbWoyz6Dg==}
+
+  micromark-extension-gfm-tagfilter@2.0.0:
+    resolution: {integrity: sha512-xHlTOmuCSotIA8TW1mDIM6X2O1SiX5P9IuDtqGonFhEK0qgRI4yeC6vMxEV2dgyr2TiD+2PQ10o+cOhdVAcwfg==}
+
+  micromark-extension-gfm-task-list-item@2.1.0:
+    resolution: {integrity: sha512-qIBZhqxqI6fjLDYFTBIa4eivDMnP+OZqsNwmQ3xNLE4Cxwc+zfQEfbs6tzAo2Hjq+bh6q5F+Z8/cksrLFYWQQw==}
+
+  micromark-extension-gfm@3.0.0:
+    resolution: {integrity: sha512-vsKArQsicm7t0z2GugkCKtZehqUm31oeGBV/KVSorWSy8ZlNAv7ytjFhvaryUiCUJYqs+NoE6AFhpQvBTM6Q4w==}
+
+  micromark-factory-destination@2.0.1:
+    resolution: {integrity: sha512-Xe6rDdJlkmbFRExpTOmRj9N3MaWmbAgdpSrBQvCFqhezUn4AHqJHbaEnfbVYYiexVSs//tqOdY/DxhjdCiJnIA==}
+
+  micromark-factory-label@2.0.1:
+    resolution: {integrity: sha512-VFMekyQExqIW7xIChcXn4ok29YE3rnuyveW3wZQWWqF4Nv9Wk5rgJ99KzPvHjkmPXF93FXIbBp6YdW3t71/7Vg==}
+
+  micromark-factory-space@2.0.1:
+    resolution: {integrity: sha512-zRkxjtBxxLd2Sc0d+fbnEunsTj46SWXgXciZmHq0kDYGnck/ZSGj9/wULTV95uoeYiK5hRXP2mJ98Uo4cq/LQg==}
+
+  micromark-factory-title@2.0.1:
+    resolution: {integrity: sha512-5bZ+3CjhAd9eChYTHsjy6TGxpOFSKgKKJPJxr293jTbfry2KDoWkhBb6TcPVB4NmzaPhMs1Frm9AZH7OD4Cjzw==}
+
+  micromark-factory-whitespace@2.0.1:
+    resolution: {integrity: sha512-Ob0nuZ3PKt/n0hORHyvoD9uZhr+Za8sFoP+OnMcnWK5lngSzALgQYKMr9RJVOWLqQYuyn6ulqGWSXdwf6F80lQ==}
+
+  micromark-util-character@2.1.1:
+    resolution: {integrity: sha512-wv8tdUTJ3thSFFFJKtpYKOYiGP2+v96Hvk4Tu8KpCAsTMs6yi+nVmGh1syvSCsaxz45J6Jbw+9DD6g97+NV67Q==}
+
+  micromark-util-chunked@2.0.1:
+    resolution: {integrity: sha512-QUNFEOPELfmvv+4xiNg2sRYeS/P84pTW0TCgP5zc9FpXetHY0ab7SxKyAQCNCc1eK0459uoLI1y5oO5Vc1dbhA==}
+
+  micromark-util-classify-character@2.0.1:
+    resolution: {integrity: sha512-K0kHzM6afW/MbeWYWLjoHQv1sgg2Q9EccHEDzSkxiP/EaagNzCm7T/WMKZ3rjMbvIpvBiZgwR3dKMygtA4mG1Q==}
+
+  micromark-util-combine-extensions@2.0.1:
+    resolution: {integrity: sha512-OnAnH8Ujmy59JcyZw8JSbK9cGpdVY44NKgSM7E9Eh7DiLS2E9RNQf0dONaGDzEG9yjEl5hcqeIsj4hfRkLH/Bg==}
+
+  micromark-util-decode-numeric-character-reference@2.0.2:
+    resolution: {integrity: sha512-ccUbYk6CwVdkmCQMyr64dXz42EfHGkPQlBj5p7YVGzq8I7CtjXZJrubAYezf7Rp+bjPseiROqe7G6foFd+lEuw==}
+
+  micromark-util-decode-string@2.0.1:
+    resolution: {integrity: sha512-nDV/77Fj6eH1ynwscYTOsbK7rR//Uj0bZXBwJZRfaLEJ1iGBR6kIfNmlNqaqJf649EP0F3NWNdeJi03elllNUQ==}
 
-  matcher@3.0.0:
-    resolution: {integrity: sha512-OkeDaAZ/bQCxeFAozM55PKcKU0yJMPGifLwV4Qgjitu+5MoAfSQN4lsLJeXZ1b8w0x+/Emda6MZgXS1jvsapng==}
-    engines: {node: '>=10'}
+  micromark-util-encode@2.0.1:
+    resolution: {integrity: sha512-c3cVx2y4KqUnwopcO9b/SCdo2O67LwJJ/UyqGfbigahfegL9myoEFoDYZgkT7f36T0bLrM9hZTAaAyH+PCAXjw==}
 
-  math-intrinsics@1.1.0:
-    resolution: {integrity: sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==}
-    engines: {node: '>= 0.4'}
+  micromark-util-html-tag-name@2.0.1:
+    resolution: {integrity: sha512-2cNEiYDhCWKI+Gs9T0Tiysk136SnR13hhO8yW6BGNyhOC4qYFnwF1nKfD3HFAIXA5c45RrIG1ub11GiXeYd1xA==}
 
-  media-typer@0.3.0:
-    resolution: {integrity: sha512-dq+qelQ9akHpcOl/gUVRTxVIOkAJ1wR3QAvb4RsVjS8oVoFjDGTc679wJYmUmknUF5HwMLOgb5O+a3KxfWapPQ==}
-    engines: {node: '>= 0.6'}
+  micromark-util-normalize-identifier@2.0.1:
+    resolution: {integrity: sha512-sxPqmo70LyARJs0w2UclACPUUEqltCkJ6PhKdMIDuJ3gSf/Q+/GIe3WKl0Ijb/GyH9lOpUkRAO2wp0GVkLvS9Q==}
 
-  merge-descriptors@1.0.3:
-    resolution: {integrity: sha512-gaNvAS7TZ897/rVaZ0nMtAyxNyi/pdbjbAwUpFQpN70GqnVfOiXpeUUMKRBmzXaSQ8DdTX4/0ms62r2K+hE6mQ==}
+  micromark-util-resolve-all@2.0.1:
+    resolution: {integrity: sha512-VdQyxFWFT2/FGJgwQnJYbe1jjQoNTS4RjglmSjTUlpUMa95Htx9NHeYW4rGDJzbjvCsl9eLjMQwGeElsqmzcHg==}
 
-  merge2@1.4.1:
-    resolution: {integrity: sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==}
-    engines: {node: '>= 8'}
+  micromark-util-sanitize-uri@2.0.1:
+    resolution: {integrity: sha512-9N9IomZ/YuGGZZmQec1MbgxtlgougxTodVwDzzEouPKo3qFWvymFHWcnDi2vzV1ff6kas9ucW+o3yzJK9YB1AQ==}
 
-  methods@1.1.2:
-    resolution: {integrity: sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w==}
-    engines: {node: '>= 0.6'}
+  micromark-util-subtokenize@2.1.0:
+    resolution: {integrity: sha512-XQLu552iSctvnEcgXw6+Sx75GflAPNED1qx7eBJ+wydBb2KCbRZe+NwvIEEMM83uml1+2WSXpBAcp9IUCgCYWA==}
+
+  micromark-util-symbol@2.0.1:
+    resolution: {integrity: sha512-vs5t8Apaud9N28kgCrRUdEed4UJ+wWNvicHLPxCa9ENlYuAY31M0ETy5y1vA33YoNPDFTghEbnh6efaE8h4x0Q==}
+
+  micromark-util-types@2.0.2:
+    resolution: {integrity: sha512-Yw0ECSpJoViF1qTU4DC6NwtC4aWGt1EkzaQB8KPPyCRR8z9TWeV0HbEFGTO+ZY1wB22zmxnJqhPyTpOVCpeHTA==}
+
+  micromark@4.0.2:
+    resolution: {integrity: sha512-zpe98Q6kvavpCr1NPVSCMebCKfD7CA2NqZ+rykeNhONIJBpc1tFKt9hucLGwha3jNTNI8lHpctWJWoimVF4PfA==}
 
   micromatch@4.0.8:
     resolution: {integrity: sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==}
@@ -2408,6 +4023,33 @@ packages:
     resolution: {integrity: sha512-8Ofs/AUQh8MaEcrlq5xOX0CQ9ypTF5dl78mjlMNfOK08fzpgTHQRQPBxcPlEtIw0yRpws+Zo/3r+5WRby7u3Gg==}
     engines: {node: '>= 0.6'}
 
+  next-themes@0.4.6:
+    resolution: {integrity: sha512-pZvgD5L0IEvX5/9GWyHMf3m8BKiVQwsCMHfoFosXtXBMnaS0ZnIJ9ST4b4NqLVKDEm8QBxoNNGNaBv2JNF6XNA==}
+    peerDependencies:
+      react: ^16.8 || ^17 || ^18 || ^19 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17 || ^18 || ^19 || ^19.0.0-rc
+
+  next@16.2.6:
+    resolution: {integrity: sha512-qOVgKJg1+At15NpeUP+eJgCHvTCgXsogweq87Ri/Ix7PkqQHg4sdaXmSFqKlgaIXE4kW0g25LE68W87UANlHtw==}
+    engines: {node: '>=20.9.0'}
+    hasBin: true
+    peerDependencies:
+      '@opentelemetry/api': ^1.1.0
+      '@playwright/test': ^1.51.1
+      babel-plugin-react-compiler: '*'
+      react: ^18.2.0 || 19.0.0-rc-de68d2f4-20241204 || ^19.0.0
+      react-dom: ^18.2.0 || 19.0.0-rc-de68d2f4-20241204 || ^19.0.0
+      sass: ^1.3.0
+    peerDependenciesMeta:
+      '@opentelemetry/api':
+        optional: true
+      '@playwright/test':
+        optional: true
+      babel-plugin-react-compiler:
+        optional: true
+      sass:
+        optional: true
+
   node-abi@3.92.0:
     resolution: {integrity: sha512-KdHvFWZjEKDf0cakgFjebl371GPsISX2oZHcuyKqM7DtogIsHrqKeLTo8wBHxaXRAQlY2PsPlZmfo+9ZCxEREQ==}
     engines: {node: '>=10'}
@@ -2482,6 +4124,9 @@ packages:
     resolution: {integrity: sha512-5b6Y85tPxZZ7QytO+BQzysW31HJku27cRIlkbAXaNx+BdcVi+LlRFmVXzeF6a7JCwJpyw5c4b+YSVImQIrBpuQ==}
     engines: {node: '>=10'}
 
+  overlap-area@1.1.0:
+    resolution: {integrity: sha512-3dlJgJCaVeXH0/eZjYVJvQiLVVrPO4U1ZGqlATtx6QGO3b5eNM6+JgUKa7oStBTdYuGTk7gVoABCW6Tp+dhRdw==}
+
   p-cancelable@2.1.1:
     resolution: {integrity: sha512-BZOr3nRQHOntUjTrH8+Lh54smKHoHyur8We1V8DSMVrl5A2malOOwuJRnKRDjSnkoeBh4at6BwEnb5I7Jl31wg==}
     engines: {node: '>=8'}
@@ -2513,6 +4158,9 @@ packages:
   package-json-from-dist@1.0.1:
     resolution: {integrity: sha512-UEZIS3/by4OC8vL3P2dTXRETpebLI2NiI5vIrjaD/5UtrkFX/tNbwjTSRAGC/+7CAo2pIcBaRgWmcBBHcsaCIw==}
 
+  parse-entities@4.0.2:
+    resolution: {integrity: sha512-GG2AQYWoLgL877gQIKeRPGO1xF9+eG1ujIb5soS5gPvLQ1y2o8FL90w2QWNdf9I361Mpp7726c+lj3U0qK1uGw==}
+
   parseurl@1.3.3:
     resolution: {integrity: sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==}
     engines: {node: '>= 0.8'}
@@ -2565,10 +4213,6 @@ packages:
     resolution: {integrity: sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==}
     engines: {node: '>=12'}
 
-  picomatch@4.0.4:
-    resolution: {integrity: sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==}
-    engines: {node: '>=12'}
-
   pify@2.3.0:
     resolution: {integrity: sha512-udgsAY+fTnvv7kI7aaxbqwWNb0AHiB0qBO89PZKPkoTmGOgdbrHDKD+0B2X4uTfJ/FT1R09r9gTsjUjNJotuog==}
     engines: {node: '>=0.10.0'}
@@ -2625,6 +4269,10 @@ packages:
     peerDependencies:
       postcss: ^8.2.14
 
+  postcss-selector-parser@6.0.10:
+    resolution: {integrity: sha512-IQ7TZdoaqbT+LCpShg46jnZVlhWD2w6iQYAcYXfHARZ7X1t/UGhhceQDs5X0cGqKvYlHNOuv7Oa1xmb0oQuA3w==}
+    engines: {node: '>=4'}
+
   postcss-selector-parser@6.1.2:
     resolution: {integrity: sha512-Q8qQfPiZ+THO/3ZrOrO0cJJKfpYCagtMUkXbnEfmgUjwXg6z/WBeOyS9APBBPCTSiDV+s4SwQGu8yFsiMRIudg==}
     engines: {node: '>=4'}
@@ -2632,6 +4280,10 @@ packages:
   postcss-value-parser@4.2.0:
     resolution: {integrity: sha512-1NNCs6uurfkVbeXG4S8JFT9t19m45ICnif8zWLd5oPSZ50QnwMfK+H3jv408d4jw/7Bttv5axS5IiHoLaVNHeQ==}
 
+  postcss@8.4.31:
+    resolution: {integrity: sha512-PS08Iboia9mts/2ygV3eLpY5ghnUcfLV/EXTOW1E2qYxJKGGBUtNjN76FYHnMs36RmARn41bC0AZmn+rR0OVpQ==}
+    engines: {node: ^10 || ^12 || >=14}
+
   postcss@8.5.1:
     resolution: {integrity: sha512-6oz2beyjc5VMn/KV1pPw8fliQkhBXrVn1Z3TVyqZxU8kZpzEKhBdmCFqI6ZbmGtamQvQGuU1sgPTk8ZrXDD7jQ==}
     engines: {node: ^10 || ^12 || >=14}
@@ -2651,6 +4303,10 @@ packages:
     resolution: {integrity: sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==}
     engines: {node: '>= 0.8.0'}
 
+  prismjs@1.30.0:
+    resolution: {integrity: sha512-DEvV2ZF2r2/63V+tK8hQvrR2ZGn10srHbXviTlcv7Kpzw8jWiNTqbVgjO3IY8RxrrOUF8VPMQQFysYYYv0YZxw==}
+    engines: {node: '>=6'}
+
   proc-log@5.0.0:
     resolution: {integrity: sha512-Azwzvl90HaF0aCz1JrDdXQykFakSSNPaPoiZ9fm5qJIMHioDZEi7OAdRwSm6rSoPtY3Qutnm3L7ogmg3dc+wbQ==}
     engines: {node: ^18.17.0 || >=20.5.0}
@@ -2666,6 +4322,9 @@ packages:
   proper-lockfile@4.1.2:
     resolution: {integrity: sha512-TjNPblN4BwAWMXU8s9AEz4JmQxnD1NNL7bNOY/AKUzyamc379FWASUhc/K1pL2noVb+XmZKLL68cjzLsiOAMaA==}
 
+  property-information@7.1.0:
+    resolution: {integrity: sha512-TwEZ+X+yCJmYfL7TPUOcvBZ4QfoT5YenQiJuX//0th53DE6w0xxLEtfK3iyryQFddXuvkIk51EEgrJQ0WJkOmQ==}
+
   proxy-addr@2.0.7:
     resolution: {integrity: sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==}
     engines: {node: '>= 0.10'}
@@ -2673,9 +4332,6 @@ packages:
   pump@3.0.3:
     resolution: {integrity: sha512-todwxLMY7/heScKmntwQG8CXVkWUOdYxIvY2s0VWAAMh/nd8SoYiRaKjlr7+iCs984f2P8zvrfWcDDYVb73NfA==}
 
-  pump@3.0.4:
-    resolution: {integrity: sha512-VS7sjc6KR7e1ukRFhQSY5LM2uBWAUPiOPa/A3mkKmiMwSmRFUITt0xuj+/lesgnCv+dPIEYlkzrcyXgquIHMcA==}
-
   punycode@2.3.1:
     resolution: {integrity: sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==}
     engines: {node: '>=6'}
@@ -2691,6 +4347,19 @@ packages:
     resolution: {integrity: sha512-WuyALRjWPDGtt/wzJiadO5AXY+8hZ80hVpe6MyivgraREW751X3SbhRvG3eLKOYN+8VEvqLcf3wdnt44Z4S4SA==}
     engines: {node: '>=10'}
 
+  radix-ui@1.4.3:
+    resolution: {integrity: sha512-aWizCQiyeAenIdUbqEpXgRA1ya65P13NKn/W8rWkcN0OPkRDxdBVLWnIEDsS2RpwCK2nobI7oMUSmexzTDyAmA==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
   range-parser@1.2.1:
     resolution: {integrity: sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==}
     engines: {node: '>= 0.6'}
@@ -2703,11 +4372,31 @@ packages:
     resolution: {integrity: sha512-y3bGgqKj3QBdxLbLkomlohkvsA8gdAiUQlSBJnBhfn+BPxg4bc62d8TcBW15wavDfgexCgccckhcZvywyQYPOw==}
     hasBin: true
 
+  react-css-styled@1.1.9:
+    resolution: {integrity: sha512-M7fJZ3IWFaIHcZEkoFOnkjdiUFmwd8d+gTh2bpqMOcnxy/0Gsykw4dsL4QBiKsxcGow6tETUa4NAUcmJF+/nfw==}
+
+  react-day-picker@9.14.0:
+    resolution: {integrity: sha512-tBaoDWjPwe0M5pGrum4H0SR6Lyk+BO9oHnp9JbKpGKW2mlraNPgP9BMfsg5pWpwrssARmeqk7YBl2oXutZTaHA==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      react: '>=16.8.0'
+
   react-dom@18.3.1:
     resolution: {integrity: sha512-5m4nQKp+rZRb09LNH59GM4BxTh9251/ylbKIbpe7TpGxfJ+9kv6BLkLBXIjjspbgbnIBNqlI23tRnTWT0snUIw==}
     peerDependencies:
       react: ^18.3.1
 
+  react-dom@19.2.6:
+    resolution: {integrity: sha512-0prMI+hvBbPjsWnxDLxlCGyM8PN6UuWjEUCYmZhO67xIV9Xasa/r/vDnq+Xyq4Lo27g8QSbO5YzARu0D1Sps3g==}
+    peerDependencies:
+      react: ^19.2.6
+
+  react-hook-form@7.76.1:
+    resolution: {integrity: sha512-rYM7tPiWlu3nZchkR/ex7piyzui2vFPyaLnXnI/RnblB/L4qfMmyses8llJVtF1NpE9WBBsJlGtcSZzPCXW1qQ==}
+    engines: {node: '>=18.0.0'}
+    peerDependencies:
+      react: ^16.8.0 || ^17 || ^18 || ^19
+
   react-i18next@17.0.8:
     resolution: {integrity: sha512-0ooKbGLU8JXhe1zwpQUWIeXSgLPOfwJmgheWRIUpcoA0CpyabpGhayjdG+/eA5esC1AQ8h2jWpXjJfzQzeDOCw==}
     peerDependencies:
@@ -2724,10 +4413,60 @@ packages:
       typescript:
         optional: true
 
+  react-is@19.2.6:
+    resolution: {integrity: sha512-XjBR15BhXuylgWGuslhDKqlSayuqvqBX91BP8pauG8kd1zY8kotkNWbXksTCNRarse4kuGbe2kIY05ARtwNIvw==}
+
+  react-markdown@10.1.0:
+    resolution: {integrity: sha512-qKxVopLT/TyA6BX3Ue5NwabOsAzm0Q7kAPwq6L+wWDwisYs7R8vZ0nRXqq6rkueboxpkjvLGU9fWifiX/ZZFxQ==}
+    peerDependencies:
+      '@types/react': '>=18'
+      react: '>=18'
+
+  react-moveable@0.56.0:
+    resolution: {integrity: sha512-FmJNmIOsOA36mdxbrc/huiE4wuXSRlmon/o+/OrfNhSiYYYL0AV5oObtPluEhb2Yr/7EfYWBHTxF5aWAvjg1SA==}
+
+  react-redux@9.3.0:
+    resolution: {integrity: sha512-KQopgqFo/p/fgmAs5qz6p5RWaNAzq40WAu7fJIXnQpYxFPbJYtsJPWvGeF2rOBaY/kEuV77AVsX8TsQzKm+A/g==}
+    peerDependencies:
+      '@types/react': ^18.2.25 || ^19
+      react: ^18.0 || ^19
+      redux: ^5.0.0
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      redux:
+        optional: true
+
   react-refresh@0.14.2:
     resolution: {integrity: sha512-jCvmsr+1IUSMUyzOkRcvnVbX3ZYC6g9TDrDbFuFmRDq7PD4yaGbLKNQL6k2jnArV8hjYxh7hVhAZB6s9HDGpZA==}
     engines: {node: '>=0.10.0'}
 
+  react-remove-scroll-bar@2.3.8:
+    resolution: {integrity: sha512-9r+yi9+mgU33AKcj6IbT9oRCO78WriSj6t/cF8DWBZJ9aOGPOTEDvdUDz1FwKim7QXWwmHqtdHnRJfhAxEG46Q==}
+    engines: {node: '>=10'}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  react-remove-scroll@2.7.2:
+    resolution: {integrity: sha512-Iqb9NjCCTt6Hf+vOdNIZGdTiH1QSqr27H/Ek9sv/a97gfueI/5h1s3yRi1nngzMUaOOToin5dI1dXKdXiF+u0Q==}
+    engines: {node: '>=10'}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  react-resizable-panels@3.0.6:
+    resolution: {integrity: sha512-b3qKHQ3MLqOgSS+FRYKapNkJZf5EQzuf6+RLiq1/IlTHw99YrZ2NJZLk4hQIzTnnIkRg2LUqyVinu6YWWpUYew==}
+    peerDependencies:
+      react: ^16.14.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc
+      react-dom: ^16.14.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc
+
   react-router-dom@6.30.3:
     resolution: {integrity: sha512-pxPcv1AczD4vso7G4Z3TKcvlxK7g7TNt3/FNGMhfqyntocvYKj+GCatfigGDjbLozC4baguJ0ReCigoDJXb0ag==}
     engines: {node: '>=14.0.0'}
@@ -2741,10 +4480,33 @@ packages:
     peerDependencies:
       react: '>=16.8'
 
+  react-selecto@1.26.3:
+    resolution: {integrity: sha512-Ubik7kWSnZyQEBNro+1k38hZaI1tJarE+5aD/qsqCOA1uUBSjgKVBy3EWRzGIbdmVex7DcxznFZLec/6KZNvwQ==}
+
+  react-style-singleton@2.2.3:
+    resolution: {integrity: sha512-b6jSvxvVnyptAiLjbkWLE/lOnR4lfTtDAl+eUC7RZy+QQWc6wRzIV2CE6xBuMmDxc2qIihtDCZD5NPOFl7fRBQ==}
+    engines: {node: '>=10'}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  react-syntax-highlighter@16.1.1:
+    resolution: {integrity: sha512-PjVawBGy80C6YbC5DDZJeUjBmC7skaoEUdvfFQediQHgCL7aKyVHe57SaJGfQsloGDac+gCpTfRdtxzWWKmCXA==}
+    engines: {node: '>= 16.20.2'}
+    peerDependencies:
+      react: '>= 0.14.0'
+
   react@18.3.1:
     resolution: {integrity: sha512-wS+hAgJShR0KhEvPJArfuPVN1+Hz1t0Y6n5jLrGQbkb4urgPE/0Rve+1kMB1v/oWgHgm4WIcV+i7F2pTVj+2iQ==}
     engines: {node: '>=0.10.0'}
 
+  react@19.2.6:
+    resolution: {integrity: sha512-sfWGGfavi0xr8Pg0sVsyHMAOziVYKgPLNrS7ig+ivMNb3wbCBw3KxtflsGBAwD3gYQlE/AEZsTLgToRrSCjb0Q==}
+    engines: {node: '>=0.10.0'}
+
   read-binary-file-arch@1.0.6:
     resolution: {integrity: sha512-BNg9EN3DD3GsDXX7Aa8O4p92sryjkmzYYgmgTAc6CA4uGLEDzFfxOxugu21akOxpcXHiEgsYkC6nPsQvLLLmEg==}
     hasBin: true
@@ -2760,6 +4522,37 @@ packages:
     resolution: {integrity: sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==}
     engines: {node: '>=8.10.0'}
 
+  recharts@3.8.1:
+    resolution: {integrity: sha512-mwzmO1s9sFL0TduUpwndxCUNoXsBw3u3E/0+A+cLcrSfQitSG62L32N69GhqUrrT5qKcAE3pCGVINC6pqkBBQg==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      react: ^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0
+      react-dom: ^16.0.0 || ^17.0.0 || ^18.0.0 || ^19.0.0
+      react-is: ^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0
+
+  redux-thunk@3.1.0:
+    resolution: {integrity: sha512-NW2r5T6ksUKXCabzhL9z+h206HQw/NJkcLm1GPImRQ8IzfXwRGqjVhKJGauHirT0DAuyy6hjdnMZaRoAcy0Klw==}
+    peerDependencies:
+      redux: ^5.0.0
+
+  redux@5.0.1:
+    resolution: {integrity: sha512-M9/ELqF6fy8FwmkpnF0S3YKOqMyoWJ4+CS5Efg2ct3oY9daQvd/Pc71FpGZsVsbl3Cpb+IIcjBDUnnyBdQbq4w==}
+
+  refractor@5.0.0:
+    resolution: {integrity: sha512-QXOrHQF5jOpjjLfiNk5GFnWhRXvxjUVnlFxkeDmewR5sXkr3iM46Zo+CnRR8B+MDVqkULW4EcLVcRBNOPXHosw==}
+
+  remark-gfm@4.0.1:
+    resolution: {integrity: sha512-1quofZ2RQ9EWdeN34S79+KExV1764+wCUGop5CPL1WGdD0ocPpu91lzPGbwWMECpEpd42kJGQwzRfyov9j4yNg==}
+
+  remark-parse@11.0.0:
+    resolution: {integrity: sha512-FCxlKLNGknS5ba/1lmpYijMUzX2esxW5xQqjWxw2eHFfS2MSdaHVINFmhjo+qN1WhZhNimq0dZATN9pH0IDrpA==}
+
+  remark-rehype@11.1.2:
+    resolution: {integrity: sha512-Dh7l57ianaEoIpzbp0PC9UKAdCSVklD8E5Rpw7ETfbTl3FqcOOgq5q2LVDhgGCkaBv7p24JXikPdvhhmHvKMsw==}
+
+  remark-stringify@11.0.0:
+    resolution: {integrity: sha512-1OSmLd3awB/t8qdoEOMazZkNsfVTeY4fTsgzcQFdXNq8ToTN4ZGwrMnlda4K6smTFKD+GRV6O48i6Z4iKgPPpw==}
+
   require-directory@2.1.1:
     resolution: {integrity: sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==}
     engines: {node: '>=0.10.0'}
@@ -2772,6 +4565,9 @@ packages:
     resolution: {integrity: sha512-vHjcY2MlAITJhC0eRD/Vv8Vlgmu9Sd3LX9zZvtGzU5ZImdTN3+d6e/4mnTyV8vEbyf1sgNIrWxhWlrys52OkEA==}
     engines: {node: '>=12', npm: '>=6'}
 
+  reselect@5.1.1:
+    resolution: {integrity: sha512-K/BG6eIky/SBpzfHZv/dd+9JBFiS4SWV7FIujVyJRux6e45+73RaUHXLmIR1f7WOMaQ0U1km6qwklRQxpJJY0w==}
+
   resolve-alpn@1.2.1:
     resolution: {integrity: sha512-0a1F4l73/ZFZOakJnQ3FvkJ2+gSTQWz/r2KE5OdDY0TxPm5h4GkqkWWfM47T7HsbnOtcJVEF4epCVy6u7Q3K+g==}
 
@@ -2837,6 +4633,12 @@ packages:
   scheduler@0.23.2:
     resolution: {integrity: sha512-UOShsPwz7NrMUqhR6t0hWjFduvOzbtv7toDH1/hIrfRNIDBnnBWd0CwJTGvTpngVlmwGCdP9/Zl/tVrDqcuYzQ==}
 
+  scheduler@0.27.0:
+    resolution: {integrity: sha512-eNv+WrVbKu1f3vbYJT/xtiF5syA5HPIMtf9IgY/nKg0sWqzAUEvqY/xm7OcZc/qafLx/iO9FgOmeSAp4v5ti/Q==}
+
+  selecto@1.26.3:
+    resolution: {integrity: sha512-gZHgqMy5uyB6/2YDjv3Qqaf7bd2hTDOpPdxXlrez4R3/L0GiEWDCFaUfrflomgqdb3SxHF2IXY0Jw0EamZi7cw==}
+
   semver-compare@1.0.0:
     resolution: {integrity: sha512-YM3/ITh2MJ5MtzaM429anh+x2jiLVjqILF4m4oyQB18W7Ggea7BfqdH/wGMK7dDiMghv/6WG7znWMwUDzJiXow==}
 
@@ -2853,8 +4655,8 @@ packages:
     engines: {node: '>=10'}
     hasBin: true
 
-  semver@7.8.0:
-    resolution: {integrity: sha512-AcM7dV/5ul4EekoQ29Agm5vri8JNqRyj39o0qpX6vDF2GZrtutZl5RwgD1XnZjiTAfncsJhMI48QQH3sN87YNA==}
+  semver@7.8.1:
+    resolution: {integrity: sha512-rkVq3IXh+4FDGch+KwzX3aV9W3kO54GyEgpvBzSyctDA6Xtd7RJQV1xmXbeQp5v7+VzLOfVqiutSE6GICgPFvg==}
     engines: {node: '>=10'}
     hasBin: true
 
@@ -2870,9 +4672,16 @@ packages:
     resolution: {integrity: sha512-x0RTqQel6g5SY7Lg6ZreMmsOzncHFU7nhnRWkKgWuMTu5NN0DR5oruckMqRvacAN9d5w6ARnRBXl9xhDCgfMeA==}
     engines: {node: '>= 0.8.0'}
 
+  server-only@0.0.1:
+    resolution: {integrity: sha512-qepMx2JxAa5jjfzxG79yPPq+8BuFToHd1hm7kI+Z4zAq1ftQiP7HcxMhDDItrbtwVeLg/cY2JnKnrcFkmiswNA==}
+
   setprototypeof@1.2.0:
     resolution: {integrity: sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==}
 
+  sharp@0.34.5:
+    resolution: {integrity: sha512-Ou9I5Ft9WNcCbXrU9cMgPBcCK8LiwLqcbywW3t4oDV37n1pzpuNLsYiAV8eODnjbtQlSDwZ2cUEeQz4E54Hltg==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+
   shebang-command@2.0.0:
     resolution: {integrity: sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==}
     engines: {node: '>=8'}
@@ -2938,6 +4747,12 @@ packages:
     resolution: {integrity: sha512-HLpt+uLy/pxB+bum/9DzAgiKS8CX1EvbWxI4zlmgGCExImLdiad2iCwXT5Z4c9c3Eq8rP2318mPW2c+QbtjK8A==}
     engines: {node: '>= 10.0.0', npm: '>= 3.0.0'}
 
+  sonner@2.0.7:
+    resolution: {integrity: sha512-W6ZN4p58k8aDKA4XPcx2hpIQXBRAgyiWVkYhT7CvK6D3iAu7xjvVyhQHg2/iaKJZ1XVJ4r7XuwGL+WGEK37i9w==}
+    peerDependencies:
+      react: ^18.0.0 || ^19.0.0 || ^19.0.0-rc
+      react-dom: ^18.0.0 || ^19.0.0 || ^19.0.0-rc
+
   source-map-js@1.2.1:
     resolution: {integrity: sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==}
     engines: {node: '>=0.10.0'}
@@ -2949,6 +4764,9 @@ packages:
     resolution: {integrity: sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==}
     engines: {node: '>=0.10.0'}
 
+  space-separated-tokens@2.0.2:
+    resolution: {integrity: sha512-PEGlAwrG8yXGXRjW32fGbg66JAlOAwbObuqVoJpv/mRgoWDQfgH1wDPvtzWyUSNAXBGSk8h755YDbbcEy3SH2Q==}
+
   sprintf-js@1.1.3:
     resolution: {integrity: sha512-Oo+0REFV59/rz3gfJNKQiBlwfHaSESl1pcGyABQsnnIfWOFt6JNj5gCog2U6MLZ//IGYD+nA8nI+mTShREReaA==}
 
@@ -2979,6 +4797,9 @@ packages:
   string_decoder@1.3.0:
     resolution: {integrity: sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==}
 
+  stringify-entities@4.0.4:
+    resolution: {integrity: sha512-IwfBptatlO+QCJUo19AqvrPNqlVMpW9YEL2LIVY+Rpv2qsjCGxaDLNRgeGsQWJhfItebuJhsGSLjaBbNSQ+ieg==}
+
   strip-ansi@6.0.1:
     resolution: {integrity: sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==}
     engines: {node: '>=8'}
@@ -2991,6 +4812,25 @@ packages:
     resolution: {integrity: sha512-4gB8na07fecVVkOI6Rs4e7T6NOTki5EmL7TUduTs6bu3EdnSycntVJ4re8kgZA+wx9IueI2Y11bfbgwtzuE0KQ==}
     engines: {node: '>=0.10.0'}
 
+  style-to-js@1.1.21:
+    resolution: {integrity: sha512-RjQetxJrrUJLQPHbLku6U/ocGtzyjbJMP9lCNK7Ag0CNh690nSH8woqWH9u16nMjYBAok+i7JO1NP2pOy8IsPQ==}
+
+  style-to-object@1.0.14:
+    resolution: {integrity: sha512-LIN7rULI0jBscWQYaSswptyderlarFkjQ+t79nzty8tcIAceVomEVlLzH5VP4Cmsv6MtKhs7qaAiwlcp+Mgaxw==}
+
+  styled-jsx@5.1.6:
+    resolution: {integrity: sha512-qSVyDTeMotdvQYoHWLNGwRFJHC+i+ZvdBRYosOFgC+Wg1vx4frN2/RG/NA7SYqqvKNLf39P2LSRA2pu6n0XYZA==}
+    engines: {node: '>= 12.0.0'}
+    peerDependencies:
+      '@babel/core': '*'
+      babel-plugin-macros: '*'
+      react: '>= 16.8.0 || 17.x.x || ^18.0.0-0 || ^19.0.0-0'
+    peerDependenciesMeta:
+      '@babel/core':
+        optional: true
+      babel-plugin-macros:
+        optional: true
+
   sucrase@3.35.1:
     resolution: {integrity: sha512-DhuTmvZWux4H1UOnWMB3sk0sbaCVOoQZjv8u1rDoTV0HTdGem9hkAZtl4JZy8P2z4Bg0nT+YMeOFyVr4zcG5Tw==}
     engines: {node: '>=16 || 14 >=14.17'}
@@ -3017,11 +4857,21 @@ packages:
     peerDependencies:
       express: '>=4.0.0 || >=5.0.0-beta'
 
+  tailwind-merge@3.6.0:
+    resolution: {integrity: sha512-uxL7qAVQriqRQPAyK3pj66VqskWqoZ37PW94jwOTwNfq/z9oyu1V+eqrZqtR2+fCiXdYOZe/Modt8GtvqNzu+w==}
+
   tailwindcss@3.4.17:
     resolution: {integrity: sha512-w33E2aCvSDP0tW9RZuNXadXlkHXqFzSkQew/aIa2i/Sj8fThxwovwlXHSPXTbAHwEIhBFXAedUhP2tueAKP8Og==}
     engines: {node: '>=14.0.0'}
     hasBin: true
 
+  tailwindcss@4.3.0:
+    resolution: {integrity: sha512-y6nxMGB1nMW9R6k96e5gdIFzcfL/gTJRNaqGes1YvkLnPVXzWgbqFF2yLC0T8G774n24cx3Pe8XrKoniCOAH+Q==}
+
+  tapable@2.3.3:
+    resolution: {integrity: sha512-uxc/zpqFg6x7C8vOE7lh6Lbda8eEL9zmVm/PLeTPBRhh1xCgdWaQ+J1CUieGpIfm2HdtsUpRv+HshiasBMcc6A==}
+    engines: {node: '>=6'}
+
   tar-fs@2.1.4:
     resolution: {integrity: sha512-mDAjwmZdh7LTT6pNleZ05Yt65HC3E+NiQzl672vQG38jIrehtJk/J3mNwIg+vShQPcLF/LV7CMnDW6vjj6sfYQ==}
 
@@ -3033,10 +4883,6 @@ packages:
     resolution: {integrity: sha512-ChjMH33/KetonMTAtpYdgUFr0tbz69Fp2v7zWxQfYZX4g5ZN2nOBXm1R2xyA+lMIKrLKIoKAwFj93jE/avX9cQ==}
     engines: {node: '>=18'}
 
-  tar@7.5.15:
-    resolution: {integrity: sha512-dzGK0boVlC4W5QFuQN1EFSl3bIDYsk7Tj40U6eIBnK2k/8ml7TZ5agbI5j5+qnoVcAA+rNtBml8SEiLxZpNqRQ==}
-    engines: {node: '>=18'}
-
   temp-file@3.4.0:
     resolution: {integrity: sha512-C5tjlC/HCtVUOi3KWVokd4vHVViOmGjtLwIh4MuzPo/nMYTV/p1urt3RnMz2IWXDdKEGJH3k5+KPxtqRsUYGtg==}
 
@@ -3054,6 +4900,9 @@ packages:
   tiny-async-pool@1.3.0:
     resolution: {integrity: sha512-01EAw5EDrcVrdgyCLgoSPvqznC0sVxDSVeiOz09FUpjh71G79VCqneOr+xvt7T1r76CF6ZZfPjHorN2+d+3mqA==}
 
+  tiny-invariant@1.3.3:
+    resolution: {integrity: sha512-+FbBPE1o9QAYvviau/qC5SE3caw21q3xkvWKBtja5vgqOWIHHJ3ioaq1VPfn/Szqctz2bU/oYeKd9/z5BL+PVg==}
+
   tiny-typed-emitter@2.1.0:
     resolution: {integrity: sha512-qVtvMxeXbVej0cQWKqVSSAHmKZEHAvxdF8HEUBFWts8h+xEo5m/lEiPakuyZ3BnCBjOD8i24kzNOiOLLgsSxhA==}
 
@@ -3061,10 +4910,6 @@ packages:
     resolution: {integrity: sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==}
     engines: {node: '>=12.0.0'}
 
-  tinyglobby@0.2.16:
-    resolution: {integrity: sha512-pn99VhoACYR8nFHhxqix+uvsbXineAasWm5ojXoN8xEwK5Kd3/TrhNn1wByuD52UxWRLy8pu+kRMniEi6Eq9Zg==}
-    engines: {node: '>=12.0.0'}
-
   tmp-promise@3.0.3:
     resolution: {integrity: sha512-RwM7MoPojPxsOBYnyd2hy0bxtIlVrihNs9pj5SUvY8Zz1sQcQG2tG1hSr8PDxfgEB8RNKDhqbIlroIarSNDNsQ==}
 
@@ -3080,6 +4925,12 @@ packages:
     resolution: {integrity: sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==}
     engines: {node: '>=0.6'}
 
+  trim-lines@3.0.1:
+    resolution: {integrity: sha512-kRj8B+YHZCc9kQYdWfJB2/oUl9rA99qbowYYBtr4ui4mZyAQ2JpvVBd/6U2YloATfqBhBTSMhTpgBHtU0Mf3Rg==}
+
+  trough@2.2.0:
+    resolution: {integrity: sha512-tmMpK00BjZiUyVyvrBK7knerNgmgvcV/KLVyuma/SC+TQN167GrMRciANTz09+k3zW8L8t60jWO1GpfkZdjTaw==}
+
   truncate-utf8-bytes@1.0.2:
     resolution: {integrity: sha512-95Pu1QXQvruGEhv62XCMO3Mm90GscOCClvrIUwCM0PYOXK3kaF3l3sIHxx71ThJfcbM2O5Au6SO3AWCSEfW4mQ==}
 
@@ -3092,6 +4943,9 @@ packages:
   ts-interface-checker@0.1.13:
     resolution: {integrity: sha512-Y/arvbn+rrz3JCKl9C4kVNfTfSm2/mEp5FSz5EsZSANGPSlQrpRI5M4PKF+mJnE52jOO90PnPSc3Ur3bTQw0gA==}
 
+  tslib@2.8.1:
+    resolution: {integrity: sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==}
+
   tsx@4.21.0:
     resolution: {integrity: sha512-5C1sg4USs1lfG0GFb2RLXsdpXqBSEhAaA/0kPL01wxzpMqLILNxIxIOKiILz+cdg/pLnOUxFYOR5yhHU666wbw==}
     engines: {node: '>=18.0.0'}
@@ -3100,6 +4954,9 @@ packages:
   tunnel-agent@0.6.0:
     resolution: {integrity: sha512-McnNiV1l8RYeY8tBgEpuodCC1mLUdbSN+CYBL7kJsJNInOP8UjDDEwdk6Mw60vdLLrr5NHKZhMAOSrR2NZuQ+w==}
 
+  tw-animate-css@1.4.0:
+    resolution: {integrity: sha512-7bziOlRqH0hJx80h/3mbicLW7o8qLsH5+RaLR2t+OHM3D0JlWGODQKQ4cxbK7WlvmUxpcj6Kgu6EKqjrGFe3QQ==}
+
   type-check@0.4.0:
     resolution: {integrity: sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==}
     engines: {node: '>= 0.8.0'}
@@ -3134,6 +4991,9 @@ packages:
   undici-types@6.21.0:
     resolution: {integrity: sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==}
 
+  unified@11.0.5:
+    resolution: {integrity: sha512-xKvGhPWw3k84Qjh8bI3ZeJjqnyadK+GEFtazSfZv/rKeTkTjOJho6mFqh2SM96iIcZokxiOpg78GazTSg8+KHA==}
+
   unique-filename@4.0.0:
     resolution: {integrity: sha512-XSnEewXmQ+veP7xX2dS5Q4yZAvO40cBN2MWkJ7D/6sW4Dg6wYBNwM1Vrnz1FhH5AdeLIlUXRI9e28z1YZi71NQ==}
     engines: {node: ^18.17.0 || >=20.5.0}
@@ -3142,6 +5002,21 @@ packages:
     resolution: {integrity: sha512-9OdaqO5kwqR+1kVgHAhsp5vPNU0hnxRa26rBFNfNgM7M6pNtgzeBn3s/xbyCQL3dcjzOatcef6UUHpB/6MaETg==}
     engines: {node: ^18.17.0 || >=20.5.0}
 
+  unist-util-is@6.0.1:
+    resolution: {integrity: sha512-LsiILbtBETkDz8I9p1dQ0uyRUWuaQzd/cuEeS1hoRSyW5E5XGmTzlwY1OrNzzakGowI9Dr/I8HVaw4hTtnxy8g==}
+
+  unist-util-position@5.0.0:
+    resolution: {integrity: sha512-fucsC7HjXvkB5R3kTCO7kUjRdrS0BJt3M/FPxmHMBOm8JQi2BsHAHFsy27E0EolP8rp0NzXsJ+jNPyDWvOJZPA==}
+
+  unist-util-stringify-position@4.0.0:
+    resolution: {integrity: sha512-0ASV06AAoKCDkS2+xw5RXJywruurpbC4JZSm7nr7MOt1ojAzvyyaO+UxZf18j8FCF6kmzCZKcAgN/yu2gm2XgQ==}
+
+  unist-util-visit-parents@6.0.2:
+    resolution: {integrity: sha512-goh1s1TBrqSqukSc8wrjwWhL0hiJxgA8m4kFxGlQ+8FYQ3C/m11FcTs4YYem7V664AhHVvgoQLk890Ssdsr2IQ==}
+
+  unist-util-visit@5.1.0:
+    resolution: {integrity: sha512-m+vIdyeCOpdr/QeQCu2EzxX/ohgS8KbnPDgFni4dQsfSCtpz8UqDyY5GjRru8PDKuYn7Fq19j1CQ+nJSsGKOzg==}
+
   universalify@0.1.2:
     resolution: {integrity: sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg==}
     engines: {node: '>= 4.0.0'}
@@ -3163,6 +5038,26 @@ packages:
   uri-js@4.4.1:
     resolution: {integrity: sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==}
 
+  use-callback-ref@1.3.3:
+    resolution: {integrity: sha512-jQL3lRnocaFtu3V00JToYz/4QkNWswxijDaCVNZRiRTO3HQDLsdu1ZtmIUvV4yPp+rvWm5j0y0TG/S61cuijTg==}
+    engines: {node: '>=10'}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  use-sidecar@1.1.3:
+    resolution: {integrity: sha512-Fedw0aZvkhynoPYlA5WXrMCAMm+nSWdZt6lzJQ7Ok8S6Q+VsHmHpRWndVRJ8Be0ZbkfPc5LRYH+5XrzXcEeLRQ==}
+    engines: {node: '>=10'}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
   use-sync-external-store@1.6.0:
     resolution: {integrity: sha512-Pp6GSwGP/NrPIrxVFAIkOQeyw8lFenOHijQWkUTrDvrF4ALqylP2C/KCkeS9dpUM3KvYRQhna5vt7IL95+ZQ9w==}
     peerDependencies:
@@ -3186,10 +5081,25 @@ packages:
     resolution: {integrity: sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==}
     engines: {node: '>= 0.8'}
 
+  vaul@1.1.2:
+    resolution: {integrity: sha512-ZFkClGpWyI2WUQjdLJ/BaGuV6AVQiJ3uELGk3OYtP+B6yCO7Cmn9vPFXVJkRaGkOJu3m8bQMgtyzNHixULceQA==}
+    peerDependencies:
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0.0 || ^19.0.0-rc
+
   verror@1.10.1:
     resolution: {integrity: sha512-veufcmxri4e3XSrT0xwfUR7kguIkaxBeosDg00yDWhk49wdwkSUrvvsm7nc75e1PUyvIeZj6nS8VQRYz2/S4Xg==}
     engines: {node: '>=0.6.0'}
 
+  vfile-message@4.0.3:
+    resolution: {integrity: sha512-QTHzsGd1EhbZs4AsQ20JX1rC3cOlt/IWJruk893DfLRr57lcnOeMaWG4K0JrRta4mIJZKth2Au3mM3u03/JWKw==}
+
+  vfile@6.0.3:
+    resolution: {integrity: sha512-KzIbH/9tXat2u30jf+smMwFCsno4wHVdNmzFyL+T/L3UGqqk6JKfVqOFOZEpZSHADH1k40ab6NUIXZq422ov3Q==}
+
+  victory-vendor@37.3.6:
+    resolution: {integrity: sha512-SbPDPdDBYp+5MJHhBCAyI7wKM3d5ivekigc2Dk2s7pgbZ9wIgIBYGVw4zGHBml/qTFbexrofXW6Gu4noGxrOwQ==}
+
   vite@6.1.0:
     resolution: {integrity: sha512-RjjMipCKVoR4hVfPY6GQTgveinjNuyLw+qruksLDvA5ktI1150VmcMBKmQaEWJhg/j6Uaf6dNCNA0AfdzUb/hQ==}
     engines: {node: ^18.0.0 || ^20.0.0 || >=22.0.0}
@@ -3279,18 +5189,6 @@ packages:
       utf-8-validate:
         optional: true
 
-  ws@8.20.1:
-    resolution: {integrity: sha512-It4dO0K5v//JtTXuPkfEOaI3uUN87iYPnqo/ZzqCoG3g8uhA66QUMs/SrM0YK7/NAu+r4LMh/9dq2A7k+rHs+w==}
-    engines: {node: '>=10.0.0'}
-    peerDependencies:
-      bufferutil: ^4.0.1
-      utf-8-validate: '>=5.0.2'
-    peerDependenciesMeta:
-      bufferutil:
-        optional: true
-      utf-8-validate:
-        optional: true
-
   xmlbuilder@15.1.1:
     resolution: {integrity: sha512-yMqGBqtXyeN1e3TGYvgNgDVZ3j84W4cwkOXQswghol6APgZWaff9lnbvN7MHYJOiXsvGPXtjTYJEiC9J2wv9Eg==}
     engines: {node: '>=8.0'}
@@ -3336,6 +5234,9 @@ packages:
   zod@4.3.6:
     resolution: {integrity: sha512-rftlrkhHZOcjDwkGlnUtZZkvaPHCsDATp4pGpuOOMDaTdDDXF91wuVDJoWoPsKX/3YPQ5fHuF3STjcYyKr+Qhg==}
 
+  zwitch@2.0.4:
+    resolution: {integrity: sha512-bXE4cR/kVZhKZX/RjPEflHaKVhUVl85noU3v6b8apfQEc1x4A+zBxjZ4lN8LqGd6WZ3dl98pY4o717VFmoPp+A==}
+
 snapshots:
 
   7zip-bin@5.2.0: {}
@@ -3431,7 +5332,7 @@ snapshots:
       '@babel/core': 7.29.0
       '@babel/helper-plugin-utils': 7.28.6
 
-  '@babel/runtime@7.29.2': {}
+  '@babel/runtime@7.29.7': {}
 
   '@babel/template@7.28.6':
     dependencies:
@@ -3456,15 +5357,74 @@ snapshots:
       '@babel/helper-string-parser': 7.27.1
       '@babel/helper-validator-identifier': 7.28.5
 
-  '@closedloop-ai/loops-api@0.2.11(zod@4.3.6)':
+  '@cfcs/core@0.0.6':
+    dependencies:
+      '@egjs/component': 3.0.5
+
+  '@closedloop-ai/design-system@0.1.1-dev.26892521643.1(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(next-themes@0.4.6(react-dom@19.2.6(react@19.2.6))(react@19.2.6))(next@16.2.6(@babel/core@7.29.0)(@playwright/test@1.60.0)(react-dom@19.2.6(react@19.2.6))(react@19.2.6))(react-day-picker@9.14.0(react@19.2.6))(react-dom@19.2.6(react@19.2.6))(react-hook-form@7.76.1(react@19.2.6))(react-is@19.2.6)(react-resizable-panels@3.0.6(react-dom@19.2.6(react@19.2.6))(react@19.2.6))(react@19.2.6)(redux@5.0.1)':
+    dependencies:
+      '@closedloop-ai/loops-api': 0.3.1(zod@4.3.6)
+      '@hookform/resolvers': 5.4.0(react-hook-form@7.76.1(react@19.2.6))
+      '@radix-ui/react-icons': 1.3.2(react@19.2.6)
+      class-variance-authority: 0.7.1
+      clsx: 2.1.1
+      cmdk: 1.1.1(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      d3: 7.9.0
+      d3-sankey: 0.12.3
+      date-fns: 4.3.0
+      embla-carousel-react: 8.6.0(react@19.2.6)
+      geist: 1.7.1(next@16.2.6(@babel/core@7.29.0)(@playwright/test@1.60.0)(react-dom@19.2.6(react@19.2.6))(react@19.2.6))
+      input-otp: 1.4.2(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      lucide-react: 0.556.0(react@19.2.6)
+      next-themes: 0.4.6(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      radix-ui: 1.4.3(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      react: 19.2.6
+      react-day-picker: 9.14.0(react@19.2.6)
+      react-hook-form: 7.76.1(react@19.2.6)
+      react-markdown: 10.1.0(@types/react@19.2.15)(react@19.2.6)
+      react-moveable: 0.56.0
+      react-resizable-panels: 3.0.6(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      react-syntax-highlighter: 16.1.1(react@19.2.6)
+      recharts: 3.8.1(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react-is@19.2.6)(react@19.2.6)(redux@5.0.1)
+      remark-gfm: 4.0.1
+      server-only: 0.0.1
+      sonner: 2.0.7(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      tailwind-merge: 3.6.0
+      tw-animate-css: 1.4.0
+      vaul: 1.1.2(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      zod: 4.3.6
+    transitivePeerDependencies:
+      - '@types/react'
+      - '@types/react-dom'
+      - next
+      - react-dom
+      - react-is
+      - redux
+      - supports-color
+
+  '@closedloop-ai/loops-api@0.3.1(zod@4.3.6)':
     dependencies:
       zod: 4.3.6
 
+  '@date-fns/tz@1.5.0': {}
+
+  '@daybrush/utils@1.13.0': {}
+
   '@develar/schema-utils@2.6.5':
     dependencies:
       ajv: 6.14.0
       ajv-keywords: 3.5.2(ajv@6.14.0)
 
+  '@egjs/agent@2.4.4': {}
+
+  '@egjs/children-differ@1.0.1':
+    dependencies:
+      '@egjs/list-differ': 1.0.1
+
+  '@egjs/component@3.0.5': {}
+
+  '@egjs/list-differ@1.0.1': {}
+
   '@electron/asar@3.4.1':
     dependencies:
       commander: 5.1.0
@@ -3565,6 +5525,11 @@ snapshots:
       - supports-color
     optional: true
 
+  '@emnapi/runtime@1.10.0':
+    dependencies:
+      tslib: 2.8.1
+    optional: true
+
   '@esbuild/aix-ppc64@0.24.2':
     optional: true
 
@@ -3743,21 +5708,140 @@ snapshots:
 
   '@eslint/object-schema@3.0.3': {}
 
-  '@eslint/plugin-kit@0.6.1':
-    dependencies:
-      '@eslint/core': 1.1.1
-      levn: 0.4.1
+  '@eslint/plugin-kit@0.6.1':
+    dependencies:
+      '@eslint/core': 1.1.1
+      levn: 0.4.1
+
+  '@floating-ui/core@1.7.5':
+    dependencies:
+      '@floating-ui/utils': 0.2.11
+
+  '@floating-ui/dom@1.7.6':
+    dependencies:
+      '@floating-ui/core': 1.7.5
+      '@floating-ui/utils': 0.2.11
+
+  '@floating-ui/react-dom@2.1.8(react-dom@19.2.6(react@19.2.6))(react@19.2.6)':
+    dependencies:
+      '@floating-ui/dom': 1.7.6
+      react: 19.2.6
+      react-dom: 19.2.6(react@19.2.6)
+
+  '@floating-ui/utils@0.2.11': {}
+
+  '@hookform/resolvers@5.4.0(react-hook-form@7.76.1(react@19.2.6))':
+    dependencies:
+      '@standard-schema/utils': 0.3.0
+      react-hook-form: 7.76.1(react@19.2.6)
+
+  '@humanfs/core@0.19.1': {}
+
+  '@humanfs/node@0.16.7':
+    dependencies:
+      '@humanfs/core': 0.19.1
+      '@humanwhocodes/retry': 0.4.3
+
+  '@humanwhocodes/module-importer@1.0.1': {}
+
+  '@humanwhocodes/retry@0.4.3': {}
+
+  '@img/colour@1.1.0':
+    optional: true
+
+  '@img/sharp-darwin-arm64@0.34.5':
+    optionalDependencies:
+      '@img/sharp-libvips-darwin-arm64': 1.2.4
+    optional: true
+
+  '@img/sharp-darwin-x64@0.34.5':
+    optionalDependencies:
+      '@img/sharp-libvips-darwin-x64': 1.2.4
+    optional: true
+
+  '@img/sharp-libvips-darwin-arm64@1.2.4':
+    optional: true
+
+  '@img/sharp-libvips-darwin-x64@1.2.4':
+    optional: true
+
+  '@img/sharp-libvips-linux-arm64@1.2.4':
+    optional: true
+
+  '@img/sharp-libvips-linux-arm@1.2.4':
+    optional: true
+
+  '@img/sharp-libvips-linux-ppc64@1.2.4':
+    optional: true
+
+  '@img/sharp-libvips-linux-riscv64@1.2.4':
+    optional: true
+
+  '@img/sharp-libvips-linux-s390x@1.2.4':
+    optional: true
+
+  '@img/sharp-libvips-linux-x64@1.2.4':
+    optional: true
+
+  '@img/sharp-libvips-linuxmusl-arm64@1.2.4':
+    optional: true
+
+  '@img/sharp-libvips-linuxmusl-x64@1.2.4':
+    optional: true
+
+  '@img/sharp-linux-arm64@0.34.5':
+    optionalDependencies:
+      '@img/sharp-libvips-linux-arm64': 1.2.4
+    optional: true
+
+  '@img/sharp-linux-arm@0.34.5':
+    optionalDependencies:
+      '@img/sharp-libvips-linux-arm': 1.2.4
+    optional: true
+
+  '@img/sharp-linux-ppc64@0.34.5':
+    optionalDependencies:
+      '@img/sharp-libvips-linux-ppc64': 1.2.4
+    optional: true
+
+  '@img/sharp-linux-riscv64@0.34.5':
+    optionalDependencies:
+      '@img/sharp-libvips-linux-riscv64': 1.2.4
+    optional: true
+
+  '@img/sharp-linux-s390x@0.34.5':
+    optionalDependencies:
+      '@img/sharp-libvips-linux-s390x': 1.2.4
+    optional: true
+
+  '@img/sharp-linux-x64@0.34.5':
+    optionalDependencies:
+      '@img/sharp-libvips-linux-x64': 1.2.4
+    optional: true
+
+  '@img/sharp-linuxmusl-arm64@0.34.5':
+    optionalDependencies:
+      '@img/sharp-libvips-linuxmusl-arm64': 1.2.4
+    optional: true
 
-  '@humanfs/core@0.19.1': {}
+  '@img/sharp-linuxmusl-x64@0.34.5':
+    optionalDependencies:
+      '@img/sharp-libvips-linuxmusl-x64': 1.2.4
+    optional: true
 
-  '@humanfs/node@0.16.7':
+  '@img/sharp-wasm32@0.34.5':
     dependencies:
-      '@humanfs/core': 0.19.1
-      '@humanwhocodes/retry': 0.4.3
+      '@emnapi/runtime': 1.10.0
+    optional: true
 
-  '@humanwhocodes/module-importer@1.0.1': {}
+  '@img/sharp-win32-arm64@0.34.5':
+    optional: true
 
-  '@humanwhocodes/retry@0.4.3': {}
+  '@img/sharp-win32-ia32@0.34.5':
+    optional: true
+
+  '@img/sharp-win32-x64@0.34.5':
+    optional: true
 
   '@isaacs/cliui@8.0.2':
     dependencies:
@@ -3806,6 +5890,32 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
+  '@next/env@16.2.6': {}
+
+  '@next/swc-darwin-arm64@16.2.6':
+    optional: true
+
+  '@next/swc-darwin-x64@16.2.6':
+    optional: true
+
+  '@next/swc-linux-arm64-gnu@16.2.6':
+    optional: true
+
+  '@next/swc-linux-arm64-musl@16.2.6':
+    optional: true
+
+  '@next/swc-linux-x64-gnu@16.2.6':
+    optional: true
+
+  '@next/swc-linux-x64-musl@16.2.6':
+    optional: true
+
+  '@next/swc-win32-arm64-msvc@16.2.6':
+    optional: true
+
+  '@next/swc-win32-x64-msvc@16.2.6':
+    optional: true
+
   '@nodelib/fs.scandir@2.1.5':
     dependencies:
       '@nodelib/fs.stat': 2.0.5
@@ -3843,6 +5953,785 @@ snapshots:
     dependencies:
       yargs: 17.7.2
 
+  '@radix-ui/number@1.1.1': {}
+
+  '@radix-ui/primitive@1.1.3': {}
+
+  '@radix-ui/react-accessible-icon@1.1.7(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)':
+    dependencies:
+      '@radix-ui/react-visually-hidden': 1.2.3(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      react: 19.2.6
+      react-dom: 19.2.6(react@19.2.6)
+    optionalDependencies:
+      '@types/react': 19.2.15
+      '@types/react-dom': 19.2.3(@types/react@19.2.15)
+
+  '@radix-ui/react-accordion@1.2.12(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-collapsible': 1.1.12(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-collection': 1.1.7(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-direction': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-id': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-use-controllable-state': 1.2.2(@types/react@19.2.15)(react@19.2.6)
+      react: 19.2.6
+      react-dom: 19.2.6(react@19.2.6)
+    optionalDependencies:
+      '@types/react': 19.2.15
+      '@types/react-dom': 19.2.3(@types/react@19.2.15)
+
+  '@radix-ui/react-alert-dialog@1.1.15(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-dialog': 1.1.15(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-slot': 1.2.3(@types/react@19.2.15)(react@19.2.6)
+      react: 19.2.6
+      react-dom: 19.2.6(react@19.2.6)
+    optionalDependencies:
+      '@types/react': 19.2.15
+      '@types/react-dom': 19.2.3(@types/react@19.2.15)
+
+  '@radix-ui/react-arrow@1.1.7(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)':
+    dependencies:
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      react: 19.2.6
+      react-dom: 19.2.6(react@19.2.6)
+    optionalDependencies:
+      '@types/react': 19.2.15
+      '@types/react-dom': 19.2.3(@types/react@19.2.15)
+
+  '@radix-ui/react-aspect-ratio@1.1.7(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)':
+    dependencies:
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      react: 19.2.6
+      react-dom: 19.2.6(react@19.2.6)
+    optionalDependencies:
+      '@types/react': 19.2.15
+      '@types/react-dom': 19.2.3(@types/react@19.2.15)
+
+  '@radix-ui/react-avatar@1.1.10(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)':
+    dependencies:
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-use-callback-ref': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-use-is-hydrated': 0.1.0(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-use-layout-effect': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      react: 19.2.6
+      react-dom: 19.2.6(react@19.2.6)
+    optionalDependencies:
+      '@types/react': 19.2.15
+      '@types/react-dom': 19.2.3(@types/react@19.2.15)
+
+  '@radix-ui/react-checkbox@1.3.3(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-presence': 1.1.5(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-use-controllable-state': 1.2.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-use-previous': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-use-size': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      react: 19.2.6
+      react-dom: 19.2.6(react@19.2.6)
+    optionalDependencies:
+      '@types/react': 19.2.15
+      '@types/react-dom': 19.2.3(@types/react@19.2.15)
+
+  '@radix-ui/react-collapsible@1.1.12(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-id': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-presence': 1.1.5(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-use-controllable-state': 1.2.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-use-layout-effect': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      react: 19.2.6
+      react-dom: 19.2.6(react@19.2.6)
+    optionalDependencies:
+      '@types/react': 19.2.15
+      '@types/react-dom': 19.2.3(@types/react@19.2.15)
+
+  '@radix-ui/react-collection@1.1.7(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)':
+    dependencies:
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-slot': 1.2.3(@types/react@19.2.15)(react@19.2.6)
+      react: 19.2.6
+      react-dom: 19.2.6(react@19.2.6)
+    optionalDependencies:
+      '@types/react': 19.2.15
+      '@types/react-dom': 19.2.3(@types/react@19.2.15)
+
+  '@radix-ui/react-compose-refs@1.1.2(@types/react@19.2.15)(react@19.2.6)':
+    dependencies:
+      react: 19.2.6
+    optionalDependencies:
+      '@types/react': 19.2.15
+
+  '@radix-ui/react-context-menu@2.2.16(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-menu': 2.1.16(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-use-callback-ref': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-use-controllable-state': 1.2.2(@types/react@19.2.15)(react@19.2.6)
+      react: 19.2.6
+      react-dom: 19.2.6(react@19.2.6)
+    optionalDependencies:
+      '@types/react': 19.2.15
+      '@types/react-dom': 19.2.3(@types/react@19.2.15)
+
+  '@radix-ui/react-context@1.1.2(@types/react@19.2.15)(react@19.2.6)':
+    dependencies:
+      react: 19.2.6
+    optionalDependencies:
+      '@types/react': 19.2.15
+
+  '@radix-ui/react-dialog@1.1.15(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-dismissable-layer': 1.1.11(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-focus-guards': 1.1.3(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-focus-scope': 1.1.7(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-id': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-portal': 1.1.9(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-presence': 1.1.5(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-slot': 1.2.3(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-use-controllable-state': 1.2.2(@types/react@19.2.15)(react@19.2.6)
+      aria-hidden: 1.2.6
+      react: 19.2.6
+      react-dom: 19.2.6(react@19.2.6)
+      react-remove-scroll: 2.7.2(@types/react@19.2.15)(react@19.2.6)
+    optionalDependencies:
+      '@types/react': 19.2.15
+      '@types/react-dom': 19.2.3(@types/react@19.2.15)
+
+  '@radix-ui/react-direction@1.1.1(@types/react@19.2.15)(react@19.2.6)':
+    dependencies:
+      react: 19.2.6
+    optionalDependencies:
+      '@types/react': 19.2.15
+
+  '@radix-ui/react-dismissable-layer@1.1.11(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-use-callback-ref': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-use-escape-keydown': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      react: 19.2.6
+      react-dom: 19.2.6(react@19.2.6)
+    optionalDependencies:
+      '@types/react': 19.2.15
+      '@types/react-dom': 19.2.3(@types/react@19.2.15)
+
+  '@radix-ui/react-dropdown-menu@2.1.16(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-id': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-menu': 2.1.16(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-use-controllable-state': 1.2.2(@types/react@19.2.15)(react@19.2.6)
+      react: 19.2.6
+      react-dom: 19.2.6(react@19.2.6)
+    optionalDependencies:
+      '@types/react': 19.2.15
+      '@types/react-dom': 19.2.3(@types/react@19.2.15)
+
+  '@radix-ui/react-focus-guards@1.1.3(@types/react@19.2.15)(react@19.2.6)':
+    dependencies:
+      react: 19.2.6
+    optionalDependencies:
+      '@types/react': 19.2.15
+
+  '@radix-ui/react-focus-scope@1.1.7(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)':
+    dependencies:
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-use-callback-ref': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      react: 19.2.6
+      react-dom: 19.2.6(react@19.2.6)
+    optionalDependencies:
+      '@types/react': 19.2.15
+      '@types/react-dom': 19.2.3(@types/react@19.2.15)
+
+  '@radix-ui/react-form@0.1.8(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-id': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-label': 2.1.7(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      react: 19.2.6
+      react-dom: 19.2.6(react@19.2.6)
+    optionalDependencies:
+      '@types/react': 19.2.15
+      '@types/react-dom': 19.2.3(@types/react@19.2.15)
+
+  '@radix-ui/react-hover-card@1.1.15(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-dismissable-layer': 1.1.11(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-popper': 1.2.8(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-portal': 1.1.9(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-presence': 1.1.5(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-use-controllable-state': 1.2.2(@types/react@19.2.15)(react@19.2.6)
+      react: 19.2.6
+      react-dom: 19.2.6(react@19.2.6)
+    optionalDependencies:
+      '@types/react': 19.2.15
+      '@types/react-dom': 19.2.3(@types/react@19.2.15)
+
+  '@radix-ui/react-icons@1.3.2(react@19.2.6)':
+    dependencies:
+      react: 19.2.6
+
+  '@radix-ui/react-id@1.1.1(@types/react@19.2.15)(react@19.2.6)':
+    dependencies:
+      '@radix-ui/react-use-layout-effect': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      react: 19.2.6
+    optionalDependencies:
+      '@types/react': 19.2.15
+
+  '@radix-ui/react-label@2.1.7(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)':
+    dependencies:
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      react: 19.2.6
+      react-dom: 19.2.6(react@19.2.6)
+    optionalDependencies:
+      '@types/react': 19.2.15
+      '@types/react-dom': 19.2.3(@types/react@19.2.15)
+
+  '@radix-ui/react-menu@2.1.16(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-collection': 1.1.7(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-direction': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-dismissable-layer': 1.1.11(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-focus-guards': 1.1.3(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-focus-scope': 1.1.7(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-id': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-popper': 1.2.8(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-portal': 1.1.9(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-presence': 1.1.5(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-roving-focus': 1.1.11(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-slot': 1.2.3(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-use-callback-ref': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      aria-hidden: 1.2.6
+      react: 19.2.6
+      react-dom: 19.2.6(react@19.2.6)
+      react-remove-scroll: 2.7.2(@types/react@19.2.15)(react@19.2.6)
+    optionalDependencies:
+      '@types/react': 19.2.15
+      '@types/react-dom': 19.2.3(@types/react@19.2.15)
+
+  '@radix-ui/react-menubar@1.1.16(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-collection': 1.1.7(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-direction': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-id': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-menu': 2.1.16(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-roving-focus': 1.1.11(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-use-controllable-state': 1.2.2(@types/react@19.2.15)(react@19.2.6)
+      react: 19.2.6
+      react-dom: 19.2.6(react@19.2.6)
+    optionalDependencies:
+      '@types/react': 19.2.15
+      '@types/react-dom': 19.2.3(@types/react@19.2.15)
+
+  '@radix-ui/react-navigation-menu@1.2.14(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-collection': 1.1.7(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-direction': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-dismissable-layer': 1.1.11(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-id': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-presence': 1.1.5(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-use-callback-ref': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-use-controllable-state': 1.2.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-use-layout-effect': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-use-previous': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-visually-hidden': 1.2.3(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      react: 19.2.6
+      react-dom: 19.2.6(react@19.2.6)
+    optionalDependencies:
+      '@types/react': 19.2.15
+      '@types/react-dom': 19.2.3(@types/react@19.2.15)
+
+  '@radix-ui/react-one-time-password-field@0.1.8(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)':
+    dependencies:
+      '@radix-ui/number': 1.1.1
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-collection': 1.1.7(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-direction': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-roving-focus': 1.1.11(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-use-controllable-state': 1.2.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-use-effect-event': 0.0.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-use-is-hydrated': 0.1.0(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-use-layout-effect': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      react: 19.2.6
+      react-dom: 19.2.6(react@19.2.6)
+    optionalDependencies:
+      '@types/react': 19.2.15
+      '@types/react-dom': 19.2.3(@types/react@19.2.15)
+
+  '@radix-ui/react-password-toggle-field@0.1.3(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-id': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-use-controllable-state': 1.2.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-use-effect-event': 0.0.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-use-is-hydrated': 0.1.0(@types/react@19.2.15)(react@19.2.6)
+      react: 19.2.6
+      react-dom: 19.2.6(react@19.2.6)
+    optionalDependencies:
+      '@types/react': 19.2.15
+      '@types/react-dom': 19.2.3(@types/react@19.2.15)
+
+  '@radix-ui/react-popover@1.1.15(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-dismissable-layer': 1.1.11(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-focus-guards': 1.1.3(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-focus-scope': 1.1.7(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-id': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-popper': 1.2.8(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-portal': 1.1.9(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-presence': 1.1.5(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-slot': 1.2.3(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-use-controllable-state': 1.2.2(@types/react@19.2.15)(react@19.2.6)
+      aria-hidden: 1.2.6
+      react: 19.2.6
+      react-dom: 19.2.6(react@19.2.6)
+      react-remove-scroll: 2.7.2(@types/react@19.2.15)(react@19.2.6)
+    optionalDependencies:
+      '@types/react': 19.2.15
+      '@types/react-dom': 19.2.3(@types/react@19.2.15)
+
+  '@radix-ui/react-popper@1.2.8(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)':
+    dependencies:
+      '@floating-ui/react-dom': 2.1.8(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-arrow': 1.1.7(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-use-callback-ref': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-use-layout-effect': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-use-rect': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-use-size': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/rect': 1.1.1
+      react: 19.2.6
+      react-dom: 19.2.6(react@19.2.6)
+    optionalDependencies:
+      '@types/react': 19.2.15
+      '@types/react-dom': 19.2.3(@types/react@19.2.15)
+
+  '@radix-ui/react-portal@1.1.9(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)':
+    dependencies:
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-use-layout-effect': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      react: 19.2.6
+      react-dom: 19.2.6(react@19.2.6)
+    optionalDependencies:
+      '@types/react': 19.2.15
+      '@types/react-dom': 19.2.3(@types/react@19.2.15)
+
+  '@radix-ui/react-presence@1.1.5(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)':
+    dependencies:
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-use-layout-effect': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      react: 19.2.6
+      react-dom: 19.2.6(react@19.2.6)
+    optionalDependencies:
+      '@types/react': 19.2.15
+      '@types/react-dom': 19.2.3(@types/react@19.2.15)
+
+  '@radix-ui/react-primitive@2.1.3(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)':
+    dependencies:
+      '@radix-ui/react-slot': 1.2.3(@types/react@19.2.15)(react@19.2.6)
+      react: 19.2.6
+      react-dom: 19.2.6(react@19.2.6)
+    optionalDependencies:
+      '@types/react': 19.2.15
+      '@types/react-dom': 19.2.3(@types/react@19.2.15)
+
+  '@radix-ui/react-primitive@2.1.4(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)':
+    dependencies:
+      '@radix-ui/react-slot': 1.2.4(@types/react@19.2.15)(react@19.2.6)
+      react: 19.2.6
+      react-dom: 19.2.6(react@19.2.6)
+    optionalDependencies:
+      '@types/react': 19.2.15
+      '@types/react-dom': 19.2.3(@types/react@19.2.15)
+
+  '@radix-ui/react-progress@1.1.7(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)':
+    dependencies:
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      react: 19.2.6
+      react-dom: 19.2.6(react@19.2.6)
+    optionalDependencies:
+      '@types/react': 19.2.15
+      '@types/react-dom': 19.2.3(@types/react@19.2.15)
+
+  '@radix-ui/react-radio-group@1.3.8(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-direction': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-presence': 1.1.5(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-roving-focus': 1.1.11(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-use-controllable-state': 1.2.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-use-previous': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-use-size': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      react: 19.2.6
+      react-dom: 19.2.6(react@19.2.6)
+    optionalDependencies:
+      '@types/react': 19.2.15
+      '@types/react-dom': 19.2.3(@types/react@19.2.15)
+
+  '@radix-ui/react-roving-focus@1.1.11(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-collection': 1.1.7(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-direction': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-id': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-use-callback-ref': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-use-controllable-state': 1.2.2(@types/react@19.2.15)(react@19.2.6)
+      react: 19.2.6
+      react-dom: 19.2.6(react@19.2.6)
+    optionalDependencies:
+      '@types/react': 19.2.15
+      '@types/react-dom': 19.2.3(@types/react@19.2.15)
+
+  '@radix-ui/react-scroll-area@1.2.10(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)':
+    dependencies:
+      '@radix-ui/number': 1.1.1
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-direction': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-presence': 1.1.5(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-use-callback-ref': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-use-layout-effect': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      react: 19.2.6
+      react-dom: 19.2.6(react@19.2.6)
+    optionalDependencies:
+      '@types/react': 19.2.15
+      '@types/react-dom': 19.2.3(@types/react@19.2.15)
+
+  '@radix-ui/react-select@2.2.6(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)':
+    dependencies:
+      '@radix-ui/number': 1.1.1
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-collection': 1.1.7(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-direction': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-dismissable-layer': 1.1.11(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-focus-guards': 1.1.3(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-focus-scope': 1.1.7(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-id': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-popper': 1.2.8(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-portal': 1.1.9(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-slot': 1.2.3(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-use-callback-ref': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-use-controllable-state': 1.2.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-use-layout-effect': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-use-previous': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-visually-hidden': 1.2.3(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      aria-hidden: 1.2.6
+      react: 19.2.6
+      react-dom: 19.2.6(react@19.2.6)
+      react-remove-scroll: 2.7.2(@types/react@19.2.15)(react@19.2.6)
+    optionalDependencies:
+      '@types/react': 19.2.15
+      '@types/react-dom': 19.2.3(@types/react@19.2.15)
+
+  '@radix-ui/react-separator@1.1.7(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)':
+    dependencies:
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      react: 19.2.6
+      react-dom: 19.2.6(react@19.2.6)
+    optionalDependencies:
+      '@types/react': 19.2.15
+      '@types/react-dom': 19.2.3(@types/react@19.2.15)
+
+  '@radix-ui/react-slider@1.3.6(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)':
+    dependencies:
+      '@radix-ui/number': 1.1.1
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-collection': 1.1.7(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-direction': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-use-controllable-state': 1.2.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-use-layout-effect': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-use-previous': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-use-size': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      react: 19.2.6
+      react-dom: 19.2.6(react@19.2.6)
+    optionalDependencies:
+      '@types/react': 19.2.15
+      '@types/react-dom': 19.2.3(@types/react@19.2.15)
+
+  '@radix-ui/react-slot@1.2.3(@types/react@19.2.15)(react@19.2.6)':
+    dependencies:
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.15)(react@19.2.6)
+      react: 19.2.6
+    optionalDependencies:
+      '@types/react': 19.2.15
+
+  '@radix-ui/react-slot@1.2.4(@types/react@19.2.15)(react@19.2.6)':
+    dependencies:
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.15)(react@19.2.6)
+      react: 19.2.6
+    optionalDependencies:
+      '@types/react': 19.2.15
+
+  '@radix-ui/react-switch@1.2.6(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-use-controllable-state': 1.2.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-use-previous': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-use-size': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      react: 19.2.6
+      react-dom: 19.2.6(react@19.2.6)
+    optionalDependencies:
+      '@types/react': 19.2.15
+      '@types/react-dom': 19.2.3(@types/react@19.2.15)
+
+  '@radix-ui/react-tabs@1.1.13(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-direction': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-id': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-presence': 1.1.5(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-roving-focus': 1.1.11(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-use-controllable-state': 1.2.2(@types/react@19.2.15)(react@19.2.6)
+      react: 19.2.6
+      react-dom: 19.2.6(react@19.2.6)
+    optionalDependencies:
+      '@types/react': 19.2.15
+      '@types/react-dom': 19.2.3(@types/react@19.2.15)
+
+  '@radix-ui/react-toast@1.2.15(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-collection': 1.1.7(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-dismissable-layer': 1.1.11(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-portal': 1.1.9(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-presence': 1.1.5(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-use-callback-ref': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-use-controllable-state': 1.2.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-use-layout-effect': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-visually-hidden': 1.2.3(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      react: 19.2.6
+      react-dom: 19.2.6(react@19.2.6)
+    optionalDependencies:
+      '@types/react': 19.2.15
+      '@types/react-dom': 19.2.3(@types/react@19.2.15)
+
+  '@radix-ui/react-toggle-group@1.1.11(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-direction': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-roving-focus': 1.1.11(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-toggle': 1.1.10(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-use-controllable-state': 1.2.2(@types/react@19.2.15)(react@19.2.6)
+      react: 19.2.6
+      react-dom: 19.2.6(react@19.2.6)
+    optionalDependencies:
+      '@types/react': 19.2.15
+      '@types/react-dom': 19.2.3(@types/react@19.2.15)
+
+  '@radix-ui/react-toggle@1.1.10(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-use-controllable-state': 1.2.2(@types/react@19.2.15)(react@19.2.6)
+      react: 19.2.6
+      react-dom: 19.2.6(react@19.2.6)
+    optionalDependencies:
+      '@types/react': 19.2.15
+      '@types/react-dom': 19.2.3(@types/react@19.2.15)
+
+  '@radix-ui/react-toolbar@1.1.11(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-direction': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-roving-focus': 1.1.11(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-separator': 1.1.7(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-toggle-group': 1.1.11(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      react: 19.2.6
+      react-dom: 19.2.6(react@19.2.6)
+    optionalDependencies:
+      '@types/react': 19.2.15
+      '@types/react-dom': 19.2.3(@types/react@19.2.15)
+
+  '@radix-ui/react-tooltip@1.2.8(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-dismissable-layer': 1.1.11(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-id': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-popper': 1.2.8(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-portal': 1.1.9(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-presence': 1.1.5(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-slot': 1.2.3(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-use-controllable-state': 1.2.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-visually-hidden': 1.2.3(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      react: 19.2.6
+      react-dom: 19.2.6(react@19.2.6)
+    optionalDependencies:
+      '@types/react': 19.2.15
+      '@types/react-dom': 19.2.3(@types/react@19.2.15)
+
+  '@radix-ui/react-use-callback-ref@1.1.1(@types/react@19.2.15)(react@19.2.6)':
+    dependencies:
+      react: 19.2.6
+    optionalDependencies:
+      '@types/react': 19.2.15
+
+  '@radix-ui/react-use-controllable-state@1.2.2(@types/react@19.2.15)(react@19.2.6)':
+    dependencies:
+      '@radix-ui/react-use-effect-event': 0.0.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-use-layout-effect': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      react: 19.2.6
+    optionalDependencies:
+      '@types/react': 19.2.15
+
+  '@radix-ui/react-use-effect-event@0.0.2(@types/react@19.2.15)(react@19.2.6)':
+    dependencies:
+      '@radix-ui/react-use-layout-effect': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      react: 19.2.6
+    optionalDependencies:
+      '@types/react': 19.2.15
+
+  '@radix-ui/react-use-escape-keydown@1.1.1(@types/react@19.2.15)(react@19.2.6)':
+    dependencies:
+      '@radix-ui/react-use-callback-ref': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      react: 19.2.6
+    optionalDependencies:
+      '@types/react': 19.2.15
+
+  '@radix-ui/react-use-is-hydrated@0.1.0(@types/react@19.2.15)(react@19.2.6)':
+    dependencies:
+      react: 19.2.6
+      use-sync-external-store: 1.6.0(react@19.2.6)
+    optionalDependencies:
+      '@types/react': 19.2.15
+
+  '@radix-ui/react-use-layout-effect@1.1.1(@types/react@19.2.15)(react@19.2.6)':
+    dependencies:
+      react: 19.2.6
+    optionalDependencies:
+      '@types/react': 19.2.15
+
+  '@radix-ui/react-use-previous@1.1.1(@types/react@19.2.15)(react@19.2.6)':
+    dependencies:
+      react: 19.2.6
+    optionalDependencies:
+      '@types/react': 19.2.15
+
+  '@radix-ui/react-use-rect@1.1.1(@types/react@19.2.15)(react@19.2.6)':
+    dependencies:
+      '@radix-ui/rect': 1.1.1
+      react: 19.2.6
+    optionalDependencies:
+      '@types/react': 19.2.15
+
+  '@radix-ui/react-use-size@1.1.1(@types/react@19.2.15)(react@19.2.6)':
+    dependencies:
+      '@radix-ui/react-use-layout-effect': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      react: 19.2.6
+    optionalDependencies:
+      '@types/react': 19.2.15
+
+  '@radix-ui/react-visually-hidden@1.2.3(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)':
+    dependencies:
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      react: 19.2.6
+      react-dom: 19.2.6(react@19.2.6)
+    optionalDependencies:
+      '@types/react': 19.2.15
+      '@types/react-dom': 19.2.3(@types/react@19.2.15)
+
+  '@radix-ui/rect@1.1.1': {}
+
+  '@reduxjs/toolkit@2.12.0(react-redux@9.3.0(@types/react@19.2.15)(react@19.2.6)(redux@5.0.1))(react@19.2.6)':
+    dependencies:
+      '@standard-schema/spec': 1.1.0
+      '@standard-schema/utils': 0.3.0
+      immer: 11.1.8
+      redux: 5.0.1
+      redux-thunk: 3.1.0(redux@5.0.1)
+      reselect: 5.1.1
+    optionalDependencies:
+      react: 19.2.6
+      react-redux: 9.3.0(@types/react@19.2.15)(react@19.2.6)(redux@5.0.1)
+
   '@remix-run/router@1.23.2': {}
 
   '@rollup/rollup-android-arm-eabi@4.60.4':
@@ -3922,14 +6811,110 @@ snapshots:
 
   '@scarf/scarf@1.4.0': {}
 
+  '@scena/dragscroll@1.4.0':
+    dependencies:
+      '@daybrush/utils': 1.13.0
+      '@scena/event-emitter': 1.0.5
+
+  '@scena/event-emitter@1.0.5':
+    dependencies:
+      '@daybrush/utils': 1.13.0
+
+  '@scena/matrix@1.1.1':
+    dependencies:
+      '@daybrush/utils': 1.13.0
+
   '@sindresorhus/is@4.6.0': {}
 
   '@socket.io/component-emitter@3.1.2': {}
 
+  '@standard-schema/spec@1.1.0': {}
+
+  '@standard-schema/utils@0.3.0': {}
+
+  '@swc/helpers@0.5.15':
+    dependencies:
+      tslib: 2.8.1
+
   '@szmarczak/http-timer@4.0.6':
     dependencies:
       defer-to-connect: 2.0.1
 
+  '@tabby_ai/hijri-converter@1.0.5': {}
+
+  '@tailwindcss/node@4.3.0':
+    dependencies:
+      '@jridgewell/remapping': 2.3.5
+      enhanced-resolve: 5.22.0
+      jiti: 2.6.1
+      lightningcss: 1.32.0
+      magic-string: 0.30.21
+      source-map-js: 1.2.1
+      tailwindcss: 4.3.0
+
+  '@tailwindcss/oxide-android-arm64@4.3.0':
+    optional: true
+
+  '@tailwindcss/oxide-darwin-arm64@4.3.0':
+    optional: true
+
+  '@tailwindcss/oxide-darwin-x64@4.3.0':
+    optional: true
+
+  '@tailwindcss/oxide-freebsd-x64@4.3.0':
+    optional: true
+
+  '@tailwindcss/oxide-linux-arm-gnueabihf@4.3.0':
+    optional: true
+
+  '@tailwindcss/oxide-linux-arm64-gnu@4.3.0':
+    optional: true
+
+  '@tailwindcss/oxide-linux-arm64-musl@4.3.0':
+    optional: true
+
+  '@tailwindcss/oxide-linux-x64-gnu@4.3.0':
+    optional: true
+
+  '@tailwindcss/oxide-linux-x64-musl@4.3.0':
+    optional: true
+
+  '@tailwindcss/oxide-wasm32-wasi@4.3.0':
+    optional: true
+
+  '@tailwindcss/oxide-win32-arm64-msvc@4.3.0':
+    optional: true
+
+  '@tailwindcss/oxide-win32-x64-msvc@4.3.0':
+    optional: true
+
+  '@tailwindcss/oxide@4.3.0':
+    optionalDependencies:
+      '@tailwindcss/oxide-android-arm64': 4.3.0
+      '@tailwindcss/oxide-darwin-arm64': 4.3.0
+      '@tailwindcss/oxide-darwin-x64': 4.3.0
+      '@tailwindcss/oxide-freebsd-x64': 4.3.0
+      '@tailwindcss/oxide-linux-arm-gnueabihf': 4.3.0
+      '@tailwindcss/oxide-linux-arm64-gnu': 4.3.0
+      '@tailwindcss/oxide-linux-arm64-musl': 4.3.0
+      '@tailwindcss/oxide-linux-x64-gnu': 4.3.0
+      '@tailwindcss/oxide-linux-x64-musl': 4.3.0
+      '@tailwindcss/oxide-wasm32-wasi': 4.3.0
+      '@tailwindcss/oxide-win32-arm64-msvc': 4.3.0
+      '@tailwindcss/oxide-win32-x64-msvc': 4.3.0
+
+  '@tailwindcss/typography@0.5.19(tailwindcss@4.3.0)':
+    dependencies:
+      postcss-selector-parser: 6.0.10
+      tailwindcss: 4.3.0
+
+  '@tailwindcss/vite@4.3.0(vite@6.1.0(@types/node@22.19.13)(jiti@2.6.1)(lightningcss@1.32.0)(tsx@4.21.0)(yaml@2.9.0))':
+    dependencies:
+      '@tailwindcss/node': 4.3.0
+      '@tailwindcss/oxide': 4.3.0
+      tailwindcss: 4.3.0
+      vite: 6.1.0(@types/node@22.19.13)(jiti@2.6.1)(lightningcss@1.32.0)(tsx@4.21.0)(yaml@2.9.0)
+
   '@types/babel__core@7.20.5':
     dependencies:
       '@babel/parser': 7.29.3
@@ -3962,18 +6947,56 @@ snapshots:
       '@types/node': 22.19.13
       '@types/responselike': 1.0.3
 
+  '@types/d3-array@3.2.2': {}
+
+  '@types/d3-color@3.1.3': {}
+
+  '@types/d3-ease@3.0.2': {}
+
+  '@types/d3-interpolate@3.0.4':
+    dependencies:
+      '@types/d3-color': 3.1.3
+
+  '@types/d3-path@3.1.1': {}
+
+  '@types/d3-scale@4.0.9':
+    dependencies:
+      '@types/d3-time': 3.0.4
+
+  '@types/d3-shape@3.1.8':
+    dependencies:
+      '@types/d3-path': 3.1.1
+
+  '@types/d3-time@3.0.4': {}
+
+  '@types/d3-timer@3.0.2': {}
+
   '@types/debug@4.1.12':
     dependencies:
       '@types/ms': 2.1.0
 
+  '@types/debug@4.1.13':
+    dependencies:
+      '@types/ms': 2.1.0
+
   '@types/esrecurse@4.3.1': {}
 
+  '@types/estree-jsx@1.0.5':
+    dependencies:
+      '@types/estree': 1.0.9
+
   '@types/estree@1.0.8': {}
 
+  '@types/estree@1.0.9': {}
+
   '@types/fs-extra@9.0.13':
     dependencies:
       '@types/node': 22.19.13
 
+  '@types/hast@3.0.4':
+    dependencies:
+      '@types/unist': 3.0.3
+
   '@types/http-cache-semantics@4.2.0': {}
 
   '@types/json-schema@7.0.15': {}
@@ -3982,6 +7005,10 @@ snapshots:
     dependencies:
       '@types/node': 22.19.13
 
+  '@types/mdast@4.0.4':
+    dependencies:
+      '@types/unist': 3.0.3
+
   '@types/ms@2.1.0': {}
 
   '@types/node@22.19.13':
@@ -3994,10 +7021,26 @@ snapshots:
       xmlbuilder: 15.1.1
     optional: true
 
+  '@types/prismjs@1.26.6': {}
+
+  '@types/react-dom@19.2.3(@types/react@19.2.15)':
+    dependencies:
+      '@types/react': 19.2.15
+
+  '@types/react@19.2.15':
+    dependencies:
+      csstype: 3.2.3
+
   '@types/responselike@1.0.3':
     dependencies:
       '@types/node': 22.19.13
 
+  '@types/unist@2.0.11': {}
+
+  '@types/unist@3.0.3': {}
+
+  '@types/use-sync-external-store@0.0.6': {}
+
   '@types/verror@1.10.11':
     optional: true
 
@@ -4097,14 +7140,16 @@ snapshots:
       '@typescript-eslint/types': 8.57.1
       eslint-visitor-keys: 5.0.1
 
-  '@vitejs/plugin-react@4.3.4(vite@6.1.0(@types/node@22.19.13)(jiti@2.6.1)(tsx@4.21.0)(yaml@2.9.0))':
+  '@ungap/structured-clone@1.3.1': {}
+
+  '@vitejs/plugin-react@4.3.4(vite@6.1.0(@types/node@22.19.13)(jiti@2.6.1)(lightningcss@1.32.0)(tsx@4.21.0)(yaml@2.9.0))':
     dependencies:
       '@babel/core': 7.29.0
       '@babel/plugin-transform-react-jsx-self': 7.27.1(@babel/core@7.29.0)
       '@babel/plugin-transform-react-jsx-source': 7.27.1(@babel/core@7.29.0)
       '@types/babel__core': 7.20.5
       react-refresh: 0.14.2
-      vite: 6.1.0(@types/node@22.19.13)(jiti@2.6.1)(tsx@4.21.0)(yaml@2.9.0)
+      vite: 6.1.0(@types/node@22.19.13)(jiti@2.6.1)(lightningcss@1.32.0)(tsx@4.21.0)(yaml@2.9.0)
     transitivePeerDependencies:
       - supports-color
 
@@ -4131,12 +7176,12 @@ snapshots:
     dependencies:
       d3: 7.9.0
       d3-sankey: 0.12.3
-      i18next: 26.2.0(typescript@5.9.3)
+      i18next: 26.3.0(typescript@5.9.3)
       i18next-browser-languagedetector: 8.2.1
       lucide-react: 0.474.0(react@18.3.1)
       react: 18.3.1
       react-dom: 18.3.1(react@18.3.1)
-      react-i18next: 17.0.8(i18next@26.2.0(typescript@5.9.3))(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(typescript@5.9.3)
+      react-i18next: 17.0.8(i18next@26.3.0(typescript@5.9.3))(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(typescript@5.9.3)
       react-router-dom: 6.30.3(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
     transitivePeerDependencies:
       - react-native
@@ -4149,10 +7194,10 @@ snapshots:
       express: 4.22.2
       multer: 2.1.1
       swagger-ui-express: 5.0.1(express@4.22.2)
-      tar: 7.5.15
+      tar: 7.5.11
       uuid: 11.1.1
       web-push: 3.6.7
-      ws: 8.20.1
+      ws: 8.18.3
     optionalDependencies:
       better-sqlite3: 11.10.0
     transitivePeerDependencies:
@@ -4250,6 +7295,10 @@ snapshots:
 
   argparse@2.0.1: {}
 
+  aria-hidden@1.2.6:
+    dependencies:
+      tslib: 2.8.1
+
   array-flatten@1.1.1: {}
 
   asn1.js@5.4.1:
@@ -4285,13 +7334,15 @@ snapshots:
       postcss: 8.5.1
       postcss-value-parser: 4.2.0
 
+  bail@2.0.2: {}
+
   balanced-match@1.0.2: {}
 
   balanced-match@4.0.4: {}
 
   base64-js@1.5.1: {}
 
-  baseline-browser-mapping@2.10.31: {}
+  baseline-browser-mapping@2.10.32: {}
 
   better-sqlite3@11.10.0:
     dependencies:
@@ -4353,7 +7404,7 @@ snapshots:
 
   browserslist@4.28.2:
     dependencies:
-      baseline-browser-mapping: 2.10.31
+      baseline-browser-mapping: 2.10.32
       caniuse-lite: 1.0.30001793
       electron-to-chromium: 1.5.357
       node-releases: 2.0.44
@@ -4445,11 +7496,21 @@ snapshots:
 
   caniuse-lite@1.0.30001793: {}
 
+  ccount@2.0.1: {}
+
   chalk@4.1.2:
     dependencies:
       ansi-styles: 4.3.0
       supports-color: 7.2.0
 
+  character-entities-html4@2.1.0: {}
+
+  character-entities-legacy@3.0.0: {}
+
+  character-entities@2.0.2: {}
+
+  character-reference-invalid@2.0.1: {}
+
   chokidar@3.6.0:
     dependencies:
       anymatch: 3.1.3
@@ -4473,6 +7534,10 @@ snapshots:
 
   ci-info@4.4.0: {}
 
+  class-variance-authority@0.7.1:
+    dependencies:
+      clsx: 2.1.1
+
   cli-cursor@3.1.0:
     dependencies:
       restore-cursor: 3.1.0
@@ -4485,6 +7550,8 @@ snapshots:
       string-width: 4.2.3
     optional: true
 
+  client-only@0.0.1: {}
+
   cliui@8.0.1:
     dependencies:
       string-width: 4.2.3
@@ -4497,6 +7564,20 @@ snapshots:
 
   clone@1.0.4: {}
 
+  clsx@2.1.1: {}
+
+  cmdk@1.1.1(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6):
+    dependencies:
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-dialog': 1.1.15(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-id': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-primitive': 2.1.4(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      react: 19.2.6
+      react-dom: 19.2.6(react@19.2.6)
+    transitivePeerDependencies:
+      - '@types/react'
+      - '@types/react-dom'
+
   color-convert@2.0.1:
     dependencies:
       color-name: 1.1.4
@@ -4507,6 +7588,8 @@ snapshots:
     dependencies:
       delayed-stream: 1.0.0
 
+  comma-separated-tokens@2.0.3: {}
+
   commander@4.1.1: {}
 
   commander@5.1.0: {}
@@ -4574,8 +7657,19 @@ snapshots:
       shebang-command: 2.0.0
       which: 2.0.2
 
+  css-styled@1.0.8:
+    dependencies:
+      '@daybrush/utils': 1.13.0
+
+  css-to-mat@1.1.1:
+    dependencies:
+      '@daybrush/utils': 1.13.0
+      '@scena/matrix': 1.1.1
+
   cssesc@3.0.0: {}
 
+  csstype@3.2.3: {}
+
   d3-array@2.12.1:
     dependencies:
       internmap: 1.0.1
@@ -4743,6 +7837,10 @@ snapshots:
       d3-transition: 3.0.1(d3-selection@3.0.0)
       d3-zoom: 3.0.0
 
+  date-fns-jalali@4.1.0-0: {}
+
+  date-fns@4.3.0: {}
+
   debounce-fn@4.0.0:
     dependencies:
       mimic-fn: 3.1.0
@@ -4755,6 +7853,12 @@ snapshots:
     dependencies:
       ms: 2.1.3
 
+  decimal.js-light@2.5.1: {}
+
+  decode-named-character-reference@1.3.0:
+    dependencies:
+      character-entities: 2.0.2
+
   decompress-response@6.0.0:
     dependencies:
       mimic-response: 3.1.0
@@ -4792,13 +7896,21 @@ snapshots:
 
   depd@2.0.0: {}
 
+  dequal@2.0.3: {}
+
   destroy@1.2.0: {}
 
   detect-libc@2.1.2: {}
 
+  detect-node-es@1.1.0: {}
+
   detect-node@2.1.0:
     optional: true
 
+  devlop@1.1.0:
+    dependencies:
+      dequal: 2.0.3
+
   didyoumean@1.2.2: {}
 
   dir-compare@4.2.0:
@@ -4941,6 +8053,18 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
+  embla-carousel-react@8.6.0(react@19.2.6):
+    dependencies:
+      embla-carousel: 8.6.0
+      embla-carousel-reactive-utils: 8.6.0(embla-carousel@8.6.0)
+      react: 19.2.6
+
+  embla-carousel-reactive-utils@8.6.0(embla-carousel@8.6.0):
+    dependencies:
+      embla-carousel: 8.6.0
+
+  embla-carousel@8.6.0: {}
+
   emoji-regex@8.0.0: {}
 
   emoji-regex@9.2.2: {}
@@ -4970,6 +8094,11 @@ snapshots:
 
   engine.io-parser@5.2.3: {}
 
+  enhanced-resolve@5.22.0:
+    dependencies:
+      graceful-fs: 4.2.11
+      tapable: 2.3.3
+
   env-paths@2.2.1: {}
 
   err-code@2.0.3: {}
@@ -4987,7 +8116,9 @@ snapshots:
       es-errors: 1.3.0
       get-intrinsic: 1.3.0
       has-tostringtag: 1.0.2
-      hasown: 2.0.2
+      hasown: 2.0.4
+
+  es-toolkit@1.47.0: {}
 
   es6-error@4.1.1:
     optional: true
@@ -5055,6 +8186,8 @@ snapshots:
 
   escape-string-regexp@4.0.0: {}
 
+  escape-string-regexp@5.0.0: {}
+
   eslint-scope@9.1.2:
     dependencies:
       '@types/esrecurse': 4.3.1
@@ -5119,10 +8252,14 @@ snapshots:
 
   estraverse@5.3.0: {}
 
+  estree-util-is-identifier-name@3.0.0: {}
+
   esutils@2.0.3: {}
 
   etag@1.8.1: {}
 
+  eventemitter3@5.0.4: {}
+
   expand-template@2.0.3:
     optional: true
 
@@ -5164,6 +8301,8 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
+  extend@3.0.2: {}
+
   extract-zip@2.0.1:
     dependencies:
       debug: 4.4.3
@@ -5197,6 +8336,10 @@ snapshots:
     dependencies:
       reusify: 1.1.0
 
+  fault@1.0.4:
+    dependencies:
+      format: 0.2.2
+
   fd-slicer@1.1.0:
     dependencies:
       pend: 1.2.0
@@ -5205,10 +8348,6 @@ snapshots:
     optionalDependencies:
       picomatch: 4.0.3
 
-  fdir@6.5.0(picomatch@4.0.4):
-    optionalDependencies:
-      picomatch: 4.0.4
-
   file-entry-cache@8.0.0:
     dependencies:
       flat-cache: 4.0.1
@@ -5262,13 +8401,17 @@ snapshots:
       asynckit: 0.4.0
       combined-stream: 1.0.8
       es-set-tostringtag: 2.1.0
-      hasown: 2.0.2
+      hasown: 2.0.4
       mime-types: 2.1.35
 
+  format@0.2.2: {}
+
   forwarded@0.2.0: {}
 
   fraction.js@4.3.7: {}
 
+  framework-utils@1.1.0: {}
+
   fresh@0.5.2: {}
 
   fs-constants@1.0.0:
@@ -5326,8 +8469,17 @@ snapshots:
 
   function-bind@1.1.2: {}
 
+  geist@1.7.1(next@16.2.6(@babel/core@7.29.0)(@playwright/test@1.60.0)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)):
+    dependencies:
+      next: 16.2.6(@babel/core@7.29.0)(@playwright/test@1.60.0)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+
   gensync@1.0.0-beta.2: {}
 
+  gesto@1.19.4:
+    dependencies:
+      '@daybrush/utils': 1.13.0
+      '@scena/event-emitter': 1.0.5
+
   get-caller-file@2.0.5: {}
 
   get-intrinsic@1.3.0:
@@ -5340,9 +8492,11 @@ snapshots:
       get-proto: 1.0.1
       gopd: 1.2.0
       has-symbols: 1.1.0
-      hasown: 2.0.2
+      hasown: 2.0.4
       math-intrinsics: 1.1.0
 
+  get-nonce@1.0.1: {}
+
   get-proto@1.0.1:
     dependencies:
       dunder-proto: 1.0.1
@@ -5441,13 +8595,49 @@ snapshots:
     dependencies:
       has-symbols: 1.1.0
 
-  hasown@2.0.2:
+  hasown@2.0.4:
     dependencies:
       function-bind: 1.1.2
 
-  hasown@2.0.3:
+  hast-util-parse-selector@4.0.0:
+    dependencies:
+      '@types/hast': 3.0.4
+
+  hast-util-to-jsx-runtime@2.3.6:
+    dependencies:
+      '@types/estree': 1.0.9
+      '@types/hast': 3.0.4
+      '@types/unist': 3.0.3
+      comma-separated-tokens: 2.0.3
+      devlop: 1.1.0
+      estree-util-is-identifier-name: 3.0.0
+      hast-util-whitespace: 3.0.0
+      mdast-util-mdx-expression: 2.0.1
+      mdast-util-mdx-jsx: 3.2.0
+      mdast-util-mdxjs-esm: 2.0.1
+      property-information: 7.1.0
+      space-separated-tokens: 2.0.2
+      style-to-js: 1.1.21
+      unist-util-position: 5.0.0
+      vfile-message: 4.0.3
+    transitivePeerDependencies:
+      - supports-color
+
+  hast-util-whitespace@3.0.0:
     dependencies:
-      function-bind: 1.1.2
+      '@types/hast': 3.0.4
+
+  hastscript@9.0.1:
+    dependencies:
+      '@types/hast': 3.0.4
+      comma-separated-tokens: 2.0.3
+      hast-util-parse-selector: 4.0.0
+      property-information: 7.1.0
+      space-separated-tokens: 2.0.2
+
+  highlight.js@10.7.3: {}
+
+  highlightjs-vue@1.0.0: {}
 
   hosted-git-info@4.1.0:
     dependencies:
@@ -5457,6 +8647,8 @@ snapshots:
     dependencies:
       void-elements: 3.1.0
 
+  html-url-attributes@3.0.1: {}
+
   http-cache-semantics@4.2.0: {}
 
   http-errors@2.0.1:
@@ -5490,9 +8682,9 @@ snapshots:
 
   i18next-browser-languagedetector@8.2.1:
     dependencies:
-      '@babel/runtime': 7.29.2
+      '@babel/runtime': 7.29.7
 
-  i18next@26.2.0(typescript@5.9.3):
+  i18next@26.3.0(typescript@5.9.3):
     optionalDependencies:
       typescript: 5.9.3
 
@@ -5516,6 +8708,10 @@ snapshots:
 
   ignore@7.0.5: {}
 
+  immer@10.2.0: {}
+
+  immer@11.1.8: {}
+
   imurmurhash@0.1.4: {}
 
   inflight@1.0.6:
@@ -5528,6 +8724,13 @@ snapshots:
   ini@1.3.8:
     optional: true
 
+  inline-style-parser@0.2.7: {}
+
+  input-otp@1.4.2(react-dom@19.2.6(react@19.2.6))(react@19.2.6):
+    dependencies:
+      react: 19.2.6
+      react-dom: 19.2.6(react@19.2.6)
+
   internmap@1.0.1: {}
 
   internmap@2.0.3: {}
@@ -5536,13 +8739,22 @@ snapshots:
 
   ipaddr.js@1.9.1: {}
 
+  is-alphabetical@2.0.1: {}
+
+  is-alphanumerical@2.0.1:
+    dependencies:
+      is-alphabetical: 2.0.1
+      is-decimal: 2.0.1
+
   is-binary-path@2.1.0:
     dependencies:
       binary-extensions: 2.3.0
 
   is-core-module@2.16.2:
     dependencies:
-      hasown: 2.0.3
+      hasown: 2.0.4
+
+  is-decimal@2.0.1: {}
 
   is-extglob@2.1.1: {}
 
@@ -5552,12 +8764,16 @@ snapshots:
     dependencies:
       is-extglob: 2.1.1
 
+  is-hexadecimal@2.0.1: {}
+
   is-interactive@1.0.0: {}
 
   is-number@7.0.0: {}
 
   is-obj@2.0.0: {}
 
+  is-plain-obj@4.1.0: {}
+
   is-unicode-supported@0.1.0: {}
 
   isbinaryfile@4.0.10: {}
@@ -5604,130 +8820,549 @@ snapshots:
 
   json-schema-typed@7.0.3: {}
 
-  json-stable-stringify-without-jsonify@1.0.1: {}
+  json-stable-stringify-without-jsonify@1.0.1: {}
+
+  json-stringify-safe@5.0.1:
+    optional: true
+
+  json5@2.2.3: {}
+
+  jsonfile@4.0.0:
+    optionalDependencies:
+      graceful-fs: 4.2.11
+
+  jsonfile@6.2.0:
+    dependencies:
+      universalify: 2.0.1
+    optionalDependencies:
+      graceful-fs: 4.2.11
+
+  jsonfile@6.2.1:
+    dependencies:
+      universalify: 2.0.1
+    optionalDependencies:
+      graceful-fs: 4.2.11
+    optional: true
+
+  jwa@2.0.1:
+    dependencies:
+      buffer-equal-constant-time: 1.0.1
+      ecdsa-sig-formatter: 1.0.11
+      safe-buffer: 5.2.1
+
+  jws@4.0.1:
+    dependencies:
+      jwa: 2.0.1
+      safe-buffer: 5.2.1
+
+  keycode@2.2.1: {}
+
+  keycon@1.4.0:
+    dependencies:
+      '@cfcs/core': 0.0.6
+      '@daybrush/utils': 1.13.0
+      '@scena/event-emitter': 1.0.5
+      keycode: 2.2.1
+
+  keyv@4.5.4:
+    dependencies:
+      json-buffer: 3.0.1
+
+  lazy-val@1.0.5: {}
+
+  levn@0.4.1:
+    dependencies:
+      prelude-ls: 1.2.1
+      type-check: 0.4.0
+
+  lightningcss-android-arm64@1.32.0:
+    optional: true
+
+  lightningcss-darwin-arm64@1.32.0:
+    optional: true
+
+  lightningcss-darwin-x64@1.32.0:
+    optional: true
+
+  lightningcss-freebsd-x64@1.32.0:
+    optional: true
+
+  lightningcss-linux-arm-gnueabihf@1.32.0:
+    optional: true
+
+  lightningcss-linux-arm64-gnu@1.32.0:
+    optional: true
+
+  lightningcss-linux-arm64-musl@1.32.0:
+    optional: true
+
+  lightningcss-linux-x64-gnu@1.32.0:
+    optional: true
+
+  lightningcss-linux-x64-musl@1.32.0:
+    optional: true
+
+  lightningcss-win32-arm64-msvc@1.32.0:
+    optional: true
+
+  lightningcss-win32-x64-msvc@1.32.0:
+    optional: true
+
+  lightningcss@1.32.0:
+    dependencies:
+      detect-libc: 2.1.2
+    optionalDependencies:
+      lightningcss-android-arm64: 1.32.0
+      lightningcss-darwin-arm64: 1.32.0
+      lightningcss-darwin-x64: 1.32.0
+      lightningcss-freebsd-x64: 1.32.0
+      lightningcss-linux-arm-gnueabihf: 1.32.0
+      lightningcss-linux-arm64-gnu: 1.32.0
+      lightningcss-linux-arm64-musl: 1.32.0
+      lightningcss-linux-x64-gnu: 1.32.0
+      lightningcss-linux-x64-musl: 1.32.0
+      lightningcss-win32-arm64-msvc: 1.32.0
+      lightningcss-win32-x64-msvc: 1.32.0
+
+  lilconfig@3.1.3: {}
+
+  lines-and-columns@1.2.4: {}
+
+  locate-path@3.0.0:
+    dependencies:
+      p-locate: 3.0.0
+      path-exists: 3.0.0
+
+  locate-path@6.0.0:
+    dependencies:
+      p-locate: 5.0.0
+
+  lodash.escaperegexp@4.1.2: {}
+
+  lodash.isequal@4.5.0: {}
+
+  lodash@4.17.23: {}
+
+  lodash@4.18.1: {}
+
+  log-symbols@4.1.0:
+    dependencies:
+      chalk: 4.1.2
+      is-unicode-supported: 0.1.0
+
+  longest-streak@3.1.0: {}
+
+  loose-envify@1.4.0:
+    dependencies:
+      js-tokens: 4.0.0
+
+  lowercase-keys@2.0.0: {}
+
+  lowlight@1.20.0:
+    dependencies:
+      fault: 1.0.4
+      highlight.js: 10.7.3
+
+  lru-cache@10.4.3: {}
+
+  lru-cache@11.2.6: {}
+
+  lru-cache@5.1.1:
+    dependencies:
+      yallist: 3.1.1
+
+  lru-cache@6.0.0:
+    dependencies:
+      yallist: 4.0.0
+
+  lucide-react@0.474.0(react@18.3.1):
+    dependencies:
+      react: 18.3.1
+
+  lucide-react@0.556.0(react@19.2.6):
+    dependencies:
+      react: 19.2.6
+
+  magic-string@0.30.21:
+    dependencies:
+      '@jridgewell/sourcemap-codec': 1.5.5
+
+  make-fetch-happen@14.0.3:
+    dependencies:
+      '@npmcli/agent': 3.0.0
+      cacache: 19.0.1
+      http-cache-semantics: 4.2.0
+      minipass: 7.1.3
+      minipass-fetch: 4.0.1
+      minipass-flush: 1.0.5
+      minipass-pipeline: 1.2.4
+      negotiator: 1.0.0
+      proc-log: 5.0.0
+      promise-retry: 2.0.1
+      ssri: 12.0.0
+    transitivePeerDependencies:
+      - supports-color
+
+  markdown-table@3.0.4: {}
+
+  matcher@3.0.0:
+    dependencies:
+      escape-string-regexp: 4.0.0
+    optional: true
+
+  math-intrinsics@1.1.0: {}
+
+  mdast-util-find-and-replace@3.0.2:
+    dependencies:
+      '@types/mdast': 4.0.4
+      escape-string-regexp: 5.0.0
+      unist-util-is: 6.0.1
+      unist-util-visit-parents: 6.0.2
+
+  mdast-util-from-markdown@2.0.3:
+    dependencies:
+      '@types/mdast': 4.0.4
+      '@types/unist': 3.0.3
+      decode-named-character-reference: 1.3.0
+      devlop: 1.1.0
+      mdast-util-to-string: 4.0.0
+      micromark: 4.0.2
+      micromark-util-decode-numeric-character-reference: 2.0.2
+      micromark-util-decode-string: 2.0.1
+      micromark-util-normalize-identifier: 2.0.1
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+      unist-util-stringify-position: 4.0.0
+    transitivePeerDependencies:
+      - supports-color
+
+  mdast-util-gfm-autolink-literal@2.0.1:
+    dependencies:
+      '@types/mdast': 4.0.4
+      ccount: 2.0.1
+      devlop: 1.1.0
+      mdast-util-find-and-replace: 3.0.2
+      micromark-util-character: 2.1.1
+
+  mdast-util-gfm-footnote@2.1.0:
+    dependencies:
+      '@types/mdast': 4.0.4
+      devlop: 1.1.0
+      mdast-util-from-markdown: 2.0.3
+      mdast-util-to-markdown: 2.1.2
+      micromark-util-normalize-identifier: 2.0.1
+    transitivePeerDependencies:
+      - supports-color
+
+  mdast-util-gfm-strikethrough@2.0.0:
+    dependencies:
+      '@types/mdast': 4.0.4
+      mdast-util-from-markdown: 2.0.3
+      mdast-util-to-markdown: 2.1.2
+    transitivePeerDependencies:
+      - supports-color
+
+  mdast-util-gfm-table@2.0.0:
+    dependencies:
+      '@types/mdast': 4.0.4
+      devlop: 1.1.0
+      markdown-table: 3.0.4
+      mdast-util-from-markdown: 2.0.3
+      mdast-util-to-markdown: 2.1.2
+    transitivePeerDependencies:
+      - supports-color
+
+  mdast-util-gfm-task-list-item@2.0.0:
+    dependencies:
+      '@types/mdast': 4.0.4
+      devlop: 1.1.0
+      mdast-util-from-markdown: 2.0.3
+      mdast-util-to-markdown: 2.1.2
+    transitivePeerDependencies:
+      - supports-color
+
+  mdast-util-gfm@3.1.0:
+    dependencies:
+      mdast-util-from-markdown: 2.0.3
+      mdast-util-gfm-autolink-literal: 2.0.1
+      mdast-util-gfm-footnote: 2.1.0
+      mdast-util-gfm-strikethrough: 2.0.0
+      mdast-util-gfm-table: 2.0.0
+      mdast-util-gfm-task-list-item: 2.0.0
+      mdast-util-to-markdown: 2.1.2
+    transitivePeerDependencies:
+      - supports-color
+
+  mdast-util-mdx-expression@2.0.1:
+    dependencies:
+      '@types/estree-jsx': 1.0.5
+      '@types/hast': 3.0.4
+      '@types/mdast': 4.0.4
+      devlop: 1.1.0
+      mdast-util-from-markdown: 2.0.3
+      mdast-util-to-markdown: 2.1.2
+    transitivePeerDependencies:
+      - supports-color
+
+  mdast-util-mdx-jsx@3.2.0:
+    dependencies:
+      '@types/estree-jsx': 1.0.5
+      '@types/hast': 3.0.4
+      '@types/mdast': 4.0.4
+      '@types/unist': 3.0.3
+      ccount: 2.0.1
+      devlop: 1.1.0
+      mdast-util-from-markdown: 2.0.3
+      mdast-util-to-markdown: 2.1.2
+      parse-entities: 4.0.2
+      stringify-entities: 4.0.4
+      unist-util-stringify-position: 4.0.0
+      vfile-message: 4.0.3
+    transitivePeerDependencies:
+      - supports-color
+
+  mdast-util-mdxjs-esm@2.0.1:
+    dependencies:
+      '@types/estree-jsx': 1.0.5
+      '@types/hast': 3.0.4
+      '@types/mdast': 4.0.4
+      devlop: 1.1.0
+      mdast-util-from-markdown: 2.0.3
+      mdast-util-to-markdown: 2.1.2
+    transitivePeerDependencies:
+      - supports-color
+
+  mdast-util-phrasing@4.1.0:
+    dependencies:
+      '@types/mdast': 4.0.4
+      unist-util-is: 6.0.1
+
+  mdast-util-to-hast@13.2.1:
+    dependencies:
+      '@types/hast': 3.0.4
+      '@types/mdast': 4.0.4
+      '@ungap/structured-clone': 1.3.1
+      devlop: 1.1.0
+      micromark-util-sanitize-uri: 2.0.1
+      trim-lines: 3.0.1
+      unist-util-position: 5.0.0
+      unist-util-visit: 5.1.0
+      vfile: 6.0.3
+
+  mdast-util-to-markdown@2.1.2:
+    dependencies:
+      '@types/mdast': 4.0.4
+      '@types/unist': 3.0.3
+      longest-streak: 3.1.0
+      mdast-util-phrasing: 4.1.0
+      mdast-util-to-string: 4.0.0
+      micromark-util-classify-character: 2.0.1
+      micromark-util-decode-string: 2.0.1
+      unist-util-visit: 5.1.0
+      zwitch: 2.0.4
+
+  mdast-util-to-string@4.0.0:
+    dependencies:
+      '@types/mdast': 4.0.4
+
+  media-typer@0.3.0: {}
 
-  json-stringify-safe@5.0.1:
-    optional: true
+  merge-descriptors@1.0.3: {}
 
-  json5@2.2.3: {}
+  merge2@1.4.1: {}
 
-  jsonfile@4.0.0:
-    optionalDependencies:
-      graceful-fs: 4.2.11
+  methods@1.1.2: {}
 
-  jsonfile@6.2.0:
+  micromark-core-commonmark@2.0.3:
     dependencies:
-      universalify: 2.0.1
-    optionalDependencies:
-      graceful-fs: 4.2.11
+      decode-named-character-reference: 1.3.0
+      devlop: 1.1.0
+      micromark-factory-destination: 2.0.1
+      micromark-factory-label: 2.0.1
+      micromark-factory-space: 2.0.1
+      micromark-factory-title: 2.0.1
+      micromark-factory-whitespace: 2.0.1
+      micromark-util-character: 2.1.1
+      micromark-util-chunked: 2.0.1
+      micromark-util-classify-character: 2.0.1
+      micromark-util-html-tag-name: 2.0.1
+      micromark-util-normalize-identifier: 2.0.1
+      micromark-util-resolve-all: 2.0.1
+      micromark-util-subtokenize: 2.1.0
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
 
-  jsonfile@6.2.1:
+  micromark-extension-gfm-autolink-literal@2.1.0:
     dependencies:
-      universalify: 2.0.1
-    optionalDependencies:
-      graceful-fs: 4.2.11
-    optional: true
+      micromark-util-character: 2.1.1
+      micromark-util-sanitize-uri: 2.0.1
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
 
-  jwa@2.0.1:
+  micromark-extension-gfm-footnote@2.1.0:
     dependencies:
-      buffer-equal-constant-time: 1.0.1
-      ecdsa-sig-formatter: 1.0.11
-      safe-buffer: 5.2.1
+      devlop: 1.1.0
+      micromark-core-commonmark: 2.0.3
+      micromark-factory-space: 2.0.1
+      micromark-util-character: 2.1.1
+      micromark-util-normalize-identifier: 2.0.1
+      micromark-util-sanitize-uri: 2.0.1
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
 
-  jws@4.0.1:
+  micromark-extension-gfm-strikethrough@2.1.0:
     dependencies:
-      jwa: 2.0.1
-      safe-buffer: 5.2.1
+      devlop: 1.1.0
+      micromark-util-chunked: 2.0.1
+      micromark-util-classify-character: 2.0.1
+      micromark-util-resolve-all: 2.0.1
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
 
-  keyv@4.5.4:
+  micromark-extension-gfm-table@2.1.1:
     dependencies:
-      json-buffer: 3.0.1
+      devlop: 1.1.0
+      micromark-factory-space: 2.0.1
+      micromark-util-character: 2.1.1
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
 
-  lazy-val@1.0.5: {}
+  micromark-extension-gfm-tagfilter@2.0.0:
+    dependencies:
+      micromark-util-types: 2.0.2
 
-  levn@0.4.1:
+  micromark-extension-gfm-task-list-item@2.1.0:
     dependencies:
-      prelude-ls: 1.2.1
-      type-check: 0.4.0
+      devlop: 1.1.0
+      micromark-factory-space: 2.0.1
+      micromark-util-character: 2.1.1
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
 
-  lilconfig@3.1.3: {}
+  micromark-extension-gfm@3.0.0:
+    dependencies:
+      micromark-extension-gfm-autolink-literal: 2.1.0
+      micromark-extension-gfm-footnote: 2.1.0
+      micromark-extension-gfm-strikethrough: 2.1.0
+      micromark-extension-gfm-table: 2.1.1
+      micromark-extension-gfm-tagfilter: 2.0.0
+      micromark-extension-gfm-task-list-item: 2.1.0
+      micromark-util-combine-extensions: 2.0.1
+      micromark-util-types: 2.0.2
 
-  lines-and-columns@1.2.4: {}
+  micromark-factory-destination@2.0.1:
+    dependencies:
+      micromark-util-character: 2.1.1
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
 
-  locate-path@3.0.0:
+  micromark-factory-label@2.0.1:
     dependencies:
-      p-locate: 3.0.0
-      path-exists: 3.0.0
+      devlop: 1.1.0
+      micromark-util-character: 2.1.1
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
 
-  locate-path@6.0.0:
+  micromark-factory-space@2.0.1:
     dependencies:
-      p-locate: 5.0.0
+      micromark-util-character: 2.1.1
+      micromark-util-types: 2.0.2
 
-  lodash.escaperegexp@4.1.2: {}
+  micromark-factory-title@2.0.1:
+    dependencies:
+      micromark-factory-space: 2.0.1
+      micromark-util-character: 2.1.1
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
 
-  lodash.isequal@4.5.0: {}
+  micromark-factory-whitespace@2.0.1:
+    dependencies:
+      micromark-factory-space: 2.0.1
+      micromark-util-character: 2.1.1
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
 
-  lodash@4.17.23: {}
+  micromark-util-character@2.1.1:
+    dependencies:
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
 
-  lodash@4.18.1: {}
+  micromark-util-chunked@2.0.1:
+    dependencies:
+      micromark-util-symbol: 2.0.1
 
-  log-symbols@4.1.0:
+  micromark-util-classify-character@2.0.1:
     dependencies:
-      chalk: 4.1.2
-      is-unicode-supported: 0.1.0
+      micromark-util-character: 2.1.1
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
 
-  loose-envify@1.4.0:
+  micromark-util-combine-extensions@2.0.1:
     dependencies:
-      js-tokens: 4.0.0
+      micromark-util-chunked: 2.0.1
+      micromark-util-types: 2.0.2
 
-  lowercase-keys@2.0.0: {}
+  micromark-util-decode-numeric-character-reference@2.0.2:
+    dependencies:
+      micromark-util-symbol: 2.0.1
 
-  lru-cache@10.4.3: {}
+  micromark-util-decode-string@2.0.1:
+    dependencies:
+      decode-named-character-reference: 1.3.0
+      micromark-util-character: 2.1.1
+      micromark-util-decode-numeric-character-reference: 2.0.2
+      micromark-util-symbol: 2.0.1
 
-  lru-cache@11.2.6: {}
+  micromark-util-encode@2.0.1: {}
 
-  lru-cache@5.1.1:
-    dependencies:
-      yallist: 3.1.1
+  micromark-util-html-tag-name@2.0.1: {}
 
-  lru-cache@6.0.0:
+  micromark-util-normalize-identifier@2.0.1:
     dependencies:
-      yallist: 4.0.0
+      micromark-util-symbol: 2.0.1
 
-  lucide-react@0.474.0(react@18.3.1):
+  micromark-util-resolve-all@2.0.1:
     dependencies:
-      react: 18.3.1
+      micromark-util-types: 2.0.2
 
-  make-fetch-happen@14.0.3:
+  micromark-util-sanitize-uri@2.0.1:
     dependencies:
-      '@npmcli/agent': 3.0.0
-      cacache: 19.0.1
-      http-cache-semantics: 4.2.0
-      minipass: 7.1.3
-      minipass-fetch: 4.0.1
-      minipass-flush: 1.0.5
-      minipass-pipeline: 1.2.4
-      negotiator: 1.0.0
-      proc-log: 5.0.0
-      promise-retry: 2.0.1
-      ssri: 12.0.0
-    transitivePeerDependencies:
-      - supports-color
+      micromark-util-character: 2.1.1
+      micromark-util-encode: 2.0.1
+      micromark-util-symbol: 2.0.1
 
-  matcher@3.0.0:
+  micromark-util-subtokenize@2.1.0:
     dependencies:
-      escape-string-regexp: 4.0.0
-    optional: true
-
-  math-intrinsics@1.1.0: {}
+      devlop: 1.1.0
+      micromark-util-chunked: 2.0.1
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
 
-  media-typer@0.3.0: {}
-
-  merge-descriptors@1.0.3: {}
+  micromark-util-symbol@2.0.1: {}
 
-  merge2@1.4.1: {}
+  micromark-util-types@2.0.2: {}
 
-  methods@1.1.2: {}
+  micromark@4.0.2:
+    dependencies:
+      '@types/debug': 4.1.13
+      debug: 4.4.3
+      decode-named-character-reference: 1.3.0
+      devlop: 1.1.0
+      micromark-core-commonmark: 2.0.3
+      micromark-factory-space: 2.0.1
+      micromark-util-character: 2.1.1
+      micromark-util-chunked: 2.0.1
+      micromark-util-combine-extensions: 2.0.1
+      micromark-util-decode-numeric-character-reference: 2.0.2
+      micromark-util-encode: 2.0.1
+      micromark-util-normalize-identifier: 2.0.1
+      micromark-util-resolve-all: 2.0.1
+      micromark-util-sanitize-uri: 2.0.1
+      micromark-util-subtokenize: 2.1.0
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+    transitivePeerDependencies:
+      - supports-color
 
   micromatch@4.0.8:
     dependencies:
@@ -5841,9 +9476,39 @@ snapshots:
 
   negotiator@1.0.0: {}
 
+  next-themes@0.4.6(react-dom@19.2.6(react@19.2.6))(react@19.2.6):
+    dependencies:
+      react: 19.2.6
+      react-dom: 19.2.6(react@19.2.6)
+
+  next@16.2.6(@babel/core@7.29.0)(@playwright/test@1.60.0)(react-dom@19.2.6(react@19.2.6))(react@19.2.6):
+    dependencies:
+      '@next/env': 16.2.6
+      '@swc/helpers': 0.5.15
+      baseline-browser-mapping: 2.10.32
+      caniuse-lite: 1.0.30001793
+      postcss: 8.4.31
+      react: 19.2.6
+      react-dom: 19.2.6(react@19.2.6)
+      styled-jsx: 5.1.6(@babel/core@7.29.0)(react@19.2.6)
+    optionalDependencies:
+      '@next/swc-darwin-arm64': 16.2.6
+      '@next/swc-darwin-x64': 16.2.6
+      '@next/swc-linux-arm64-gnu': 16.2.6
+      '@next/swc-linux-arm64-musl': 16.2.6
+      '@next/swc-linux-x64-gnu': 16.2.6
+      '@next/swc-linux-x64-musl': 16.2.6
+      '@next/swc-win32-arm64-msvc': 16.2.6
+      '@next/swc-win32-x64-msvc': 16.2.6
+      '@playwright/test': 1.60.0
+      sharp: 0.34.5
+    transitivePeerDependencies:
+      - '@babel/core'
+      - babel-plugin-macros
+
   node-abi@3.92.0:
     dependencies:
-      semver: 7.8.0
+      semver: 7.8.1
     optional: true
 
   node-abi@4.27.0:
@@ -5926,6 +9591,10 @@ snapshots:
       strip-ansi: 6.0.1
       wcwidth: 1.0.1
 
+  overlap-area@1.1.0:
+    dependencies:
+      '@daybrush/utils': 1.13.0
+
   p-cancelable@2.1.1: {}
 
   p-limit@2.3.0:
@@ -5950,6 +9619,16 @@ snapshots:
 
   package-json-from-dist@1.0.1: {}
 
+  parse-entities@4.0.2:
+    dependencies:
+      '@types/unist': 2.0.11
+      character-entities-legacy: 3.0.0
+      character-reference-invalid: 2.0.1
+      decode-named-character-reference: 1.3.0
+      is-alphanumerical: 2.0.1
+      is-decimal: 2.0.1
+      is-hexadecimal: 2.0.1
+
   parseurl@1.3.3: {}
 
   path-exists@3.0.0: {}
@@ -5984,8 +9663,6 @@ snapshots:
 
   picomatch@4.0.3: {}
 
-  picomatch@4.0.4: {}
-
   pify@2.3.0: {}
 
   pirates@4.0.7: {}
@@ -6032,6 +9709,11 @@ snapshots:
       postcss: 8.5.1
       postcss-selector-parser: 6.1.2
 
+  postcss-selector-parser@6.0.10:
+    dependencies:
+      cssesc: 3.0.0
+      util-deprecate: 1.0.2
+
   postcss-selector-parser@6.1.2:
     dependencies:
       cssesc: 3.0.0
@@ -6039,6 +9721,12 @@ snapshots:
 
   postcss-value-parser@4.2.0: {}
 
+  postcss@8.4.31:
+    dependencies:
+      nanoid: 3.3.12
+      picocolors: 1.1.1
+      source-map-js: 1.2.1
+
   postcss@8.5.1:
     dependencies:
       nanoid: 3.3.12
@@ -6059,7 +9747,7 @@ snapshots:
       mkdirp-classic: 0.5.3
       napi-build-utils: 2.0.0
       node-abi: 3.92.0
-      pump: 3.0.4
+      pump: 3.0.3
       rc: 1.2.8
       simple-get: 4.0.1
       tar-fs: 2.1.4
@@ -6068,6 +9756,8 @@ snapshots:
 
   prelude-ls@1.2.1: {}
 
+  prismjs@1.30.0: {}
+
   proc-log@5.0.0: {}
 
   progress@2.0.3: {}
@@ -6083,6 +9773,8 @@ snapshots:
       retry: 0.12.0
       signal-exit: 3.0.7
 
+  property-information@7.1.0: {}
+
   proxy-addr@2.0.7:
     dependencies:
       forwarded: 0.2.0
@@ -6093,12 +9785,6 @@ snapshots:
       end-of-stream: 1.4.5
       once: 1.4.0
 
-  pump@3.0.4:
-    dependencies:
-      end-of-stream: 1.4.5
-      once: 1.4.0
-    optional: true
-
   punycode@2.3.1: {}
 
   qs@6.15.2:
@@ -6109,6 +9795,69 @@ snapshots:
 
   quick-lru@5.1.1: {}
 
+  radix-ui@1.4.3(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6):
+    dependencies:
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-accessible-icon': 1.1.7(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-accordion': 1.2.12(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-alert-dialog': 1.1.15(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-arrow': 1.1.7(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-aspect-ratio': 1.1.7(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-avatar': 1.1.10(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-checkbox': 1.3.3(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-collapsible': 1.1.12(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-collection': 1.1.7(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-context-menu': 2.2.16(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-dialog': 1.1.15(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-direction': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-dismissable-layer': 1.1.11(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-dropdown-menu': 2.1.16(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-focus-guards': 1.1.3(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-focus-scope': 1.1.7(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-form': 0.1.8(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-hover-card': 1.1.15(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-label': 2.1.7(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-menu': 2.1.16(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-menubar': 1.1.16(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-navigation-menu': 1.2.14(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-one-time-password-field': 0.1.8(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-password-toggle-field': 0.1.3(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-popover': 1.1.15(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-popper': 1.2.8(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-portal': 1.1.9(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-presence': 1.1.5(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-progress': 1.1.7(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-radio-group': 1.3.8(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-roving-focus': 1.1.11(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-scroll-area': 1.2.10(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-select': 2.2.6(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-separator': 1.1.7(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-slider': 1.3.6(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-slot': 1.2.3(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-switch': 1.2.6(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-tabs': 1.1.13(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-toast': 1.2.15(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-toggle': 1.1.10(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-toggle-group': 1.1.11(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-toolbar': 1.1.11(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-tooltip': 1.2.8(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-use-callback-ref': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-use-controllable-state': 1.2.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-use-effect-event': 0.0.2(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-use-escape-keydown': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-use-is-hydrated': 0.1.0(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-use-layout-effect': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-use-size': 1.1.1(@types/react@19.2.15)(react@19.2.6)
+      '@radix-ui/react-visually-hidden': 1.2.3(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      react: 19.2.6
+      react-dom: 19.2.6(react@19.2.6)
+    optionalDependencies:
+      '@types/react': 19.2.15
+      '@types/react-dom': 19.2.3(@types/react@19.2.15)
+
   range-parser@1.2.1: {}
 
   raw-body@2.5.3:
@@ -6126,25 +9875,116 @@ snapshots:
       strip-json-comments: 2.0.1
     optional: true
 
+  react-css-styled@1.1.9:
+    dependencies:
+      css-styled: 1.0.8
+      framework-utils: 1.1.0
+
+  react-day-picker@9.14.0(react@19.2.6):
+    dependencies:
+      '@date-fns/tz': 1.5.0
+      '@tabby_ai/hijri-converter': 1.0.5
+      date-fns: 4.3.0
+      date-fns-jalali: 4.1.0-0
+      react: 19.2.6
+
   react-dom@18.3.1(react@18.3.1):
     dependencies:
       loose-envify: 1.4.0
       react: 18.3.1
       scheduler: 0.23.2
 
-  react-i18next@17.0.8(i18next@26.2.0(typescript@5.9.3))(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(typescript@5.9.3):
+  react-dom@19.2.6(react@19.2.6):
+    dependencies:
+      react: 19.2.6
+      scheduler: 0.27.0
+
+  react-hook-form@7.76.1(react@19.2.6):
+    dependencies:
+      react: 19.2.6
+
+  react-i18next@17.0.8(i18next@26.3.0(typescript@5.9.3))(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(typescript@5.9.3):
     dependencies:
-      '@babel/runtime': 7.29.2
+      '@babel/runtime': 7.29.7
       html-parse-stringify: 3.0.1
-      i18next: 26.2.0(typescript@5.9.3)
+      i18next: 26.3.0(typescript@5.9.3)
       react: 18.3.1
       use-sync-external-store: 1.6.0(react@18.3.1)
     optionalDependencies:
       react-dom: 18.3.1(react@18.3.1)
       typescript: 5.9.3
 
+  react-is@19.2.6: {}
+
+  react-markdown@10.1.0(@types/react@19.2.15)(react@19.2.6):
+    dependencies:
+      '@types/hast': 3.0.4
+      '@types/mdast': 4.0.4
+      '@types/react': 19.2.15
+      devlop: 1.1.0
+      hast-util-to-jsx-runtime: 2.3.6
+      html-url-attributes: 3.0.1
+      mdast-util-to-hast: 13.2.1
+      react: 19.2.6
+      remark-parse: 11.0.0
+      remark-rehype: 11.1.2
+      unified: 11.0.5
+      unist-util-visit: 5.1.0
+      vfile: 6.0.3
+    transitivePeerDependencies:
+      - supports-color
+
+  react-moveable@0.56.0:
+    dependencies:
+      '@daybrush/utils': 1.13.0
+      '@egjs/agent': 2.4.4
+      '@egjs/children-differ': 1.0.1
+      '@egjs/list-differ': 1.0.1
+      '@scena/dragscroll': 1.4.0
+      '@scena/event-emitter': 1.0.5
+      '@scena/matrix': 1.1.1
+      css-to-mat: 1.1.1
+      framework-utils: 1.1.0
+      gesto: 1.19.4
+      overlap-area: 1.1.0
+      react-css-styled: 1.1.9
+      react-selecto: 1.26.3
+
+  react-redux@9.3.0(@types/react@19.2.15)(react@19.2.6)(redux@5.0.1):
+    dependencies:
+      '@types/use-sync-external-store': 0.0.6
+      react: 19.2.6
+      use-sync-external-store: 1.6.0(react@19.2.6)
+    optionalDependencies:
+      '@types/react': 19.2.15
+      redux: 5.0.1
+
   react-refresh@0.14.2: {}
 
+  react-remove-scroll-bar@2.3.8(@types/react@19.2.15)(react@19.2.6):
+    dependencies:
+      react: 19.2.6
+      react-style-singleton: 2.2.3(@types/react@19.2.15)(react@19.2.6)
+      tslib: 2.8.1
+    optionalDependencies:
+      '@types/react': 19.2.15
+
+  react-remove-scroll@2.7.2(@types/react@19.2.15)(react@19.2.6):
+    dependencies:
+      react: 19.2.6
+      react-remove-scroll-bar: 2.3.8(@types/react@19.2.15)(react@19.2.6)
+      react-style-singleton: 2.2.3(@types/react@19.2.15)(react@19.2.6)
+      tslib: 2.8.1
+      use-callback-ref: 1.3.3(@types/react@19.2.15)(react@19.2.6)
+      use-sidecar: 1.1.3(@types/react@19.2.15)(react@19.2.6)
+    optionalDependencies:
+      '@types/react': 19.2.15
+
+  react-resizable-panels@3.0.6(react-dom@19.2.6(react@19.2.6))(react@19.2.6):
+    dependencies:
+      react: 19.2.6
+      react-dom: 19.2.6(react@19.2.6)
+
   react-router-dom@6.30.3(react-dom@18.3.1(react@18.3.1))(react@18.3.1):
     dependencies:
       '@remix-run/router': 1.23.2
@@ -6157,10 +9997,34 @@ snapshots:
       '@remix-run/router': 1.23.2
       react: 18.3.1
 
+  react-selecto@1.26.3:
+    dependencies:
+      selecto: 1.26.3
+
+  react-style-singleton@2.2.3(@types/react@19.2.15)(react@19.2.6):
+    dependencies:
+      get-nonce: 1.0.1
+      react: 19.2.6
+      tslib: 2.8.1
+    optionalDependencies:
+      '@types/react': 19.2.15
+
+  react-syntax-highlighter@16.1.1(react@19.2.6):
+    dependencies:
+      '@babel/runtime': 7.29.7
+      highlight.js: 10.7.3
+      highlightjs-vue: 1.0.0
+      lowlight: 1.20.0
+      prismjs: 1.30.0
+      react: 19.2.6
+      refractor: 5.0.0
+
   react@18.3.1:
     dependencies:
       loose-envify: 1.4.0
 
+  react@19.2.6: {}
+
   read-binary-file-arch@1.0.6:
     dependencies:
       debug: 4.4.3
@@ -6181,6 +10045,73 @@ snapshots:
     dependencies:
       picomatch: 2.3.2
 
+  recharts@3.8.1(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react-is@19.2.6)(react@19.2.6)(redux@5.0.1):
+    dependencies:
+      '@reduxjs/toolkit': 2.12.0(react-redux@9.3.0(@types/react@19.2.15)(react@19.2.6)(redux@5.0.1))(react@19.2.6)
+      clsx: 2.1.1
+      decimal.js-light: 2.5.1
+      es-toolkit: 1.47.0
+      eventemitter3: 5.0.4
+      immer: 10.2.0
+      react: 19.2.6
+      react-dom: 19.2.6(react@19.2.6)
+      react-is: 19.2.6
+      react-redux: 9.3.0(@types/react@19.2.15)(react@19.2.6)(redux@5.0.1)
+      reselect: 5.1.1
+      tiny-invariant: 1.3.3
+      use-sync-external-store: 1.6.0(react@19.2.6)
+      victory-vendor: 37.3.6
+    transitivePeerDependencies:
+      - '@types/react'
+      - redux
+
+  redux-thunk@3.1.0(redux@5.0.1):
+    dependencies:
+      redux: 5.0.1
+
+  redux@5.0.1: {}
+
+  refractor@5.0.0:
+    dependencies:
+      '@types/hast': 3.0.4
+      '@types/prismjs': 1.26.6
+      hastscript: 9.0.1
+      parse-entities: 4.0.2
+
+  remark-gfm@4.0.1:
+    dependencies:
+      '@types/mdast': 4.0.4
+      mdast-util-gfm: 3.1.0
+      micromark-extension-gfm: 3.0.0
+      remark-parse: 11.0.0
+      remark-stringify: 11.0.0
+      unified: 11.0.5
+    transitivePeerDependencies:
+      - supports-color
+
+  remark-parse@11.0.0:
+    dependencies:
+      '@types/mdast': 4.0.4
+      mdast-util-from-markdown: 2.0.3
+      micromark-util-types: 2.0.2
+      unified: 11.0.5
+    transitivePeerDependencies:
+      - supports-color
+
+  remark-rehype@11.1.2:
+    dependencies:
+      '@types/hast': 3.0.4
+      '@types/mdast': 4.0.4
+      mdast-util-to-hast: 13.2.1
+      unified: 11.0.5
+      vfile: 6.0.3
+
+  remark-stringify@11.0.0:
+    dependencies:
+      '@types/mdast': 4.0.4
+      mdast-util-to-markdown: 2.1.2
+      unified: 11.0.5
+
   require-directory@2.1.1: {}
 
   require-from-string@2.0.2: {}
@@ -6189,6 +10120,8 @@ snapshots:
     dependencies:
       pe-library: 0.4.1
 
+  reselect@5.1.1: {}
+
   resolve-alpn@1.2.1: {}
 
   resolve-pkg-maps@1.0.0: {}
@@ -6280,6 +10213,21 @@ snapshots:
     dependencies:
       loose-envify: 1.4.0
 
+  scheduler@0.27.0: {}
+
+  selecto@1.26.3:
+    dependencies:
+      '@daybrush/utils': 1.13.0
+      '@egjs/children-differ': 1.0.1
+      '@scena/dragscroll': 1.4.0
+      '@scena/event-emitter': 1.0.5
+      css-styled: 1.0.8
+      css-to-mat: 1.1.1
+      framework-utils: 1.1.0
+      gesto: 1.19.4
+      keycon: 1.4.0
+      overlap-area: 1.1.0
+
   semver-compare@1.0.0:
     optional: true
 
@@ -6289,7 +10237,7 @@ snapshots:
 
   semver@7.7.4: {}
 
-  semver@7.8.0:
+  semver@7.8.1:
     optional: true
 
   send@0.19.2:
@@ -6324,8 +10272,42 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
+  server-only@0.0.1: {}
+
   setprototypeof@1.2.0: {}
 
+  sharp@0.34.5:
+    dependencies:
+      '@img/colour': 1.1.0
+      detect-libc: 2.1.2
+      semver: 7.8.1
+    optionalDependencies:
+      '@img/sharp-darwin-arm64': 0.34.5
+      '@img/sharp-darwin-x64': 0.34.5
+      '@img/sharp-libvips-darwin-arm64': 1.2.4
+      '@img/sharp-libvips-darwin-x64': 1.2.4
+      '@img/sharp-libvips-linux-arm': 1.2.4
+      '@img/sharp-libvips-linux-arm64': 1.2.4
+      '@img/sharp-libvips-linux-ppc64': 1.2.4
+      '@img/sharp-libvips-linux-riscv64': 1.2.4
+      '@img/sharp-libvips-linux-s390x': 1.2.4
+      '@img/sharp-libvips-linux-x64': 1.2.4
+      '@img/sharp-libvips-linuxmusl-arm64': 1.2.4
+      '@img/sharp-libvips-linuxmusl-x64': 1.2.4
+      '@img/sharp-linux-arm': 0.34.5
+      '@img/sharp-linux-arm64': 0.34.5
+      '@img/sharp-linux-ppc64': 0.34.5
+      '@img/sharp-linux-riscv64': 0.34.5
+      '@img/sharp-linux-s390x': 0.34.5
+      '@img/sharp-linux-x64': 0.34.5
+      '@img/sharp-linuxmusl-arm64': 0.34.5
+      '@img/sharp-linuxmusl-x64': 0.34.5
+      '@img/sharp-wasm32': 0.34.5
+      '@img/sharp-win32-arm64': 0.34.5
+      '@img/sharp-win32-ia32': 0.34.5
+      '@img/sharp-win32-x64': 0.34.5
+    optional: true
+
   shebang-command@2.0.0:
     dependencies:
       shebang-regex: 3.0.0
@@ -6418,6 +10400,11 @@ snapshots:
       ip-address: 10.1.0
       smart-buffer: 4.2.0
 
+  sonner@2.0.7(react-dom@19.2.6(react@19.2.6))(react@19.2.6):
+    dependencies:
+      react: 19.2.6
+      react-dom: 19.2.6(react@19.2.6)
+
   source-map-js@1.2.1: {}
 
   source-map-support@0.5.21:
@@ -6427,6 +10414,8 @@ snapshots:
 
   source-map@0.6.1: {}
 
+  space-separated-tokens@2.0.2: {}
+
   sprintf-js@1.1.3:
     optional: true
 
@@ -6456,6 +10445,11 @@ snapshots:
     dependencies:
       safe-buffer: 5.2.1
 
+  stringify-entities@4.0.4:
+    dependencies:
+      character-entities-html4: 2.1.0
+      character-entities-legacy: 3.0.0
+
   strip-ansi@6.0.1:
     dependencies:
       ansi-regex: 5.0.1
@@ -6467,6 +10461,21 @@ snapshots:
   strip-json-comments@2.0.1:
     optional: true
 
+  style-to-js@1.1.21:
+    dependencies:
+      style-to-object: 1.0.14
+
+  style-to-object@1.0.14:
+    dependencies:
+      inline-style-parser: 0.2.7
+
+  styled-jsx@5.1.6(@babel/core@7.29.0)(react@19.2.6):
+    dependencies:
+      client-only: 0.0.1
+      react: 19.2.6
+    optionalDependencies:
+      '@babel/core': 7.29.0
+
   sucrase@3.35.1:
     dependencies:
       '@jridgewell/gen-mapping': 0.3.13
@@ -6474,7 +10483,7 @@ snapshots:
       lines-and-columns: 1.2.4
       mz: 2.7.0
       pirates: 4.0.7
-      tinyglobby: 0.2.16
+      tinyglobby: 0.2.15
       ts-interface-checker: 0.1.13
 
   sumchecker@3.0.1:
@@ -6498,6 +10507,8 @@ snapshots:
       express: 4.22.2
       swagger-ui-dist: 5.32.6
 
+  tailwind-merge@3.6.0: {}
+
   tailwindcss@3.4.17:
     dependencies:
       '@alloc/quick-lru': 5.2.0
@@ -6525,11 +10536,15 @@ snapshots:
     transitivePeerDependencies:
       - ts-node
 
+  tailwindcss@4.3.0: {}
+
+  tapable@2.3.3: {}
+
   tar-fs@2.1.4:
     dependencies:
       chownr: 1.1.4
       mkdirp-classic: 0.5.3
-      pump: 3.0.4
+      pump: 3.0.3
       tar-stream: 2.2.0
     optional: true
 
@@ -6550,14 +10565,6 @@ snapshots:
       minizlib: 3.1.0
       yallist: 5.0.0
 
-  tar@7.5.15:
-    dependencies:
-      '@isaacs/fs-minipass': 4.0.1
-      chownr: 3.0.0
-      minipass: 7.1.3
-      minizlib: 3.1.0
-      yallist: 5.0.0
-
   temp-file@3.4.0:
     dependencies:
       async-exit-hook: 2.0.1
@@ -6580,6 +10587,8 @@ snapshots:
     dependencies:
       semver: 5.7.2
 
+  tiny-invariant@1.3.3: {}
+
   tiny-typed-emitter@2.1.0: {}
 
   tinyglobby@0.2.15:
@@ -6587,11 +10596,6 @@ snapshots:
       fdir: 6.5.0(picomatch@4.0.3)
       picomatch: 4.0.3
 
-  tinyglobby@0.2.16:
-    dependencies:
-      fdir: 6.5.0(picomatch@4.0.4)
-      picomatch: 4.0.4
-
   tmp-promise@3.0.3:
     dependencies:
       tmp: 0.2.5
@@ -6604,6 +10608,10 @@ snapshots:
 
   toidentifier@1.0.1: {}
 
+  trim-lines@3.0.1: {}
+
+  trough@2.2.0: {}
+
   truncate-utf8-bytes@1.0.2:
     dependencies:
       utf8-byte-length: 1.0.5
@@ -6614,6 +10622,8 @@ snapshots:
 
   ts-interface-checker@0.1.13: {}
 
+  tslib@2.8.1: {}
+
   tsx@4.21.0:
     dependencies:
       esbuild: 0.27.3
@@ -6626,6 +10636,8 @@ snapshots:
       safe-buffer: 5.2.1
     optional: true
 
+  tw-animate-css@1.4.0: {}
+
   type-check@0.4.0:
     dependencies:
       prelude-ls: 1.2.1
@@ -6657,6 +10669,16 @@ snapshots:
 
   undici-types@6.21.0: {}
 
+  unified@11.0.5:
+    dependencies:
+      '@types/unist': 3.0.3
+      bail: 2.0.2
+      devlop: 1.1.0
+      extend: 3.0.2
+      is-plain-obj: 4.1.0
+      trough: 2.2.0
+      vfile: 6.0.3
+
   unique-filename@4.0.0:
     dependencies:
       unique-slug: 5.0.0
@@ -6665,6 +10687,29 @@ snapshots:
     dependencies:
       imurmurhash: 0.1.4
 
+  unist-util-is@6.0.1:
+    dependencies:
+      '@types/unist': 3.0.3
+
+  unist-util-position@5.0.0:
+    dependencies:
+      '@types/unist': 3.0.3
+
+  unist-util-stringify-position@4.0.0:
+    dependencies:
+      '@types/unist': 3.0.3
+
+  unist-util-visit-parents@6.0.2:
+    dependencies:
+      '@types/unist': 3.0.3
+      unist-util-is: 6.0.1
+
+  unist-util-visit@5.1.0:
+    dependencies:
+      '@types/unist': 3.0.3
+      unist-util-is: 6.0.1
+      unist-util-visit-parents: 6.0.2
+
   universalify@0.1.2: {}
 
   universalify@2.0.1: {}
@@ -6681,10 +10726,29 @@ snapshots:
     dependencies:
       punycode: 2.3.1
 
+  use-callback-ref@1.3.3(@types/react@19.2.15)(react@19.2.6):
+    dependencies:
+      react: 19.2.6
+      tslib: 2.8.1
+    optionalDependencies:
+      '@types/react': 19.2.15
+
+  use-sidecar@1.1.3(@types/react@19.2.15)(react@19.2.6):
+    dependencies:
+      detect-node-es: 1.1.0
+      react: 19.2.6
+      tslib: 2.8.1
+    optionalDependencies:
+      '@types/react': 19.2.15
+
   use-sync-external-store@1.6.0(react@18.3.1):
     dependencies:
       react: 18.3.1
 
+  use-sync-external-store@1.6.0(react@19.2.6):
+    dependencies:
+      react: 19.2.6
+
   utf8-byte-length@1.0.5: {}
 
   util-deprecate@1.0.2: {}
@@ -6695,6 +10759,15 @@ snapshots:
 
   vary@1.1.2: {}
 
+  vaul@1.1.2(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6):
+    dependencies:
+      '@radix-ui/react-dialog': 1.1.15(@types/react-dom@19.2.3(@types/react@19.2.15))(@types/react@19.2.15)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      react: 19.2.6
+      react-dom: 19.2.6(react@19.2.6)
+    transitivePeerDependencies:
+      - '@types/react'
+      - '@types/react-dom'
+
   verror@1.10.1:
     dependencies:
       assert-plus: 1.0.0
@@ -6702,7 +10775,34 @@ snapshots:
       extsprintf: 1.4.1
     optional: true
 
-  vite@6.1.0(@types/node@22.19.13)(jiti@2.6.1)(tsx@4.21.0)(yaml@2.9.0):
+  vfile-message@4.0.3:
+    dependencies:
+      '@types/unist': 3.0.3
+      unist-util-stringify-position: 4.0.0
+
+  vfile@6.0.3:
+    dependencies:
+      '@types/unist': 3.0.3
+      vfile-message: 4.0.3
+
+  victory-vendor@37.3.6:
+    dependencies:
+      '@types/d3-array': 3.2.2
+      '@types/d3-ease': 3.0.2
+      '@types/d3-interpolate': 3.0.4
+      '@types/d3-scale': 4.0.9
+      '@types/d3-shape': 3.1.8
+      '@types/d3-time': 3.0.4
+      '@types/d3-timer': 3.0.2
+      d3-array: 3.2.4
+      d3-ease: 3.0.1
+      d3-interpolate: 3.0.1
+      d3-scale: 4.0.2
+      d3-shape: 3.2.0
+      d3-time: 3.1.0
+      d3-timer: 3.0.1
+
+  vite@6.1.0(@types/node@22.19.13)(jiti@2.6.1)(lightningcss@1.32.0)(tsx@4.21.0)(yaml@2.9.0):
     dependencies:
       esbuild: 0.24.2
       postcss: 8.5.1
@@ -6711,6 +10811,7 @@ snapshots:
       '@types/node': 22.19.13
       fsevents: 2.3.3
       jiti: 2.6.1
+      lightningcss: 1.32.0
       tsx: 4.21.0
       yaml: 2.9.0
 
@@ -6756,8 +10857,6 @@ snapshots:
 
   ws@8.18.3: {}
 
-  ws@8.20.1: {}
-
   xmlbuilder@15.1.1: {}
 
   xmlhttprequest-ssl@2.1.2: {}
@@ -6792,3 +10891,5 @@ snapshots:
   yocto-queue@0.1.0: {}
 
   zod@4.3.6: {}
+
+  zwitch@2.0.4: {}
diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml
index b9302139..a85448c1 100644
--- a/pnpm-workspace.yaml
+++ b/pnpm-workspace.yaml
@@ -9,6 +9,9 @@ minimumReleaseAge: 10080
 # Our own internal packages ship frequently and are trusted — exempt from the
 # 7-day quarantine so we can consume new versions immediately.
 minimumReleaseAgeExclude:
+  # Temporary while Desktop consumes newly published design-system prereleases
+  # directly from GitHub Packages during the FEA-1497 migration.
+  - "@closedloop-ai/design-system"
   - "@closedloop-ai/loops-api"
   # External, but exempted deliberately (PRD-414 / FEA-1431). We pin
   # @pydantic/genai-prices to an EXACT version (no semver range) so this