diff --git a/docs/ADR-004-same-origin-embed-proxy.md b/docs/ADR-004-same-origin-embed-proxy.md
new file mode 100644
index 0000000..84e5e29
--- /dev/null
+++ b/docs/ADR-004-same-origin-embed-proxy.md
@@ -0,0 +1,60 @@
+# ADR-004: Same-origin embed reverse-proxy (no iframes)
+
+- **Status:** Accepted (Phase 4a); Embed v2 mount → [ADR-004b](./ADR-004b-embed-v2-same-document-mount.md)
+- **Date:** 2026-09-18
+- **Deciders:** Ben / skill-shell rationalization charter
+
+## Context
+
+Switchbay hosts Graph (curiosity-engine atlas/wiki) and Agents (okstratr
+observer/desk) surfaces. Cross-origin iframes pointed at
+`127.0.0.1:8766` / `:8767` break hosted-mode control (okstratr HTML
+settings must hide when `host=switchbay`) and create an opaque nested
+browsing context.
+
+Charter locked decision #1: shells **same-origin reverse-proxy** skill
+daemons; in-app panels load first-party proxied routes — **not nested
+frames**.
+
+## Decision
+
+1. **Daemon reverse-proxy** (always on; independent of the UI flag):
+   - `/embed/ce/*` → `http://127.0.0.1:8766/*` (override:
+     `SWITCHBAY_CE_UPSTREAM`, must remain loopback)
+   - `/embed/okstratr/*` → `http://127.0.0.1:8767/*` (override:
+     `SWITCHBAY_OKSTRATR_UPSTREAM`, must remain loopback)
+   - Upstream allowlist is **loopback-only** (`127.0.0.1` / `::1` /
+     `localhost`). Non-loopback upstreams are rejected (502).
+   - Inject hosted-shell headers on every proxied request:
+     - `X-CE-Host: switchbay`
+     - `X-Okstratr-Host: switchbay`
+
+2. **No iframes** for Graph/Agents skill surfaces. Feature flag
+   `proxied_skill_embeds` (default **false**) switches Graph → CE panel
+   and Agents → okstratr panel that navigate `/embed/*` via same-origin
+   `fetch` + same-document rendering. Phase 4a was script-stripped HTML / JSON; Embed v2 (ADR-004b) executes skill scripts in-panel.
+   Built-in GraphTab / AgentDashboardTab / filebrowser remain the
+   default and are **not deleted**.
+
+3. **Settings → okstratr registry (done — ADR-005).** Switchbay settings
+   is a thin client over okstratr's harness/model registry
+   (`harnesses.toml` via `/api/okstratr/harness…` / embed proxy). No
+   second Switchbay allowlist. See
+   [ADR-005](./ADR-005-okstratr-harness-registry-client.md).
+
+## Consequences
+
+- Dev Vite must proxy `/embed` to the daemon (`vite.config.ts`).
+- CE and okstratr should honor public-base + `X-*-Host` (okstratr
+  Phase 1a `public_base.py`; CE equivalent TBD).
+- Full atlas/observer chrome parity is gated by the parity checklist
+  before any Switchbay duplicate deletion (Phase 4b+).
+- WebSocket upgrade through the embed proxy is deferred; HTTP(S) first.
+
+## Alternatives considered
+
+| Option | Why not |
+|--------|---------|
+| Cross-origin iframe to :8766/:8767 | Opaque origin; hosted settings leak; charter forbid |
+| Same-origin iframe to `/embed/*` | Still a nested frame; charter: no iframes |
+| Delete built-in Graph/Agents now | Violates parity checklist / dual-stack gate |
diff --git a/docs/ADR-004b-embed-v2-same-document-mount.md b/docs/ADR-004b-embed-v2-same-document-mount.md
new file mode 100644
index 0000000..ec018ef
--- /dev/null
+++ b/docs/ADR-004b-embed-v2-same-document-mount.md
@@ -0,0 +1,78 @@
+# ADR-004b: Embed v2 — same-document interactive mount
+
+- **Status:** Accepted (Embed v2)
+- **Date:** 2026-09-19
+- **Parent:** [ADR-004](./ADR-004-same-origin-embed-proxy.md)
+- **Contract:** umbrella `CONTRACT-EMBED-V2.md`
+
+## Context
+
+Phase 4a (`ProxiedSkillPanel`) fetched `/embed/*` HTML and injected a
+**script-stripped** body. That proved the reverse-proxy path but left Graph
+and Agents inert (no pan/zoom, no desk controls). Charter + ADR-004 forbid
+`<iframe>` / nested frames for skill surfaces.
+
+CE and okstratr already honor `CE_PUBLIC_BASE` / `OKSTRATR_PUBLIC_BASE`
+(`_/embed/ce_`, `_/embed/okstratr_`) and inject `window.*_PUBLIC_BASE` so
+API helpers resolve under the proxy. Relative asset tags (`static/main.js`,
+`observer.css`) still need rewriting when the HTML is mounted into a
+Switchbay panel rather than navigated as a top-level document.
+
+## Decision
+
+**Same-document microfrontend mount** (no nested browsing context):
+
+1. **Wait chrome first.** While the panel is open, poll
+   `GET /api/core-skills/status` (~2s). Banner states: `starting` /
+   `unhealthy` / `building_wiki` / `live`. Do **not** flash a full 502
+   error while the supervisor is still `starting` or `stopped` —
+   status chrome explains the wait (`suppressFetchError`).
+2. **Fetch** proxied HTML from `/embed/ce/…` or `/embed/okstratr/…` only
+   when the skill slice is `healthy` (`allowMount`).
+3. **Rewrite** relative / root-relative / loopback asset URLs onto the
+   public base (`frontend/src/widgets/embed/embedMount.ts`).
+4. **Extract** `<script>` tags (classic + `type=module`); inject remaining
+   markup (body + head stylesheets) into a dedicated panel root via
+   `innerHTML`.
+5. **Execute** scripts by `document.createElement("script")` + append
+   (with rewritten `src`, or inline `textContent`). Browsers never run
+   scripts inserted via `innerHTML` alone.
+6. **Tear down** before soft-reload (`sy:files-changed`) or unmount:
+   remove tracked script nodes and clear the panel root so listeners /
+   duplicate roots do not accumulate.
+7. **JSON** responses keep the pretty-print path (no script mount).
+
+Built-in `GraphTab` is **not** deleted (parity checklist / Ben lock).
+
+## Consequences
+
+- Interactive CE / okstratr chrome can run under `/embed/*` without iframes.
+- Skill UIs share the Switchbay document: global ID collisions and
+  `document`-level assumptions are residual risks; skills should prefer
+  scoped queries when possible.
+- **WebSocket upgrade** through the embed proxy remains deferred (HTTP
+  first). Live features that require WS may be limited until proxyed.
+- Unit tests cover URL rewrite, script extraction, and status-banner
+  mapping (`embedMount.test.ts`).
+
+## Alternatives considered
+
+| Option | Why not |
+|--------|---------|
+| Keep script-stripping | Inert UI; fails Embed v2 acceptance |
+| Same-origin `<iframe src="/embed/…">` | Nested frame; charter / ADR-004 forbid |
+| `srcdoc` iframe | Still a nested browsing context |
+| Shadow DOM isolation | Extra complexity; CE/okstratr expect light DOM + `getElementById` |
+
+## Mount algorithm (short)
+
+```
+poll status → if !healthy: banner only
+else:
+  teardown prior mount
+  html = fetch(/embed/…/)
+  { markup, scripts } = prepareEmbedHtml(html, publicBase, pagePath)
+  root.innerHTML = markup
+  for s in scripts: createElement(script); set src|text; append; await load
+on files_changed / unmount: teardown
+```
diff --git a/docs/ADR-005-okstratr-harness-registry-client.md b/docs/ADR-005-okstratr-harness-registry-client.md
new file mode 100644
index 0000000..2b2b095
--- /dev/null
+++ b/docs/ADR-005-okstratr-harness-registry-client.md
@@ -0,0 +1,57 @@
+# ADR-005: Settings → okstratr harness registry (SSOT client)
+
+- **Status:** Accepted
+- **Date:** 2026-09-19
+- **Parent:** [ADR-004](./ADR-004-same-origin-embed-proxy.md) (Settings TODO)
+- **Deciders:** Ben / skill-shell rationalization charter
+
+## Context
+
+okstratr owns the harness+model registry (`~/.config/okstratr/harnesses.toml`
+via `GET/POST /api/harness…`). Charter: shells are **config UIs** over that
+registry — no second Switchbay allowlist. Hosted mode
+(`X-Okstratr-Host: switchbay`) already disables okstratr HTML settings, so
+Switchbay Settings must become the write path.
+
+## Decision
+
+1. **Thin client module** `switchbay.okstratr_harness`:
+   - Server-side calls loopback `SWITCHBAY_OKSTRATR_UPSTREAM`
+     (default `http://127.0.0.1:8767`) with hosted-shell header.
+   - Loopback guard reused from `embed_proxy` (non-loopback → 502).
+   - `normalize_registry()` maps okstratr `list_for_api` JSON; never
+     invents an allowlist.
+   - Browser may also hit same-origin `/embed/okstratr/api/harness…`.
+
+2. **Daemon routes** (shells/UI need not know embed paths):
+   - `GET  /api/okstratr/harness`
+   - `POST /api/okstratr/harness/enable`   `{ "id": "…" }`
+   - `POST /api/okstratr/harness/disable`  `{ "id": "…" }`
+   - `POST /api/okstratr/harness/set`      `{ "key": "…", "value": "…" }`
+   - `POST /api/okstratr/harness/reload`
+
+3. **Settings UI** — section **Harness registry · okstratr**: list rows,
+   enable/disable, set `harness.<id>.default_model`. Existing Pi / local
+   LLM panels remain as **rail** surfaces and are labeled as not the
+   desk/agent SSOT.
+
+4. **okbay** mirrors the same thin-client pattern (doc note; full UI
+   follow-up) — see okbay `docs/HERDR-AND-REGISTRY.md` and Switchbay
+   `/api/okstratr/host-notify` as the precedent for path-native okstratr
+   integration.
+
+## Consequences
+
+- okstratr must be healthy (core-skill supervisor) for Settings toggles
+  to succeed; UI surfaces a clear 502 when upstream is down.
+- No `harnesses.toml` (or equivalent) under Switchbay state dirs.
+- Pi harness (`/api/llm/harness`) and local LLM panels stay Switchbay-local
+  for rail chat; they must not claim desk registry ownership.
+
+## Alternatives considered
+
+| Option | Why not |
+|--------|---------|
+| Copy allowlist into Switchbay `app_settings` | Second SSOT; charter forbid |
+| Settings UI calls `:8767` cross-origin | Breaks hosted-mode headers / CORS |
+| Only document CLI (`okstratr harness …`) | Users need in-app toggles when HTML settings are hosted-off |
diff --git a/docs/ADR-006-ce-pack-run-drain.md b/docs/ADR-006-ce-pack-run-drain.md
new file mode 100644
index 0000000..5ff6929
--- /dev/null
+++ b/docs/ADR-006-ce-pack-run-drain.md
@@ -0,0 +1,54 @@
+# ADR-006: CE pack-queue → Switchbay rail LLM drain
+
+- **Status:** Accepted
+- **Date:** 2026-09-19
+- **Parent:** skill-shell rationalization (CE filebrowser packs Phase 2b)
+- **Deciders:** Ben / skill-shell rationalization charter
+
+## Context
+
+Curiosity Engine's proxied filebrowser accepts
+`POST /api/packs/<pack>/action/<action>` and, after sandbox checks,
+writes only:
+
+```text
+.workbench/pack-runs/<run_id>.json   # status: "queued"
+```
+
+It does **not** seat an LLM agent. Switchbay already has
+`handle_pack_action` which seats `_dispatch_chat` with skill
+`<pack>-<action>`, but the CE path never hits that handler — so
+CE-queued runs stayed `queued` forever.
+
+Both processes share the workspace tree, so the queue files are the
+handoff surface.
+
+## Decision
+
+1. **Switchbay drains the shared JSON** (no CE `PATCH` required).
+   Module `switchbay.pack_run_drain`:
+   - `list_queued_runs` / `write_run_status` (atomic JSON rewrite)
+   - `build_pack_prompt` — same text as `handle_pack_action`
+   - `drain_once` — validate pack enabled + skill exists, mark
+     `running`, spawn `_dispatch_chat` (injectable for tests), on
+     task completion mark `done` / `failed`
+   - In-memory `app["pack_run_inflight"]` dedupes concurrent drains
+
+2. **Triggers**
+   - Background poll every ~4s while
+     `<workspace>/.workbench/pack-runs/` exists
+   - Explicit `POST /api/packs/drain` → `{drained, skipped, errors}`
+   - Opportunistic kick from `_broadcast_files_changed_soon` when
+     the pack-runs dir is present
+
+3. **Out of scope (this ADR):** reveal-in-OS, drop-ingest, rewriting
+   CE's queue writer, and refactoring `handle_pack_action` to also
+   write pack-runs JSON (nice-to-have; CE files are the required
+   consumer).
+
+## Consequences
+
+- CE remains the sandbox/accept edge; Switchbay remains the skill/LLM
+  seat. Status fields on the shared JSON are the cross-process progress
+  UI.
+- Tests mock `dispatch_fn` — no paid model seats in CI.
diff --git a/docs/ADR-007-ce-ingest-run-drain.md b/docs/ADR-007-ce-ingest-run-drain.md
new file mode 100644
index 0000000..b08b4a3
--- /dev/null
+++ b/docs/ADR-007-ce-ingest-run-drain.md
@@ -0,0 +1,60 @@
+# ADR-007: CE ingest-queue → Switchbay local_ingest / rail drain
+
+- **Status:** Accepted
+- **Date:** 2026-09-20
+- **Parent:** skill-shell rationalization (CE drop-ingest + pack-run drain parity)
+- **Related:** ADR-006 (CE pack-queue → rail LLM drain)
+- **Deciders:** Ben / skill-shell rationalization charter
+
+## Context
+
+Curiosity Engine's drop-ingest (`POST /api/ingest/from-upload` /
+`from-path`, filebrowser + `/embed/ce/`) stages bytes under
+`vault/raw/` and writes only:
+
+```text
+.workbench/ingest-runs/<run_id>.json   # status: "queued", mode: "staged"
+```
+
+It does **not** run `local_ingest.py` or seat an LLM agent. Pack-runs
+already drain via Switchbay (`POST /api/packs/drain`, ADR-006). Without
+a sibling drain, ingest-runs sit `queued` forever after drop.
+
+Both processes share the workspace tree, so the queue files are the
+handoff surface.
+
+## Decision
+
+1. **Switchbay drains the shared JSON** (no CE `PATCH` required).
+   Module `switchbay.ingest_run_drain`:
+   - `list_queued_runs` / `write_run_status` (atomic JSON rewrite)
+   - `resolve_run_vault_path` — refuse workspace escape / null bytes
+   - Prefer **deterministic** `local_ingest` (`ce_tools._ce_ingest`)
+     for normal vault sources (`mode: staged` and peers)
+   - Escalate to `_dispatch_chat` only when metadata opts in
+     (`mode`/`drain` ∈ {llm,rail,agent,dispatch} or
+     `prefer_rail` / `use_llm` truthy)
+   - `drain_once` — mark `running`, spawn local or rail task, on
+     completion mark `done` / `failed`
+   - In-memory `app["ingest_run_inflight"]` dedupes concurrent drains
+
+2. **Triggers**
+   - Background poll every ~4s while
+     `<workspace>/.workbench/ingest-runs/` exists
+   - Explicit `POST /api/ingest/drain` → `{drained, skipped, errors}`
+   - Opportunistic kick from `_broadcast_files_changed_soon` when
+     the ingest-runs dir is present
+
+3. **Out of scope:** rewriting CE's queue writer, changing
+   Switchbay's own multipart `/api/ingest/from-upload` (still seats
+   rail immediately for non-CE uploads), multimodal CURATE waves.
+
+## Consequences
+
+- CE remains the sandbox/stage edge; Switchbay remains the ingest
+  executor. Status fields on the shared JSON are the cross-process
+  progress UI.
+- Default path stays cheap (no paid model seats). LLM only when the
+  run record asks for it.
+- Tests mock `local_ingest_fn` / `dispatch_fn` — no CE binary or paid
+  model seats in CI.
diff --git a/docs/ADR-008-workspace-sandbox-roots.md b/docs/ADR-008-workspace-sandbox-roots.md
new file mode 100644
index 0000000..471ac5c
--- /dev/null
+++ b/docs/ADR-008-workspace-sandbox-roots.md
@@ -0,0 +1,25 @@
+# ADR-008: Workspace sandbox roots (stage-5 home rule + box `/workspace`)
+
+**Status:** Accepted  
+**Date:** 2026-09-20  
+**Context:** Stage-5 restricted workspace paths to `$HOME` so file-ops /
+cebridge never get a cwd of `/`, `/etc`, etc. On the Grok Bot box,
+corpora live under `/workspace` (e.g. `/workspace/ce-cb-biocure`).
+`Path.resolve()` follows symlinks, so a `~/Workspaces/...` symlink still
+failed `is_within_home`; E2E had to `unshare`+bind-mount under home.
+
+**Decision:** Keep the stage-5 sandbox, but allow a small explicit set of
+roots via `allowed_workspace_roots()`:
+
+1. Always `Path.home()`.
+2. `/workspace` when that directory exists (agent-box scratch).
+3. Extra dirs from `SWITCHBAY_WORKSPACE_ROOTS` (`os.pathsep`-separated;
+   expanduser + resolve; skip missing / non-dirs).
+
+`is_within_home(path)` (name retained for call sites) returns true iff
+the resolved path is under any of those roots. Error copy uses
+`home_label()` → e.g. `must live inside /home/box or /workspace`.
+
+**Consequences:** Box corpora register without bind-mount workarounds.
+`/etc`, `/tmp`, `/`, and `..` escapes remain refused unless an operator
+deliberately adds a root via the env var.
diff --git a/docs/CE-EMBED-HOOK.md b/docs/CE-EMBED-HOOK.md
new file mode 100644
index 0000000..146ada6
--- /dev/null
+++ b/docs/CE-EMBED-HOOK.md
@@ -0,0 +1,84 @@
+# CE embed hook — dual mounts (shell sidebar + Graph canvas)
+
+**Date:** 2026-09-27 (updated)  
+**Owners:** Switchbay (mount scaffolding) · CE Benchmarker (CE `embed` mode)
+
+## Goal
+
+- **Shell left column** hosts the **CE sidebar** (Pages | Files + search that
+  highlights both list and canvas) — **persistent** across Graph / Agents /
+  Editor for CE-backed workspaces.
+- **Graph pane** hosts **only the CE atlas canvas** (+ in-canvas graph-search).
+- **One CE embed session**, **two mount points**, shared `data.json` /
+  module state — same-origin, no iframe, no full-document HTML remount.
+- Switchbay keeps tabs, rail, Agents, theme/mode footer. Non-CE / proxied-off
+  workspaces keep native WikiPane + Files|Sources.
+
+## Do not
+
+- Keep Pages only inside the Graph tab (must persist across tabs).
+- Rebuild Switchbay’s sidebar to imitate CE Pages (search-highlight debt).
+- Run two page lists at once.
+
+## Switchbay scaffolding (landed)
+
+| Piece | Role |
+|-------|------|
+| `ceEmbedSession.ts` | Singleton session: `ensure()` → load `/embed/ce` modules + `data.json`; `attachSidebar` / `attachCanvas` / detach; survives Graph unmount |
+| `CeSidebarSlot.tsx` | Shell-left mount (`#ce-sidebar-root`) when `proxied_skill_embeds` |
+| `CeAtlasEmbed.tsx` | Graph tab canvas (`#graph-root`); soft-parks atlas on tab leave (instant return) |
+| `ceEmbedBootstrap.ts` | `prepareSession()`, script order, fetch shim, `window.CEEmbed` prefer |
+| `ceSidebarShell.html` / `ceEmbedShell.html` | DOM fragments (aside vs graph-pane+modal) |
+
+`Sidebar.tsx`: proxied on → `CeSidebarSlot` (full-height); proxied off →
+WikiPane + Files|Sources as before. Workspace remount calls
+`resetCeEmbedSession()`.
+
+## CE hook to add (CE Benchmarker)
+
+```js
+window.CEEmbed = {
+  /**
+   * Preferred: create a session, then attach external mounts.
+   * @param {{
+   *   embed: true,
+   *   dataUrl: string,       // "/embed/ce/data.json"
+   *   publicBase: string,    // "/embed/ce"
+   *   chrome?: boolean,      // shell owns theme/rail; CE chrome minimal
+   * }} opts
+   */
+  async create(opts) {
+    return {
+      /** Mount CE Pages|Files sidebar into Switchbay's left column. */
+      mountSidebar(el) { /* Sidebar.init + FileBrowser; search↔canvas */ },
+      /** Mount atlas canvas (+ graph-search) into #graph-root. */
+      mountCanvas(el) { /* AtlasViewer / Graph; share session data */ },
+      destroy() { /* tear both; leave Switchbay fetch/body clean */ },
+    };
+  },
+};
+```
+
+Requirements:
+
+- Single shared state / `data.json` for both mounts.
+- Sidebar search highlights **list + canvas** (existing GraphSearch wiring).
+- `mountCanvas` may be called after `mountSidebar`. Leaving Graph should
+  **soft-park** the canvas (`unmountCanvas()` default) — keep atlas/simulation
+  + loaded data alive off-DOM; return calls `mountCanvas` again for **instant
+  reattach** (no N>10k layout). Pass `unmountCanvas({ destroy: true })` only
+  for hard teardown. Optional `revalidate()` refreshes `data.json` in the
+  background after reattach.
+- Honor `CE_PUBLIC_BASE` / `opts.dataUrl`.
+- Optional: `mount({ mounts: { sidebar, canvas } })` one-shot still OK.
+
+Until `CEEmbed.create` exists, Switchbay’s stub loads CE static modules and
+calls `Sidebar.init` + `AtlasViewer`/`Graph`/`GraphSearch` itself.
+
+## Verify
+
+- Pages list visible on Agents and Editor (not only Graph).
+- One page list (CE), not WikiPane + CE.
+- Graph = atlas canvas; rail right-docked; Agents not stuck Loading.
+- Leave Graph → Agents → back Graph is **instant** (no "Loading Curiosity Engine atlas…" / no 20s layout).
+- `/embed/ce/data.json` and `/api/graph/data` still serve BioCure nodes+edges.
diff --git a/docs/handoff/2026-09-20-skill-shell-parity.md b/docs/handoff/2026-09-20-skill-shell-parity.md
index 1f063c9..ab667a1 100644
--- a/docs/handoff/2026-09-20-skill-shell-parity.md
+++ b/docs/handoff/2026-09-20-skill-shell-parity.md
@@ -1,26 +1,56 @@
-# Skill-shell parity gates — v0.12.19 release baseline
+# Skill-shell rationalization gates — Switchbay v0.12.19
 
-**Not a claim that skill-shell rework already has parity.** This is the
-released contract for later work that **imports** curiosity-engine,
-curiosity-merge, and okstratr instead of vendoring or duplicating their
-servers. ADR-004 vocabulary (same-origin `/embed/ce` + `/embed/okstratr`,
-no iframes, okstratr owns harness/model registry) describes that shell,
-not this tag.
+**Charter position:** Switchbay v0.12.19 is a **behavior/performance gate under
+the import charter**, not a source-parity, source-merge, or implementation
+plan. Switchbay and okbay import and invoke the CE, curiosity-merge (CM), and
+okstratr skills through their public skill contracts. They must **not vendor
+their servers, merge their source, copy their internals, or re-implement them
+for either shell**. The shell owns its adapter/UI policy; the skills remain
+the owners of their behavior and services.
+
+This document records the v0.12.19 release behavior matrix and the additional
+gates for imported skills. Passing it means observable behavior and measured
+performance are compatible at the import boundary; it does not certify a
+particular internal implementation.
 
 Release notes: [v0.12.19](../releases/v0.12.19.md)
 
-**Body retrieval** = full message content beyond headers/labels. Allowed
-only after explicit per-workspace approval **and** a fresh classification
-gate. Revoke halts future body updates.
+## Pinned inputs
+
+- **CE skill:** `5d2b967558dd052c62b23fbc03217b1ac2a18d5a` (short
+  `5d2b967`), the exact CE skill commit for this gate.
+- **BioCure wiki fixture:** `biocure-confirm-v1-query-5b9711895`, freeze tip
+  `5b9711895` (full SHA unavailable in this checkout). This is a wiki/corpus
+  fixture pin, **not** the CE skill SHA.
+- **Switchbay release:** tag `v0.12.19`, commit
+  `bbc94062b209653178b97613876bd2c59c9e4783`.
+
+CM and okstratr versions must be recorded from their imported skill artifacts
+when those integrations are exercised; do not infer them from the Switchbay
+release SHA.
+
+## Behavior and performance gate
+
+**Body retrieval** = full message content beyond headers/labels. Allowed only
+after explicit per-workspace approval **and** a fresh classification gate.
+Revoke halts future body updates.
 
-**Verified paid Curate:** 18.87s, 10,811 tokens, 237-word
-committed page. **Fake stress (distinct):**
+The v0.12.19 release evidence is the behavior baseline. The import gate must
+exercise the same observable contracts through the imported skills and record
+cold/warm startup, readiness, CE ingest/query, CM preview/import/rollback, and
+okstratr desk lifecycle timings plus resource context. A gate result is
+**pass**, **fail**, or **not run** with the pinned skill and BioCure fixture
+identified; do not call an unmeasured integration “parity.” Unexplained
+behavioral or performance regressions fail the gate.
+
+**Verified paid Curate baseline:** 18.87s, 10,811 tokens, 237-word committed
+page. **Fake stress (distinct):**
 `test_curate_scheduler.py::test_thousand_productive_waves_unique_ids_resume`
 (≥1005 `execute()` completions).
 
-**Limitations:** live iCloud placeholder not tested; Comms fixtures are
-not an enterprise-tenant certification. Integration coverage depends on
-installed CE and the optional PDF/XLSX extractor environment; report skips.
+**Limitations:** live iCloud placeholder not tested; Comms fixtures are not an
+enterprise-tenant certification. Integration coverage depends on installed CE
+and the optional PDF/XLSX extractor environment; report skips.
 
 | Behavior | Evidence / tests |
 |---|---|
@@ -32,15 +62,19 @@ installed CE and the optional PDF/XLSX extractor environment; report skips.
 | Live cap floor 4 / default and hard 8, chief counted, admin tightens; continuous waves; no early stop; retired workers absent from live DAG | `test_desk_admission.py` (`test_cap_floor_and_admin_tightening`, `test_baked_tightens_not_raises`, `test_chief_counted_and_nested_share_desk`, `test_continuous_progress_after_compaction`); `test_admin_policy.py` (`test_max_live_workers_*`); `test_curate_lifecycle.py` (`test_curate_continue_is_package_wave_not_generic`, `test_continuous_second_wave_then_stop`); `test_comms_desks_review.py::test_retired_thousand_workers_do_not_remain_live_roster`; `test_release_acceptance.py::test_completed_single_use_worker_leaves_actual_parent_graph` |
 | Real content receipts; partial-result preservation; idle no LLM spin | `test_curate_content_receipts.py`; `test_curate_evidence.py`; `test_curate_scheduler.py` (`test_noop_curate_waits_without_llm`, `test_noop_curate_deadline_stops_idle_wait`); `test_comms_desks_review.py::test_real_transport_failure_keeps_partial_output` |
 | PPTX fallback preserving workspace PDF/XLSX; cloud single-file hydrate/retry/auth | `test_pptx_ingest.py` (`test_host_python_has_pptx_and_workspace_venv_can_lack_it`, `test_xlsx_pdf_prefer_workspace_venv_that_has_extractors`, mixed/corrupt); `test_icloud_download.py`; `test_watchfolders.py` (`test_hydration_pending_then_ready_exactly_once`, `test_dispatch_uses_workspace_captured_at_scan`); `test_watch_review.py` |
-| Skills missing/present/read-only; versioned integration; registry ownership; no duplicate server impl | `test_skillkit_authoring.py` (`test_symlinked_bundled_skill_is_not_writable`, `test_discovers_agents_skills_without_claude_dir`); `test_ce_global_fallback.py`; `test_updater.py` (`test_local_skill_version_from_changelog_when_not_git`, `test_find_skill_dir_uses_global_roots`, `test_match_skill_release_walks_older_tags`); `test_admin_policy.py` (`test_skills_allowlist`, `test_list_providers_hides_disabled`); `test_kernel_hire.py::test_denied_model_is_not_proposed`. Rework gate: import CE/merge/okstratr; do not vendor their HTTP servers or grow a second model allowlist. |
-
-Keep these tests green (or replace with equivalent external-skill contracts)
-before deleting built-in Graph/Agents duplicates. Do not copy pre-0.12.19
-architecture.
-
-For each imported skill, record its version and verify discovery, missing-skill
-errors, its public API, and unchanged installed files. Exercise CE ingest/query,
-curiosity-merge preview/import/rollback, and okstratr desk lifecycle through the
-shell. Check workspace/model policy at those boundaries and keep a single
-registry. These are **additional rework acceptance gates**; the release tests
-above do not certify the three-skill integration.
+| Skills missing/present/read-only; versioned integration; registry ownership; no duplicate server implementation | `test_skillkit_authoring.py` (`test_symlinked_bundled_skill_is_not_writable`, `test_discovers_agents_skills_without_claude_dir`); `test_ce_global_fallback.py`; `test_updater.py` (`test_local_skill_version_from_changelog_when_not_git`, `test_find_skill_dir_uses_global_roots`, `test_match_skill_release_walks_older_tags`); `test_admin_policy.py` (`test_skills_allowlist`, `test_list_providers_hides_disabled`); `test_kernel_hire.py::test_denied_model_is_not_proposed` |
+
+## Import-boundary acceptance
+
+For each imported skill, record its artifact/version and verify discovery,
+missing-skill errors, public API behavior, and unchanged installed files.
+Exercise CE ingest/query, CM preview/import/rollback, and okstratr desk
+lifecycle through the shell, using the pinned CE skill and BioCure fixture.
+Check workspace/model policy at those boundaries and keep one registry. These
+are **additional import-boundary acceptance gates**; the v0.12.19 release
+tests above do not certify the three-skill integration.
+
+Do not use this matrix as permission to merge CE/CM/okstratr source into
+Switchbay or okbay, vendor their servers, or grow shell-specific rewrites.
+Any retirement of pre-import duplicate shell behavior is a separate decision
+after the imported-skill behavior/performance gate passes.
diff --git a/docs/releases/v0.12.19.md b/docs/releases/v0.12.19.md
index ce3a09a..a618a2b 100644
--- a/docs/releases/v0.12.19.md
+++ b/docs/releases/v0.12.19.md
@@ -67,4 +67,10 @@ Then hard-reload the installed PWA. If slideshow PDF or CLI tools still miss Nod
 
 Installed curiosity-engine integration checks run when that optional dependency is present. Cloud-state fixtures and the native macOS API check do not replace a live iCloud or enterprise-tenant deployment test.
 
-Skill-shell rework gates (import curiosity-engine / curiosity-merge / okstratr; do not vendor their servers) are recorded as a **release baseline**, not as already-met parity: [2026-09-20-skill-shell-parity.md](../handoff/2026-09-20-skill-shell-parity.md).
+Skill-shell rationalization is an **import-charter behavior/performance gate**,
+not source parity: Switchbay and okbay import the CE, curiosity-merge, and
+okstratr skills through public contracts. They do not vendor, merge, copy, or
+re-implement those servers for a shell. The gate pins CE skill
+`5d2b967558dd052c62b23fbc03217b1ac2a18d5a` and uses BioCure wiki fixture
+`biocure-confirm-v1-query-5b9711895` at freeze tip `5b9711895`; the latter is a
+wiki/corpus pin, not the CE skill SHA. See the [import-boundary matrix](../handoff/2026-09-20-skill-shell-parity.md).
diff --git a/frontend/src/App.tsx b/frontend/src/App.tsx
index c837a54..0d5ffbf 100644
--- a/frontend/src/App.tsx
+++ b/frontend/src/App.tsx
@@ -996,8 +996,21 @@ export default function App() {
           }
           return prev;
         });
+      } else if (msg.type === "graph_progress") {
+        const gp = msg as {
+          message?: string; done?: boolean; workspace?: string;
+        };
+        // Ignore progress for a different workspace (hover-prefetch).
+        if (gp.workspace && focusedWsRef.current && gp.workspace !== focusedWsRef.current) {
+          return;
+        }
+        window.dispatchEvent(new CustomEvent("sy:graph-progress", {
+          detail: gp,
+        }));
       } else if (msg.type === "files_changed") {
         setFilesVersion((v) => v + 1);
+        // Proxied Graph/Agents panels listen for this to soft-refetch /embed/*.
+        window.dispatchEvent(new CustomEvent("sy:files-changed"));
       } else if (msg.type === "artifact") {
         // Pend a pulse badge (Zen) AND switch to the surface the
         // agent just wrote — sheet/plot requests used to finish
@@ -1520,6 +1533,9 @@ export default function App() {
   useEffect(() => {
     setGraphData(null);
     setGraphError(null);
+    window.dispatchEvent(new CustomEvent("sy:graph-progress", {
+      detail: { message: "Loading graph from cache…", done: false },
+    }));
   }, [workspace]);
 
   // Graph tab's "Retry" affordance (timeout / build failure) → re-run
diff --git a/frontend/src/center/builtinTabs.tsx b/frontend/src/center/builtinTabs.tsx
index 5ceb3b2..56192e3 100644
--- a/frontend/src/center/builtinTabs.tsx
+++ b/frontend/src/center/builtinTabs.tsx
@@ -1,6 +1,9 @@
 import { lazy } from "react";
 import SketchErrorBoundary from "../widgets/sketch/ErrorBoundary";
 import { registerTabKind, type TabComponent } from "./tabRegistry";
+import ProxiedSkillPanel from "../widgets/embed/ProxiedSkillPanel";
+import CeAtlasEmbed from "../widgets/embed/CeAtlasEmbed";
+import { useProxiedSkillEmbeds } from "../widgets/embed/useProxiedSkillEmbeds";
 
 /**
  * Wire each built-in tab kind into the registry. Called once from
@@ -40,9 +43,15 @@ const ReportDocTab = lazy(() => import("../widgets/library/ReportDocTab"));
 const ThrustersTab = lazy(() => import("../widgets/thrusters/ThrustersTab"));
 const OwidTab = lazy(() => import("../widgets/owid/OwidTab"));
 
-const GraphAdapter: TabComponent = ({ graphData, graphError }) => (
-  <GraphTab data={graphData} error={graphError} />
-);
+const GraphAdapter: TabComponent = ({ graphData, graphError }) => {
+  const proxied = useProxiedSkillEmbeds();
+  if (proxied === null) {
+    return <div className="sy-placeholder"><p>Loading…</p></div>;
+  }
+  // Graph = CE atlas embed skin (dedicated mount; not full HTML remount).
+  if (proxied) return <CeAtlasEmbed />;
+  return <GraphTab data={graphData} error={graphError} />;
+};
 const EditorAdapter: TabComponent = ({ tab }) => <EditorTab tab={tab} />;
 const DuckDBAdapter: TabComponent = () => <DuckDBTab />;
 const SheetAdapter: TabComponent = () => <SheetTab />;
@@ -50,7 +59,14 @@ const VegaAdapter: TabComponent = () => <VegaTab />;
 const SketchAdapter: TabComponent = () => (
   <SketchErrorBoundary><SketchTab /></SketchErrorBoundary>
 );
-const AgentsAdapter: TabComponent = () => <AgentDashboardTab />;
+const AgentsAdapter: TabComponent = () => {
+  const proxied = useProxiedSkillEmbeds();
+  if (proxied === null) {
+    return <div className="sy-placeholder"><p>Loading…</p></div>;
+  }
+  if (proxied) return <ProxiedSkillPanel kind="okstratr" />;
+  return <AgentDashboardTab />;
+};
 const ProjectsAdapter: TabComponent = () => <ProjectsTab />;
 const PackFileListAdapter: TabComponent = ({ tab }) => <PackFileListTab tab={tab} />;
 
diff --git a/frontend/src/index.css b/frontend/src/index.css
index f212a1b..72c1754 100644
--- a/frontend/src/index.css
+++ b/frontend/src/index.css
@@ -2498,6 +2498,25 @@ a.sy-source-cite { color: var(--accent); }
   width: 100%;
   height: 100%;
 }
+.sy-graph-progress {
+  position: absolute;
+  top: 10px;
+  left: 50%;
+  transform: translateX(-50%);
+  z-index: 6;
+  padding: 6px 14px;
+  border-radius: 999px;
+  font-size: 12px;
+  color: var(--text);
+  background: color-mix(in srgb, var(--bg-soft) 92%, transparent);
+  border: 1px solid var(--line);
+  box-shadow: 0 2px 8px color-mix(in srgb, #000 18%, transparent);
+  pointer-events: none;
+  max-width: min(520px, 90%);
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
 /* ── Sheet tab (Univer) ──────────────────────────────────────────── */
 .sy-sheet {
   display: flex;
@@ -8986,3 +9005,265 @@ a.sy-source-cite { color: var(--accent); }
   color: var(--danger, #c44);
   font-size: 10px;
 }
+
+
+/* ── Phase 4a: same-origin proxied skill panel (no iframe) ───────── */
+.sy-proxied-skill {
+  display: flex;
+  flex-direction: column;
+  height: 100%;
+  min-height: 0;
+  background: var(--sy-bg, #0f1115);
+  color: var(--sy-fg, #e8eaed);
+}
+.sy-proxied-skill-bar {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 8px 12px;
+  padding: 8px 12px;
+  border-bottom: 1px solid var(--sy-border, #2a2f3a);
+  flex-shrink: 0;
+}
+.sy-proxied-skill-hint {
+  opacity: 0.65;
+  font-size: 0.85em;
+}
+.sy-proxied-skill-nav {
+  display: flex;
+  gap: 6px;
+  flex: 1;
+  min-width: 200px;
+}
+.sy-proxied-skill-nav input {
+  flex: 1;
+  font-family: ui-monospace, SFMono-Regular, Menlo, monospace;
+  font-size: 0.85em;
+  padding: 4px 8px;
+  border-radius: 4px;
+  border: 1px solid var(--sy-border, #2a2f3a);
+  background: var(--sy-input-bg, #1a1f2a);
+  color: inherit;
+}
+.sy-proxied-skill-nav button {
+  padding: 4px 10px;
+  border-radius: 4px;
+  border: 1px solid var(--sy-border, #2a2f3a);
+  background: var(--sy-btn-bg, #222833);
+  color: inherit;
+  cursor: pointer;
+}
+.sy-proxied-skill-body {
+  flex: 1;
+  min-height: 0;
+  overflow: hidden;
+  padding: 12px;
+  display: flex;
+  flex-direction: column;
+}
+/* Minimal chrome: Graph/Agents — no debug bar padding; canvas fills pane. */
+.sy-proxied-skill--minimal .sy-proxied-skill-body {
+  padding: 0;
+}
+.sy-proxied-skill-muted { opacity: 0.7; }
+.sy-proxied-skill-error {
+  border: 1px solid #a44;
+  border-radius: 6px;
+  padding: 12px;
+  background: rgba(160, 40, 40, 0.12);
+}
+.sy-proxied-skill-error pre,
+.sy-proxied-skill-json,
+.sy-proxied-skill-text {
+  white-space: pre-wrap;
+  word-break: break-word;
+  font-family: ui-monospace, SFMono-Regular, Menlo, monospace;
+  font-size: 0.85em;
+}
+.sy-proxied-skill-status {
+  flex-shrink: 0;
+  padding: 6px 12px;
+  font-size: 0.85em;
+  border-bottom: 1px solid var(--sy-border, #2a2f3a);
+  background: rgba(255, 255, 255, 0.03);
+}
+.sy-proxied-skill-status--starting,
+.sy-proxied-skill-status--unknown {
+  color: #c9a227;
+}
+.sy-proxied-skill-status--unhealthy {
+  color: #e07070;
+  background: rgba(160, 40, 40, 0.12);
+}
+.sy-proxied-skill-status--building_wiki {
+  color: #6bb3e8;
+}
+.sy-proxied-skill-status--live {
+  color: #6be8a0;
+  opacity: 0.85;
+}
+.sy-proxied-skill-html {
+  /* Embed v2: interactive same-document mount (scripts executed).
+     Acts as CE/okstratr "body" — flex row so #sidebar + #graph-pane layout. */
+  max-width: 100%;
+  min-height: 0;
+  flex: 1;
+  display: flex;
+  flex-direction: row;
+  overflow: hidden;
+  height: 100%;
+  width: 100%;
+  position: relative;
+  background: var(--bg, #0f1115);
+  color: var(--text, #e8eaed);
+}
+.sy-proxied-skill-html[hidden] {
+  display: none !important;
+}
+
+/*
+ * CE/okstratr main.css set `body { display: flex }` which, once linked into
+ * this document, flex-splits #root + any body-level toast and shoves the
+ * rail mid-screen. Keep the shell body as a block BFC while an embed is up.
+ */
+body.sy-embed-hosting {
+  display: block !important;
+}
+
+/* CE embed skin: canvas + interactions only — hide atlas chrome. */
+.sy-proxied-skill-html[data-embed-skin="canvas"] #sidebar,
+.sy-proxied-skill--skin-canvas .sy-proxied-skill-html #sidebar {
+  display: none !important;
+  width: 0 !important;
+  border: none !important;
+}
+.sy-proxied-skill-html[data-embed-skin="canvas"] #graph-pane,
+.sy-proxied-skill--skin-canvas .sy-proxied-skill-html #graph-pane {
+  flex: 1 1 auto;
+  width: 100%;
+  min-width: 0;
+  height: 100%;
+}
+/* Optional: hide overlay wiki search if Switchbay chrome owns search later.
+   Keep for now — CE graph-search is an in-canvas interaction. */
+
+/* okstratr observer skin: drop top brand/chips strip; keep desk body. */
+.sy-proxied-skill-html[data-embed-skin="observer"] > header.top,
+.sy-proxied-skill--skin-observer .sy-proxied-skill-html > header.top {
+  display: none !important;
+}
+.sy-proxied-skill-html[data-embed-skin="observer"],
+.sy-proxied-skill--skin-observer .sy-proxied-skill-html {
+  flex-direction: column;
+}
+
+
+/* ── CE atlas embed skin (Graph tab; no full HTML remount) ───────── */
+.sy-ce-atlas-embed {
+  display: flex;
+  flex-direction: column;
+  height: 100%;
+  min-height: 0;
+  background: var(--bg, #0f1115);
+  color: var(--text, #e8eaed);
+  position: relative;
+}
+.sy-ce-atlas-embed-root {
+  flex: 1;
+  min-height: 0;
+  display: flex;
+  flex-direction: row;
+  overflow: hidden;
+  height: 100%;
+  width: 100%;
+  position: relative;
+}
+.sy-ce-atlas-embed-root[hidden] {
+  display: none !important;
+}
+.sy-ce-atlas-embed-root #graph-pane {
+  flex: 1 1 auto;
+  width: 100%;
+  min-width: 0;
+  height: 100%;
+  position: relative;
+}
+.sy-ce-atlas-embed-root #graph {
+  width: 100%;
+  height: 100%;
+}
+.sy-ce-atlas-embed-status,
+.sy-ce-atlas-embed-hint {
+  padding: 12px 16px;
+  opacity: 0.75;
+  font-size: 0.9em;
+}
+.sy-ce-atlas-embed-error {
+  margin: 12px;
+  padding: 12px;
+  border: 1px solid #a44;
+  border-radius: 6px;
+  background: rgba(160, 40, 40, 0.12);
+}
+.sy-ce-atlas-embed-error pre {
+  white-space: pre-wrap;
+  font-family: ui-monospace, SFMono-Regular, Menlo, monospace;
+  font-size: 0.85em;
+}
+
+/* Dual-mount Graph: Switchbay ↻/✂ sit top-left (prior GraphTab chrome).
+   Hide CE's bottom-bar copies so we don't double up. */
+.sy-ce-atlas-embed-root #split-toggle,
+.sy-ce-atlas-embed-root #replay-toggle {
+  display: none !important;
+}
+
+/* CE dual-mount: shell-left sidebar slot (Pages|Files) */
+.sy-side-pages--ce-embed {
+  flex: 1 1 auto;
+  min-height: 0;
+  display: flex;
+  flex-direction: column;
+}
+.sy-ce-sidebar-slot {
+  flex: 1;
+  min-height: 0;
+  display: flex;
+  flex-direction: column;
+  position: relative;
+}
+.sy-ce-sidebar-root {
+  flex: 1;
+  min-height: 0;
+  display: flex;
+  flex-direction: column;
+  overflow: hidden;
+  height: 100%;
+}
+.sy-ce-sidebar-root[hidden] {
+  display: none !important;
+}
+.sy-ce-sidebar-root #sidebar {
+  width: 100% !important;
+  height: 100%;
+  border-right: none;
+  display: flex;
+  flex-direction: column;
+}
+/* Hide CE theme toggle in shell — Switchbay footer owns theme/mode. */
+.sy-ce-sidebar-root #theme-toggle,
+.sy-ce-sidebar-root .sidebar-foot #theme-icon-sun,
+.sy-ce-sidebar-root .sidebar-foot #theme-icon-moon {
+  display: none !important;
+}
+.sy-ce-sidebar-slot-status,
+.sy-ce-sidebar-slot-error {
+  padding: 10px 12px;
+  font-size: 0.85em;
+  opacity: 0.8;
+}
+.sy-ce-sidebar-slot-error pre {
+  white-space: pre-wrap;
+  font-family: ui-monospace, Menlo, monospace;
+  font-size: 0.85em;
+}
diff --git a/frontend/src/layout/SettingsModal.tsx b/frontend/src/layout/SettingsModal.tsx
index fca160e..71c8270 100644
--- a/frontend/src/layout/SettingsModal.tsx
+++ b/frontend/src/layout/SettingsModal.tsx
@@ -114,7 +114,10 @@ export default function SettingsModal({ open, onClose, onQuit, onRestart, onUpda
     if (!open) return;
     fetch("/api/llm/providers")
       .then((r) => r.json())
-      .then((b: ProvidersBody) => setInfo(b))
+      .then((b: ProvidersBody) => {
+        const providers = Array.isArray(b?.providers) ? b.providers : [];
+        setInfo({ ...b, providers });
+      })
       .catch(() => { /* keychain endpoint missing on older daemons */ });
   }, [open]);
 
@@ -122,7 +125,11 @@ export default function SettingsModal({ open, onClose, onQuit, onRestart, onUpda
 
   const refresh = async () => {
     const r = await fetch("/api/llm/providers");
-    if (r.ok) setInfo((await r.json()) as ProvidersBody);
+    if (r.ok) {
+      const b = (await r.json()) as ProvidersBody;
+      const providers = Array.isArray(b?.providers) ? b.providers : [];
+      setInfo({ ...b, providers });
+    }
   };
 
   const saveKey = async (id: string) => {
@@ -426,6 +433,7 @@ export default function SettingsModal({ open, onClose, onQuit, onRestart, onUpda
             setBusy={setBusy}
             onRefresh={refresh}
           />
+          <OkstratrHarnessPanel open={open} />
           <LocalModelPanel
             open={open}
             onClose={onClose}
@@ -659,7 +667,7 @@ function MicroEditModelPanel(props: {
   };
   useEffect(() => { if (props.open) load(); }, [props.open]);
 
-  const provider = props.providers.find((p) => p.id === pid);
+  const provider = (Array.isArray(props.providers) ? props.providers : []).find((p) => p.id === pid);
   const modelOpts = modelsForProvider(provider);
   const modelChoices = model && !modelOpts.includes(model) ? [model, ...modelOpts] : modelOpts;
 
@@ -702,7 +710,7 @@ function MicroEditModelPanel(props: {
           aria-label="micro-edit provider"
         >
           <option value="">(follows picker)</option>
-          {props.providers.map((p) => <option key={p.id} value={p.id}>{p.label}</option>)}
+          {(Array.isArray(props.providers) ? props.providers : []).map((p) => <option key={p.id} value={p.id}>{p.label}</option>)}
         </select>
         <select
           className="sy-settings-input" value={model} disabled={!pid}
@@ -1494,15 +1502,17 @@ function PiHarnessPanel({
 
   return (
     <section className="sy-settings-section">
-      <h3 className="sy-settings-h">Optional harness · Pi</h3>
+      <h3 className="sy-settings-h">Optional rail harness · Pi</h3>
       <p className="sy-settings-blurb">
-        Turns on the <code>pi</code> CLI as a harness for hired specialist
-        nodes — the same class of coding-agent CLI as Claude Code, Codex,
-        or Grok Build. Switch Bay will not stack Pi on top of a signed-in
-        CLI: those keep using their own harness. Pi is the alternative
-        when a local model or an API key is doing the work instead.
-        The rail stays the chat and HTTP tool loop; Pi only runs the
-        hired package, then hands the result back. Install{" "}
+        Switch Bay <strong>rail / hire</strong> only — not the desk/agent
+        harness SSOT (that lives in{" "}
+        <em>Harness registry · okstratr</em> below). Turns on the{" "}
+        <code>pi</code> CLI for hired specialist nodes — same class as
+        Claude Code, Codex, or Grok Build. Switch Bay will not stack Pi on
+        top of a signed-in CLI: those keep using their own harness. Pi is
+        the alternative when a local model or an API key is doing the work
+        instead. The rail stays the chat and HTTP tool loop; Pi only runs
+        the hired package, then hands the result back. Install{" "}
         <code>pi</code> yourself or set <code>SWITCHBAY_PI</code>. Not a
         lockfile pin.
       </p>
@@ -1542,6 +1552,287 @@ function PiHarnessPanel({
 }
 
 
+
+// ── Harness registry (okstratr SSOT) ───────────────────────────────
+
+
+type OkstratrHarnessRow = {
+  id: string;
+  label: string;
+  enabled: boolean;
+  installed: boolean;
+  default_model?: string | null;
+  models?: string[];
+  notes?: string;
+};
+
+type OkstratrHarnessView = {
+  ok?: boolean;
+  ssot?: string;
+  path?: string | null;
+  backend?: string;
+  enabled?: string[];
+  preference?: string[];
+  harnesses?: OkstratrHarnessRow[];
+  error?: string;
+  embed_paths?: Record<string, string>;
+};
+
+
+function OkstratrHarnessPanel({ open }: { open: boolean }) {
+  const [view, setView] = useState<OkstratrHarnessView | null>(null);
+  const [busy, setBusy] = useState<string | null>(null);
+  const [status, setStatus] = useState<{ ok: boolean; msg: string } | null>(null);
+  const [draftModels, setDraftModels] = useState<Record<string, string>>({});
+
+  const reload = async () => {
+    try {
+      const r = await fetch("/api/okstratr/harness");
+      const body = (await r.json().catch(() => ({}))) as OkstratrHarnessView;
+      if (!r.ok) {
+        setView({
+          ok: false,
+          ssot: "okstratr",
+          harnesses: [],
+          error: body.error ?? `HTTP ${r.status}`,
+        });
+        return;
+      }
+      setView(body);
+      const drafts: Record<string, string> = {};
+      for (const h of body.harnesses ?? []) {
+        drafts[h.id] = h.default_model ?? "";
+      }
+      setDraftModels(drafts);
+    } catch (e) {
+      setView({
+        ok: false,
+        ssot: "okstratr",
+        harnesses: [],
+        error: e instanceof Error ? e.message : "unreachable",
+      });
+    }
+  };
+
+  useEffect(() => {
+    if (!open) return;
+    void reload();
+  }, [open]);
+
+  if (!open) return null;
+
+  const toggle = async (h: OkstratrHarnessRow) => {
+    setBusy(h.id);
+    setStatus(null);
+    try {
+      const path = h.enabled
+        ? "/api/okstratr/harness/disable"
+        : "/api/okstratr/harness/enable";
+      const r = await fetch(path, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ id: h.id }),
+      });
+      const body = (await r.json().catch(() => ({}))) as OkstratrHarnessView;
+      if (!r.ok) {
+        setStatus({ ok: false, msg: body.error ?? `HTTP ${r.status}` });
+        return;
+      }
+      setView(body);
+      setStatus({
+        ok: true,
+        msg: h.enabled ? `disabled ${h.id}` : `enabled ${h.id}`,
+      });
+    } finally {
+      setBusy(null);
+    }
+  };
+
+  const saveDefaultModel = async (h: OkstratrHarnessRow) => {
+    const value = (draftModels[h.id] ?? "").trim();
+    if (!value) return;
+    setBusy(`set:${h.id}`);
+    setStatus(null);
+    try {
+      const r = await fetch("/api/okstratr/harness/set", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          key: `harness.${h.id}.default_model`,
+          value,
+        }),
+      });
+      const body = (await r.json().catch(() => ({}))) as OkstratrHarnessView;
+      if (!r.ok) {
+        setStatus({ ok: false, msg: body.error ?? `HTTP ${r.status}` });
+        return;
+      }
+      setView(body);
+      setStatus({ ok: true, msg: `default model → ${value}` });
+    } finally {
+      setBusy(null);
+    }
+  };
+
+  const doReload = async () => {
+    setBusy("reload");
+    setStatus(null);
+    try {
+      const r = await fetch("/api/okstratr/harness/reload", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({}),
+      });
+      const body = (await r.json().catch(() => ({}))) as OkstratrHarnessView;
+      if (!r.ok) {
+        setStatus({ ok: false, msg: body.error ?? `HTTP ${r.status}` });
+        return;
+      }
+      setView(body);
+      setStatus({ ok: true, msg: "reloaded from disk" });
+    } finally {
+      setBusy(null);
+    }
+  };
+
+  const rows = view?.harnesses ?? [];
+
+  return (
+    <section className="sy-settings-packs">
+      <h3 className="sy-settings-h3">Harness registry · okstratr</h3>
+      <p className="sy-settings-blurb">
+        Desk / agent harness allowlist and model pools —{" "}
+        <strong>okstratr is the SSOT</strong> (<code>harnesses.toml</code>).
+        Switch Bay does not keep a second allowlist. Writes go through{" "}
+        <code>/api/okstratr/harness</code> (daemon thin client over{" "}
+        <code>/embed/okstratr/api/harness</code>). Hosted mode keeps okstratr
+        HTML settings off.
+      </p>
+      {view === null ? (
+        <p className="sy-settings-help">Loading registry…</p>
+      ) : view.error ? (
+        <p className="sy-settings-status sy-settings-status--err">
+          {view.error}
+          {" — "}start okstratr (core skill) or check{" "}
+          <code>SWITCHBAY_OKSTRATR_UPSTREAM</code>.
+        </p>
+      ) : (
+        <>
+          <p className="sy-settings-help">
+            backend=<code>{view.backend || "—"}</code>
+            {view.path ? (
+              <>
+                {" · "}
+                <code>{view.path}</code>
+              </>
+            ) : null}
+            {" · "}
+            enabled:{" "}
+            <code>{(view.enabled ?? []).join(", ") || "(none)"}</code>
+          </p>
+          <div className="sy-settings-row" style={{ marginBottom: 8 }}>
+            <button
+              type="button"
+              className="sy-confirm-btn"
+              onClick={() => void doReload()}
+              disabled={busy !== null}
+            >
+              {busy === "reload" ? "Reloading…" : "Reload from disk"}
+            </button>
+          </div>
+          {rows.length === 0 ? (
+            <p className="sy-settings-help">
+              <em>No harnesses returned.</em>
+            </p>
+          ) : (
+            rows.map((h) => (
+              <div key={h.id} className="sy-settings-provider">
+                <div className="sy-settings-provider-head">
+                  <span className="sy-settings-provider-label">{h.label}</span>
+                  <span className="sy-settings-provider-meta">
+                    {h.id}
+                    {h.default_model ? ` · ${h.default_model}` : ""}
+                  </span>
+                  {h.installed ? (
+                    <span className="sy-settings-badge sy-settings-badge--ok">
+                      installed
+                    </span>
+                  ) : (
+                    <span className="sy-settings-badge">not installed</span>
+                  )}
+                  <span className="sy-spacer" />
+                  <button
+                    type="button"
+                    className={
+                      "sy-settings-pill"
+                      + (h.enabled ? " sy-settings-pill--on" : "")
+                    }
+                    onClick={() => void toggle(h)}
+                    disabled={busy !== null}
+                    title={
+                      h.enabled
+                        ? `Disable ${h.id} in okstratr registry`
+                        : `Enable ${h.id} in okstratr registry`
+                    }
+                  >
+                    {busy === h.id ? "…" : h.enabled ? "on" : "off"}
+                  </button>
+                </div>
+                {h.notes ? (
+                  <p className="sy-settings-help" style={{ margin: "4px 0" }}>
+                    {h.notes}
+                  </p>
+                ) : null}
+                <div className="sy-settings-row">
+                  <input
+                    className="sy-ws-input"
+                    style={{ flex: 1, marginTop: 0 }}
+                    placeholder="default model"
+                    value={draftModels[h.id] ?? ""}
+                    onChange={(e) =>
+                      setDraftModels((d) => ({ ...d, [h.id]: e.target.value }))
+                    }
+                    spellCheck={false}
+                    list={`sy-okstratr-models-${h.id}`}
+                  />
+                  <datalist id={`sy-okstratr-models-${h.id}`}>
+                    {(h.models ?? []).map((m) => (
+                      <option key={m} value={m} />
+                    ))}
+                  </datalist>
+                  <button
+                    type="button"
+                    className="sy-confirm-btn"
+                    onClick={() => void saveDefaultModel(h)}
+                    disabled={
+                      busy !== null
+                      || !(draftModels[h.id] ?? "").trim()
+                      || (draftModels[h.id] ?? "").trim() === (h.default_model ?? "")
+                    }
+                  >
+                    {busy === `set:${h.id}` ? "Saving…" : "Set default"}
+                  </button>
+                </div>
+              </div>
+            ))
+          )}
+        </>
+      )}
+      {status && (
+        <p
+          className={
+            "sy-settings-status"
+            + (status.ok ? "" : " sy-settings-status--err")
+          }
+        >
+          {status.msg}
+        </p>
+      )}
+    </section>
+  );
+}
+
+
 // ── Permissions panel ──────────────────────────────────────────────
 
 
@@ -1732,6 +2023,7 @@ type SettingsBody = {
   admin_ceiling?: number | null;
   chief_counted?: boolean;
   note?: string;
+  proxied_skill_embeds?: boolean;
   media?: {
     modalities?: Record<string, MediaModalityState>;
     note?: string;
@@ -2673,7 +2965,7 @@ function LocalModelPanel({
     <section className="sy-settings-packs" ref={sectionRef}>
       <h3 className="sy-settings-h3">Local agent model</h3>
       <p className="sy-settings-blurb">
-        Run models on this machine (~{ram} GB RAM). Pick a server type.
+        Run models on this machine (Switch Bay rail LLM — not okstratr desk SSOT) (~{ram} GB RAM). Pick a server type.
         Installing pins CE curate workers to this local model.
       </p>
       {body.local_rung && (
@@ -3646,6 +3938,42 @@ function StoragePanel({ open }: { open: boolean }) {
     }
   };
 
+  const toggleProxiedEmbeds = async () => {
+    if (!settings || busy) return;
+    const next = !settings.proxied_skill_embeds;
+    setBusy(true);
+    setStatus(null);
+    try {
+      const r = await fetch("/api/settings", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ proxied_skill_embeds: next }),
+      });
+      if (!r.ok) {
+        const body = await r.json().catch(() => ({} as Record<string, string>));
+        setStatus({ ok: false, msg: body.error || `HTTP ${r.status}` });
+        return;
+      }
+      const body = (await r.json()) as SettingsBody;
+      setSettings(body);
+      window.dispatchEvent(
+        new CustomEvent("sy:proxied-skill-embeds", {
+          detail: { enabled: !!body.proxied_skill_embeds },
+        }),
+      );
+      setStatus({
+        ok: true,
+        msg: next
+          ? "Graph/Agents now use same-origin /embed/* panels (no iframe)."
+          : "Graph/Agents restored to built-in tabs.",
+      });
+    } catch (e) {
+      setStatus({ ok: false, msg: (e as Error).message });
+    } finally {
+      setBusy(false);
+    }
+  };
+
   const setEmbeddingBackend = async (backend: string) => {
     if (!settings || busy) return;
     setBusy(true);
@@ -3728,6 +4056,35 @@ function StoragePanel({ open }: { open: boolean }) {
         Machine-local avoids that at the cost of per-machine history.
       </p>
 
+      <h4 className="sy-settings-h4" style={{ marginTop: 22 }}>
+        Proxied skill embeds (Phase 4a)
+      </h4>
+      <p className="sy-settings-blurb">
+        When on: shell left hosts CE Pages|Files (persistent); Graph hosts
+        CE atlas canvas only — one embed session, two mounts, shared{" "}
+        <code>/embed/ce/data.json</code>. Agents mounts okstratr under{" "}
+        <code>/embed/okstratr</code>. No iframes / full CE document remount.
+        Default off keeps WikiPane + GraphTab / AgentDashboard.
+      </p>
+      <div className="sy-settings-perm-row">
+        <span>
+          <strong>Proxied embeds:</strong>{" "}
+          {settings.proxied_skill_embeds ? "on (Graph→CE canvas, Agents→okstratr)" : "off (built-in)"}
+        </span>
+        <span className="sy-spacer" />
+        <button
+          type="button"
+          className={
+            "sy-settings-pill"
+            + (settings.proxied_skill_embeds ? " sy-settings-pill--on" : "")
+          }
+          onClick={() => void toggleProxiedEmbeds()}
+          disabled={busy}
+        >
+          {settings.proxied_skill_embeds ? "on" : "off"}
+        </button>
+      </div>
+
       <h4 className="sy-settings-h4" style={{ marginTop: 22 }}>
         Semantic recall (conversation memory)
       </h4>
@@ -4050,12 +4407,13 @@ function MediaPanel({ open }: { open: boolean }) {
         if (!state) return null;
         const choice = state.choice;
         const providerId = choice?.provider ?? "";
-        const provider = state.providers.find((p) => p.id === providerId);
+        const providers = Array.isArray(state.providers) ? state.providers : [];
+        const provider = providers.find((p) => p.id === providerId);
         const modelOpts = provider?.models ?? [];
         const modelId = choice?.model && modelOpts.includes(choice.model)
           ? choice.model
           : (choice?.model || provider?.default_model || "");
-        const anyKey = state.providers.some((p) => p.has_key);
+        const anyKey = providers.some((p) => p.has_key);
         return (
           <div key={modality} className="sy-settings-ladder-row" style={{ marginBottom: 10 }}>
             <span className="sy-settings-ladder-label" style={{ textTransform: "capitalize" }}>
@@ -4071,7 +4429,7 @@ function MediaPanel({ open }: { open: boolean }) {
                   void saveModality(modality, "", "");
                   return;
                 }
-                const p = state.providers.find((x) => x.id === pid);
+                const p = providers.find((x) => x.id === pid);
                 const mid = p?.default_model || p?.models[0] || "";
                 void saveModality(modality, pid, mid);
               }}
@@ -4081,7 +4439,7 @@ function MediaPanel({ open }: { open: boolean }) {
               <option value="">
                 {anyKey ? "(unset)" : "(add an xAI or OpenAI key)"}
               </option>
-              {state.providers.map((p) => (
+              {providers.map((p) => (
                 <option key={p.id} value={p.id} disabled={!p.has_key}>
                   {p.label}{p.has_key ? "" : " (no key)"}
                 </option>
diff --git a/frontend/src/lib/ingest.ts b/frontend/src/lib/ingest.ts
index 220c7b4..7c2c277 100644
--- a/frontend/src/lib/ingest.ts
+++ b/frontend/src/lib/ingest.ts
@@ -3,12 +3,26 @@
  * the run id (or null on failure). Shared by the Browser sidebar's `+`
  * (Power) and the graph toolbar's `+` (Zen) so both add-file affordances
  * behave identically.
+ *
+ * Prefer CE SSOT when the embed proxy is up (`/embed/ce/api/ingest/…`);
+ * fall back to Switchbay's local `/api/ingest/from-upload` so drag-drop
+ * still works without CE.
  */
-export async function ingestFile(file: File): Promise<string | null> {
+async function postIngest(url: string, file: File): Promise<string | null> {
   const form = new FormData();
   form.append("file", file);
-  const r = await fetch("/api/ingest/from-upload", { method: "POST", body: form });
+  const r = await fetch(url, { method: "POST", body: form });
   if (!r.ok) return null;
   const body = (await r.json()) as { run_id?: string };
   return body.run_id ?? null;
 }
+
+export async function ingestFile(file: File): Promise<string | null> {
+  try {
+    const viaCe = await postIngest("/embed/ce/api/ingest/from-upload", file);
+    if (viaCe) return viaCe;
+  } catch {
+    // CE down / proxy missing — fall through.
+  }
+  return postIngest("/api/ingest/from-upload", file);
+}
diff --git a/frontend/src/rail/ProviderPicker.tsx b/frontend/src/rail/ProviderPicker.tsx
index 6542a56..a461e17 100644
--- a/frontend/src/rail/ProviderPicker.tsx
+++ b/frontend/src/rail/ProviderPicker.tsx
@@ -67,7 +67,13 @@ export default function ProviderPicker() {
   const refresh = () =>
     fetch("/api/llm/providers")
       .then((r) => r.json())
-      .then((b: ProvidersBody) => setInfo(b))
+      .then((b: ProvidersBody) => {
+        // Guard: some embeds / older daemons returned providers as an
+        // object (or omitted it). Workspace switcher focus refreshes
+        // this picker — a non-array would crash on .find.
+        const providers = Array.isArray(b?.providers) ? b.providers : [];
+        setInfo({ ...b, providers });
+      })
       .catch(() => setInfo(null));
 
   useEffect(() => {
@@ -104,7 +110,8 @@ export default function ProviderPicker() {
   }, [open]);
 
   if (!info) return null;
-  const active = info.providers.find((p) => p.id === info.default_provider);
+  const providers = Array.isArray(info.providers) ? info.providers : [];
+  const active = providers.find((p) => p.id === info.default_provider);
   const activeModel = info.default_model || active?.default_model || "?";
   const activeShort = shortModel(activeModel);
   const activeLabel = shortProvider(active?.label ?? info.default_provider);
@@ -112,7 +119,7 @@ export default function ProviderPicker() {
   const warnings = info.routing?.warnings ?? [];
   // Providers that can actually orchestrate a curation run (shell +
   // file-write). A propose-only provider is rejected server-side too.
-  const execProviders = info.providers.filter(
+  const execProviders = providers.filter(
     (p) => p.has_key && p.capabilities?.shell && p.capabilities?.file_write,
   );
   const runProvider = execProviders.find((p) => p.id === runOn) ?? execProviders[0];
@@ -189,7 +196,7 @@ export default function ProviderPicker() {
       </button>
       {open && (
         <div className="sy-rail-pickmenu" role="menu">
-          {info.providers.filter((p) => p.has_key).length === 0 && (
+          {providers.filter((p) => p.has_key).length === 0 && (
             <div className="sy-rail-pickprov">
               <div className="sy-rail-pickprovhd">
                 <span className="sy-rail-pickproname">No providers ready</span>
@@ -199,7 +206,7 @@ export default function ProviderPicker() {
               </div>
             </div>
           )}
-          {info.providers.filter((p) => p.has_key).map((p) => {
+          {providers.filter((p) => p.has_key).map((p) => {
             // Same union as Settings (`modelsForProvider`): live list +
             // suggestions + default/chosen. Preferring only `models`
             // made Copilot's rail list diverge from Settings whenever
diff --git a/frontend/src/sidebar/Sidebar.tsx b/frontend/src/sidebar/Sidebar.tsx
index e2bead8..18852ef 100644
--- a/frontend/src/sidebar/Sidebar.tsx
+++ b/frontend/src/sidebar/Sidebar.tsx
@@ -6,6 +6,9 @@ import WikiPane from "./WikiPane";
 import { useIngestDrop } from "./ingestDrop";
 import ThemeToggle from "../layout/ThemeToggle";
 import ModeToggle from "../layout/ModeToggle";
+import CeSidebarSlot from "../widgets/embed/CeSidebarSlot";
+import { useProxiedSkillEmbeds } from "../widgets/embed/useProxiedSkillEmbeds";
+import { resetCeEmbedSession } from "../widgets/embed/ceEmbedSession";
 
 type Props = {
   data: GraphData | null;
@@ -65,6 +68,7 @@ function BottomSeg({
  * ZenBrowserTab, which composes the same parts.
  */
 export default function Sidebar({ data, error, filesVersion }: Props) {
+  const proxied = useProxiedSkillEmbeds();
   const [refreshKey, setRefreshKey] = useState(0);
   // Bottom-pane mode (D1): the wiki page list stays always-visible on
   // top; the BOTTOM pane is the lower-level browse surface and flips
@@ -78,6 +82,14 @@ export default function Sidebar({ data, error, filesVersion }: Props) {
     return () => window.removeEventListener("sy:reveal-file", onReveal);
   }, []);
 
+  // Workspace-keyed remount of <Sidebar> tears the CE dual-mount session
+  // so the next workspace does not keep the previous wiki's Pages list.
+  useEffect(() => {
+    return () => {
+      resetCeEmbedSession();
+    };
+  }, []);
+
   return (
     // display:contents — the wrapper adds DnD without touching the
     // column's flex layout; events bubble up from the panes.
@@ -93,35 +105,49 @@ export default function Sidebar({ data, error, filesVersion }: Props) {
           </span>
         )}
       </div>
-      <div className="sy-side-pages">
-        <WikiPane
-          data={data}
-          onGraphBuild={() => setRefreshKey((k) => k + 1)}
-          onUploadFile={ingestOne}
-        />
-      </div>
-      {error && (
-        <div className="sy-side-body" style={{ color: "var(--type-fact)" }}>
-          {error}
+      {proxied === null ? (
+        <div className="sy-side-pages">
+          <p className="sy-ce-sidebar-slot-status">Loading browser…</p>
+        </div>
+      ) : proxied === true ? (
+        // One CE page list (Pages|Files) in the shell — persists across
+        // Graph/Agents/Editor. Graph pane is canvas-only via CeAtlasEmbed.
+        <div className="sy-side-pages sy-side-pages--ce-embed">
+          <CeSidebarSlot />
         </div>
+      ) : (
+        <>
+          <div className="sy-side-pages">
+            <WikiPane
+              data={data}
+              onGraphBuild={() => setRefreshKey((k) => k + 1)}
+              onUploadFile={ingestOne}
+            />
+          </div>
+          {error && (
+            <div className="sy-side-body" style={{ color: "var(--type-fact)" }}>
+              {error}
+            </div>
+          )}
+          <div className="sy-side-files">
+            {view === "files" ? (
+              <FileBrowser
+                refreshKey={refreshKey + filesVersion}
+                headExtra={
+                  <BottomSeg view={view} onChange={setView} />
+                }
+              />
+            ) : (
+              <SourceBrowser
+                refreshKey={refreshKey + filesVersion}
+                headExtra={
+                  <BottomSeg view={view} onChange={setView} />
+                }
+              />
+            )}
+          </div>
+        </>
       )}
-      <div className="sy-side-files">
-        {view === "files" ? (
-          <FileBrowser
-            refreshKey={refreshKey + filesVersion}
-            headExtra={
-              <BottomSeg view={view} onChange={setView} />
-            }
-          />
-        ) : (
-          <SourceBrowser
-            refreshKey={refreshKey + filesVersion}
-            headExtra={
-              <BottomSeg view={view} onChange={setView} />
-            }
-          />
-        )}
-      </div>
       <footer className="sy-side-bottom">
         <ThemeToggle />
         <ModeToggle />
diff --git a/frontend/src/vite-env.d.ts b/frontend/src/vite-env.d.ts
index daaf5fa..7a70a52 100644
--- a/frontend/src/vite-env.d.ts
+++ b/frontend/src/vite-env.d.ts
@@ -5,6 +5,11 @@ declare module "*?url" {
   export default src;
 }
 
+declare module "*?raw" {
+  const src: string;
+  export default src;
+}
+
 // Browser-side .docx import (FileBrowser): mammoth + turndown ship no
 // types and there are no @types/* packages for the versions we use.
 // The local FileBrowser.importDocx caller treats both APIs as
diff --git a/frontend/src/widgets/agents/AgentDashboardTab.tsx b/frontend/src/widgets/agents/AgentDashboardTab.tsx
index a97db8e..8d16491 100644
--- a/frontend/src/widgets/agents/AgentDashboardTab.tsx
+++ b/frontend/src/widgets/agents/AgentDashboardTab.tsx
@@ -206,7 +206,10 @@ function runInFocusedWorkspace(r: { workspace?: string }, focused: string): bool
 }
 
 function isLiveRun(r: Run): boolean {
-  return !r.status || LIVE_RUN_STATUSES.has(r.status);
+  // Missing/idle/quiet must NOT count as live — otherwise the Agents
+  // list pulses "running" dots while the desk is Idle.
+  if (!r.status) return false;
+  return LIVE_RUN_STATUSES.has(r.status);
 }
 
 function isCancelledRun(r: { status?: string }): boolean {
@@ -306,7 +309,7 @@ export default function AgentDashboardTab() {
       setTools(t.tools as Tool[]);
       setRules(r.rules as Rule[]);
       setPalettes(Array.isArray(pal?.commands) ? pal as PalettesPayload : null);
-      setProviders(p.providers as Provider[]);
+      setProviders(Array.isArray(p.providers) ? (p.providers as Provider[]) : []);
       setModelTick((n) => n + 1);
     } catch (e) { setError((e as Error).message); }
   }, []);
diff --git a/frontend/src/widgets/agents/AgentSpace.tsx b/frontend/src/widgets/agents/AgentSpace.tsx
index 71d5061..bad3418 100644
--- a/frontend/src/widgets/agents/AgentSpace.tsx
+++ b/frontend/src/widgets/agents/AgentSpace.tsx
@@ -317,7 +317,7 @@ export default function AgentSpace({
       runId: chief.run_id,
       label: "chief of staff",
       kind: "chief",
-      status: chief.status || "running",
+      status: chief.status || "idle",
       activity: [chief.step, chief.decision_reason, obj].filter(Boolean).join(" · "),
       model: chief.model || chief.provider || "",
       provider: chief.provider || "",
@@ -371,7 +371,7 @@ export default function AgentSpace({
           runId: w.run_id,
           label: w.node_id || w.run_id.slice(-6),
           kind,
-          status: w.status || "running",
+          status: w.status || "idle",
           activity: w.activity || w.input_excerpt || "",
           model: w.model || "",
           provider: w.provider || "",
diff --git a/frontend/src/widgets/editor/EditorTab.tsx b/frontend/src/widgets/editor/EditorTab.tsx
index 6aa3b92..d4c439c 100644
--- a/frontend/src/widgets/editor/EditorTab.tsx
+++ b/frontend/src/widgets/editor/EditorTab.tsx
@@ -398,9 +398,18 @@ export default function EditorTab({ tab }: { tab?: TabSpec } = {}) {
     );
   }
   if (state.kind === "error") {
+    const vaultMissing = Boolean(path?.startsWith("vault/") && path.endsWith(".extracted.md"));
     return (
       <div className="sy-editor sy-editor--empty">
         <p style={{ color: "var(--type-fact)" }}>error: {state.message}</p>
+        {vaultMissing && (
+          <p style={{ color: "var(--type-fact)", fontSize: "0.85em", maxWidth: "36rem" }}>
+            This vault cite points at an extraction that is not on disk (and
+            was not found in vault/vault.db). Restore the tip&apos;s
+            vault/*.extracted.md files from the hybrid vault archive, then
+            reopen the cite.
+          </p>
+        )}
       </div>
     );
   }
@@ -890,7 +899,14 @@ function TrustCompare({
       try {
         const r = await fetch(url);
         if (!r.ok) {
-          if (!cancelled) setOriginal({ kind: "error", message: `HTTP ${r.status}` });
+          if (!cancelled) {
+            let detail = `HTTP ${r.status}`;
+            try {
+              const j = await r.clone().json() as { error?: string };
+              if (j?.error) detail = j.error;
+            } catch { /* non-JSON body */ }
+            setOriginal({ kind: "error", message: detail });
+          }
           return;
         }
         const text = await r.text();
diff --git a/frontend/src/widgets/embed/CeAtlasEmbed.tsx b/frontend/src/widgets/embed/CeAtlasEmbed.tsx
new file mode 100644
index 0000000..595b1c9
--- /dev/null
+++ b/frontend/src/widgets/embed/CeAtlasEmbed.tsx
@@ -0,0 +1,151 @@
+import { useEffect, useRef, useState } from "react";
+import canvasHtml from "./ceEmbedShell.html?raw";
+import { getCeEmbedSession } from "./ceEmbedSession.ts";
+
+/**
+ * Graph tab = CE atlas canvas only (graph-search + interactions).
+ * Pages|Files live in the shell left column via CeSidebarSlot — same
+ * CeEmbedSession / data.json (no second page list, no full HTML remount).
+ *
+ * Leave Graph → Agents/Editor parks the atlas off-DOM (no destroy).
+ * Return reattaches instantly; optional background data.json revalidate.
+ */
+
+const SOFT_REMOUNT_GRACE_MS = 8000;
+const SOFT_REMOUNT_DEBOUNCE_MS = 1500;
+
+type LoadState =
+  | { status: "loading" }
+  | { status: "ready" }
+  | { status: "error"; message: string };
+
+function stateFromSession(): LoadState {
+  const st = getCeEmbedSession().getState();
+  if (st.status === "ready") return { status: "ready" };
+  if (st.status === "error") return { status: "error", message: st.message };
+  return { status: "loading" };
+}
+
+export default function CeAtlasEmbed() {
+  const rootRef = useRef<HTMLDivElement | null>(null);
+  const readyAtRef = useRef(0);
+  // Seed from session so Graph return never flashes "Loading…" when atlas
+  // is already warm (soft-parked across tab switches).
+  const [state, setState] = useState<LoadState>(() => stateFromSession());
+
+  useEffect(() => {
+    const el = rootRef.current;
+    if (!el) return;
+    const session = getCeEmbedSession();
+    const wasLive = session.hasLiveCanvas();
+
+    const sync = () => {
+      const st = session.getState();
+      if (st.status === "ready") {
+        readyAtRef.current = Date.now();
+        setState({ status: "ready" });
+      } else if (st.status === "error") {
+        setState({ status: "error", message: st.message });
+      } else if (st.status === "loading" || st.status === "idle") {
+        // Keep ready paint if atlas is soft-parked / live — avoid 20s flash.
+        if (session.hasLiveCanvas()) {
+          setState({ status: "ready" });
+        } else {
+          setState({ status: "loading" });
+        }
+      }
+    };
+
+    const unsub = session.subscribe(sync);
+    session.attachCanvas(el, canvasHtml);
+    sync();
+
+    // After instant reattach, soft-refresh data.json in the background.
+    if (wasLive) {
+      session.softRevalidate();
+    }
+
+    let timer: ReturnType<typeof setTimeout> | null = null;
+    const onFiles = () => {
+      if (readyAtRef.current === 0) return;
+      if (Date.now() - readyAtRef.current < SOFT_REMOUNT_GRACE_MS) return;
+      if (timer) clearTimeout(timer);
+      timer = setTimeout(() => {
+        // Wiki changed: drop cached layout, refetch data, hard remount.
+        session.invalidateAtlasLayoutCache();
+        session.softRevalidate();
+        session.detachCanvas(el, { destroy: true });
+        session.attachCanvas(el, canvasHtml);
+      }, SOFT_REMOUNT_DEBOUNCE_MS);
+    };
+    window.addEventListener("sy:files-changed", onFiles);
+
+    return () => {
+      if (timer) clearTimeout(timer);
+      window.removeEventListener("sy:files-changed", onFiles);
+      unsub();
+      // Soft park — atlas + layout stay warm for Agents/Editor round-trip.
+      session.detachCanvas(el);
+    };
+  }, []);
+
+  const clickCe = (sel: string) => {
+    const btn = rootRef.current?.querySelector(sel);
+    if (btn instanceof HTMLElement) btn.click();
+  };
+
+  // Only show the slow loading banner when we do not already have a live atlas.
+  const showLoading =
+    state.status === "loading" && !getCeEmbedSession().hasLiveCanvas();
+
+  return (
+    <div
+      className="sy-ce-atlas-embed"
+      data-embed-v2="1"
+      data-embed-skin="canvas"
+    >
+      {showLoading && (
+        <p className="sy-ce-atlas-embed-status">Loading Curiosity Engine atlas…</p>
+      )}
+      {state.status === "error" && (
+        <div className="sy-ce-atlas-embed-error" role="alert">
+          <p>CE atlas embed failed.</p>
+          <pre>{state.message}</pre>
+          <p className="sy-ce-atlas-embed-hint">
+            Dual-mount session: shell hosts CE Pages|Files; this pane is
+            canvas-only. See docs/CE-EMBED-HOOK.md.
+          </p>
+        </div>
+      )}
+      {(state.status === "ready" || getCeEmbedSession().hasLiveCanvas()) && (
+        <>
+          <button
+            type="button"
+            className="sy-graph-replay-btn"
+            data-tour="graph-replay"
+            onClick={() => clickCe("#replay-toggle")}
+            title="Replay the curation history animation"
+            aria-label="Replay curation history"
+          >
+            ↻
+          </button>
+          <button
+            type="button"
+            className="sy-graph-split-btn"
+            onClick={() => clickCe("#split-toggle")}
+            title="Split this workspace: partition selected pages"
+            aria-label="Split workspace mode"
+          >
+            ✂
+          </button>
+        </>
+      )}
+      <div
+        id="graph-root"
+        ref={rootRef}
+        className="sy-ce-atlas-embed-root"
+        hidden={state.status === "error" || showLoading}
+      />
+    </div>
+  );
+}
diff --git a/frontend/src/widgets/embed/CeSidebarSlot.tsx b/frontend/src/widgets/embed/CeSidebarSlot.tsx
new file mode 100644
index 0000000..17e33f7
--- /dev/null
+++ b/frontend/src/widgets/embed/CeSidebarSlot.tsx
@@ -0,0 +1,56 @@
+import { useEffect, useRef, useState } from "react";
+import sidebarHtml from "./ceSidebarShell.html?raw";
+import { getCeEmbedSession } from "./ceEmbedSession.ts";
+
+/**
+ * Persistent shell-left mount for CE's Pages|Files sidebar.
+ * Shares CeEmbedSession with CeAtlasEmbed (Graph canvas) — one data.json.
+ */
+export default function CeSidebarSlot() {
+  const ref = useRef<HTMLDivElement | null>(null);
+  const [err, setErr] = useState<string | null>(null);
+  const [ready, setReady] = useState(false);
+
+  useEffect(() => {
+    const el = ref.current;
+    if (!el) return;
+    const session = getCeEmbedSession();
+    const unsub = session.subscribe(() => {
+      const st = session.getState();
+      if (st.status === "ready") {
+        setReady(true);
+        setErr(null);
+      } else if (st.status === "error") {
+        setErr(st.message);
+        setReady(false);
+      } else if (st.status === "loading") {
+        setReady(false);
+      }
+    });
+    session.attachSidebar(el, sidebarHtml);
+    return () => {
+      unsub();
+      session.detachSidebar(el);
+    };
+  }, []);
+
+  return (
+    <div className="sy-ce-sidebar-slot" data-ce-sidebar-slot="1">
+      {!ready && !err && (
+        <p className="sy-ce-sidebar-slot-status">Loading CE pages…</p>
+      )}
+      {err && (
+        <div className="sy-ce-sidebar-slot-error" role="alert">
+          <p>CE sidebar failed</p>
+          <pre>{err}</pre>
+        </div>
+      )}
+      <div
+        ref={ref}
+        id="ce-sidebar-root"
+        className="sy-ce-sidebar-root"
+        hidden={!ready}
+      />
+    </div>
+  );
+}
diff --git a/frontend/src/widgets/embed/ProxiedSkillPanel.tsx b/frontend/src/widgets/embed/ProxiedSkillPanel.tsx
new file mode 100644
index 0000000..deb5679
--- /dev/null
+++ b/frontend/src/widgets/embed/ProxiedSkillPanel.tsx
@@ -0,0 +1,460 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+import {
+  type CoreSkillsStatus,
+  type EmbedScript,
+  type StatusBanner,
+  embedFetchShimScript,
+  embedHostShimScript,
+  mapStatusBanner,
+  prepareEmbedHtml,
+} from "./embedMount.ts";
+
+/**
+ * Embed v2 same-origin skill panel (NO iframe).
+ *
+ * Mount algorithm (happy path — scripts execute):
+ * 1. Poll `/api/core-skills/status` while open; show wait chrome until healthy.
+ * 2. fetch proxied HTML from `/embed/ce|okstratr/…`.
+ * 3. Rewrite asset URLs to the public base; extract scripts.
+ * 4. Inject markup into the panel root; createElement+append each script
+ *    (module + classic) so the browser runs them (innerHTML never does).
+ * 5. Tear down (clear root + remove injected scripts) before soft-reload
+ *    or unmount to avoid duplicate roots/listeners.
+ *
+ * JSON responses keep the pretty-print path. No nested frames (ADR-004 / 004b).
+ */
+
+export type SkillEmbedKind = "ce" | "okstratr";
+
+const PREFIX: Record<SkillEmbedKind, string> = {
+  ce: "/embed/ce",
+  okstratr: "/embed/okstratr",
+};
+
+const LABEL: Record<SkillEmbedKind, string> = {
+  ce: "Curiosity Engine",
+  okstratr: "okstratr",
+};
+
+const DEFAULT_PATH: Record<SkillEmbedKind, string> = {
+  ce: "/",
+  okstratr: "/observer/",
+};
+
+const STATUS_POLL_MS = 2000;
+/** Ignore sy:files-changed until first ok-html, then for this grace window
+ *  so CE's initial data.json fetch is not aborted by a soft remount. */
+const SOFT_REMOUNT_GRACE_MS = 8000;
+/** Debounce files_changed soft remounts (was 400ms — too eager). */
+const SOFT_REMOUNT_DEBOUNCE_MS = 1500;
+
+type Props = {
+  kind: SkillEmbedKind;
+  /**
+   * `minimal` (default): hide Switchbay debug bar (same-origin / Go / Reload)
+   * and the live status strip — shell keeps rail/tabs only.
+   * `debug`: show the Phase 4a chrome for troubleshooting.
+   */
+  chrome?: "minimal" | "debug";
+  /**
+   * CE: `canvas` hides atlas chrome (sidebar search, pages·links strip).
+   * okstratr: `observer` hides the top brand/chips strip when hosted.
+   * `full` keeps upstream chrome.
+   */
+  skin?: "canvas" | "observer" | "full";
+};
+
+type LoadState =
+  | { status: "idle" }
+  | { status: "loading" }
+  | { status: "ok-html" }
+  | { status: "ok-json"; text: string }
+  | { status: "ok-text"; text: string }
+  | { status: "error"; message: string; httpStatus?: number };
+
+async function executeScripts(
+  scripts: EmbedScript[],
+  container: HTMLElement,
+  tracker: HTMLScriptElement[],
+): Promise<void> {
+  for (const desc of scripts) {
+    if (desc.noModule) continue;
+    const el = document.createElement("script");
+    el.dataset.syEmbedScript = "1";
+    if (desc.type === "module") el.type = "module";
+    if (desc.async) el.async = true;
+    if (desc.defer) el.defer = true;
+    if (desc.crossOrigin != null) el.crossOrigin = desc.crossOrigin || "anonymous";
+    if (desc.integrity) el.integrity = desc.integrity;
+    if (desc.referrerPolicy) {
+      el.referrerPolicy = desc.referrerPolicy as ReferrerPolicy;
+    }
+
+    if (desc.src) {
+      await new Promise<void>((resolve, reject) => {
+        el.onload = () => resolve();
+        el.onerror = () =>
+          reject(new Error(`Failed to load embed script: ${desc.src}`));
+        el.src = desc.src!;
+        container.appendChild(el);
+        tracker.push(el);
+      });
+    } else {
+      // Inline: textContent + append executes classic scripts synchronously.
+      el.textContent = desc.content ?? "";
+      container.appendChild(el);
+      tracker.push(el);
+    }
+  }
+}
+
+export default function ProxiedSkillPanel({
+  kind,
+  chrome = "minimal",
+  skin,
+}: Props) {
+  const resolvedSkin =
+    skin ?? (kind === "ce" ? "canvas" : kind === "okstratr" ? "observer" : "full");
+  const prefix = PREFIX[kind];
+  const [path, setPath] = useState(DEFAULT_PATH[kind]);
+  const [draft, setDraft] = useState(DEFAULT_PATH[kind]);
+  const [state, setState] = useState<LoadState>({ status: "idle" });
+  const [refreshing, setRefreshing] = useState(false);
+  const [coreStatus, setCoreStatus] = useState<CoreSkillsStatus | null>(null);
+  const pathRef = useRef(path);
+  pathRef.current = path;
+  const coreStatusRef = useRef<CoreSkillsStatus | null>(null);
+  coreStatusRef.current = coreStatus;
+
+  const mountRef = useRef<HTMLDivElement | null>(null);
+  const injectedScriptsRef = useRef<HTMLScriptElement[]>([]);
+  const loadGenRef = useRef(0);
+  /** Wall clock of last successful ok-html mount (0 = never). */
+  const okHtmlAtRef = useRef(0);
+  /** True while load() is in flight (HTML fetch / script exec). */
+  const loadInFlightRef = useRef(false);
+
+  const banner: StatusBanner = mapStatusBanner(kind, coreStatus);
+
+  const teardown = useCallback(() => {
+    try {
+      const releaseFetch = (window as unknown as { __syEmbedReleaseFetch?: () => void })
+        .__syEmbedReleaseFetch;
+      releaseFetch?.();
+    } catch {
+      /* ignore */
+    }
+    try {
+      const releaseHost = (window as unknown as { __syEmbedReleaseHost?: () => void })
+        .__syEmbedReleaseHost;
+      releaseHost?.();
+    } catch {
+      /* ignore */
+    }
+    for (const el of injectedScriptsRef.current) {
+      try {
+        el.remove();
+      } catch {
+        /* already gone */
+      }
+    }
+    injectedScriptsRef.current = [];
+    const root = mountRef.current;
+    if (root) root.innerHTML = "";
+  }, []);
+
+  // Status poll while panel is mounted (every 2s).
+  useEffect(() => {
+    let cancelled = false;
+    let timer: ReturnType<typeof setTimeout> | null = null;
+
+    const tick = async () => {
+      try {
+        const r = await fetch("/api/core-skills/status", { cache: "no-store" });
+        if (!r.ok) throw new Error(`status ${r.status}`);
+        const j = (await r.json()) as CoreSkillsStatus;
+        if (!cancelled) setCoreStatus(j);
+      } catch {
+        /* keep last known */
+      } finally {
+        if (!cancelled) {
+          timer = setTimeout(tick, STATUS_POLL_MS);
+        }
+      }
+    };
+
+    void tick();
+    return () => {
+      cancelled = true;
+      if (timer) clearTimeout(timer);
+    };
+  }, []);
+
+  const load = useCallback(
+    async (p: string, opts?: { soft?: boolean }) => {
+      const soft = !!opts?.soft;
+      const gen = ++loadGenRef.current;
+      const liveBanner = mapStatusBanner(kind, coreStatusRef.current);
+
+      if (!liveBanner.allowMount) {
+        teardown();
+        okHtmlAtRef.current = 0;
+        loadInFlightRef.current = false;
+        setState({ status: "idle" });
+        return;
+      }
+
+      loadInFlightRef.current = true;
+      if (soft) {
+        setRefreshing(true);
+      } else {
+        setState({ status: "loading" });
+      }
+
+      const base = prefix + (p.startsWith("/") ? p : `/${p}`);
+      const sep = base.includes("?") ? "&" : "?";
+      const url = `${base}${sep}_sb=${Date.now()}`;
+
+      try {
+        const r = await fetch(url, {
+          cache: "no-store",
+          headers: { Accept: "text/html, application/json;q=0.9, */*;q=0.8" },
+        });
+        if (gen !== loadGenRef.current) return;
+
+        const ct = r.headers.get("content-type") || "";
+        const text = await r.text();
+        if (gen !== loadGenRef.current) return;
+
+        if (!r.ok) {
+          // While starting, status chrome already explains wait — skip 502 flash.
+          if (mapStatusBanner(kind, coreStatusRef.current).suppressFetchError) {
+            setState({ status: "idle" });
+            return;
+          }
+          setState({
+            status: "error",
+            message: text.slice(0, 500) || r.statusText,
+            httpStatus: r.status,
+          });
+          teardown();
+          return;
+        }
+
+        if (ct.includes("application/json")) {
+          teardown();
+          let pretty = text;
+          try {
+            pretty = JSON.stringify(JSON.parse(text), null, 2);
+          } catch {
+            /* keep raw */
+          }
+          setState({ status: "ok-json", text: pretty });
+          return;
+        }
+
+        if (ct.includes("text/html") || /^\s*</.test(text)) {
+          teardown();
+          const root = mountRef.current;
+          if (!root) {
+            setState({ status: "error", message: "mount root missing" });
+            return;
+          }
+          const prepared = prepareEmbedHtml(text, prefix, p);
+          // Host shim first (syHost + body.innerHTML guard), then fetch remap.
+          const scripts = [
+            embedHostShimScript('[data-sy-embed-root="1"]'),
+            embedFetchShimScript(prefix),
+            ...prepared.scripts,
+          ];
+          root.innerHTML = prepared.markup;
+          root.dataset.embedSkin = resolvedSkin;
+          try {
+            await executeScripts(scripts, root, injectedScriptsRef.current);
+          } catch (e) {
+            if (gen !== loadGenRef.current) return;
+            setState({
+              status: "error",
+              message: (e as Error).message || "script load failed",
+            });
+            return;
+          }
+          if (gen !== loadGenRef.current) return;
+          okHtmlAtRef.current = Date.now();
+          setState({ status: "ok-html" });
+          return;
+        }
+
+        teardown();
+        setState({ status: "ok-text", text });
+      } catch (e) {
+        if (gen !== loadGenRef.current) return;
+        if (mapStatusBanner(kind, coreStatusRef.current).suppressFetchError) {
+          setState({ status: "idle" });
+          return;
+        }
+        setState({
+          status: "error",
+          message: (e as Error).message || "fetch failed",
+        });
+      } finally {
+        if (gen === loadGenRef.current) {
+          loadInFlightRef.current = false;
+          if (soft) setRefreshing(false);
+        }
+      }
+    },
+    [prefix, kind, teardown, resolvedSkin],
+  );
+
+  // Mount when path changes or skill becomes healthy enough to allowMount.
+  useEffect(() => {
+    if (!banner.allowMount) {
+      teardown();
+      okHtmlAtRef.current = 0;
+      setState({ status: "idle" });
+      return;
+    }
+    // Path / first-healthy mount: reset grace so soft remount cannot
+    // abort the new initial data.json load.
+    okHtmlAtRef.current = 0;
+    void load(path);
+  }, [load, path, banner.allowMount, teardown]);
+
+  // Live view: wiki / curator / rescan → daemon files_changed → soft remount.
+  // Guard: never soft-remount before first ok-html, during load(), or inside
+  // the post-mount grace window (CE main.js fetch('data.json') is in flight).
+  useEffect(() => {
+    let timer: ReturnType<typeof setTimeout> | null = null;
+    const onFiles = () => {
+      if (okHtmlAtRef.current === 0) return;
+      if (loadInFlightRef.current) return;
+      if (Date.now() - okHtmlAtRef.current < SOFT_REMOUNT_GRACE_MS) return;
+      if (timer) clearTimeout(timer);
+      timer = setTimeout(() => {
+        if (okHtmlAtRef.current === 0) return;
+        if (loadInFlightRef.current) return;
+        if (Date.now() - okHtmlAtRef.current < SOFT_REMOUNT_GRACE_MS) return;
+        void load(pathRef.current, { soft: true });
+      }, SOFT_REMOUNT_DEBOUNCE_MS);
+    };
+    window.addEventListener("sy:files-changed", onFiles);
+    return () => {
+      if (timer) clearTimeout(timer);
+      window.removeEventListener("sy:files-changed", onFiles);
+    };
+  }, [load]);
+
+  useEffect(() => () => teardown(), [teardown]);
+
+  const onNavigate = (ev: React.FormEvent) => {
+    ev.preventDefault();
+    const next = draft.trim() || "/";
+    setPath(next.startsWith("/") ? next : `/${next}`);
+  };
+
+  const showWaitChrome = !banner.allowMount;
+  const showError =
+    state.status === "error" && !banner.suppressFetchError && !showWaitChrome;
+
+  const showDebugBar = chrome === "debug";
+  const showStatusStrip =
+    chrome === "debug" || banner.kind !== "live" || showWaitChrome || showError;
+
+  return (
+    <div
+      className={
+        "sy-proxied-skill"
+        + (chrome === "minimal" ? " sy-proxied-skill--minimal" : "")
+        + (resolvedSkin !== "full" ? ` sy-proxied-skill--skin-${resolvedSkin}` : "")
+      }
+      data-kind={kind}
+      data-embed-v2="1"
+      data-chrome={chrome}
+      data-embed-skin={resolvedSkin}
+    >
+      {showDebugBar && (
+        <header className="sy-proxied-skill-bar">
+          <strong>{LABEL[kind]}</strong>
+          <span className="sy-proxied-skill-hint">
+            same-origin via {prefix} (no iframe)
+            {refreshing ? " · updating…" : ""}
+          </span>
+          <form className="sy-proxied-skill-nav" onSubmit={onNavigate}>
+            <input
+              value={draft}
+              onChange={(e) => setDraft(e.target.value)}
+              aria-label="Proxied path"
+              spellCheck={false}
+            />
+            <button type="submit">Go</button>
+            <button
+              type="button"
+              onClick={() => {
+                setDraft(path);
+                void load(path, { soft: true });
+              }}
+            >
+              Reload
+            </button>
+          </form>
+        </header>
+      )}
+
+      {showStatusStrip && (
+        <div
+          className={`sy-proxied-skill-status sy-proxied-skill-status--${banner.kind}`}
+          role="status"
+          aria-live="polite"
+        >
+          {banner.label}
+          {!showDebugBar && refreshing ? " · updating…" : ""}
+        </div>
+      )}
+
+      <div className="sy-proxied-skill-body">
+        {showWaitChrome && (
+          <p className="sy-proxied-skill-muted">
+            Waiting for {LABEL[kind]} before mounting interactive UI…
+          </p>
+        )}
+        {!showWaitChrome && state.status === "loading" && (
+          <p className="sy-proxied-skill-muted">
+            Loading {prefix}
+            {path}…
+          </p>
+        )}
+        {showError && state.status === "error" && (
+          <div className="sy-proxied-skill-error" role="alert">
+            <p>
+              Upstream unreachable or proxy error
+              {state.httpStatus != null ? ` (${state.httpStatus})` : ""}.
+            </p>
+            <pre>{state.message}</pre>
+            <p className="sy-proxied-skill-muted">
+              Start the skill upstream on loopback
+              {kind === "ce"
+                ? " (CE viewer — default :8766, or whatever SWITCHBAY_CE_UPSTREAM points at)"
+                : " (okstratr :8767)"}
+              , or turn off Settings → Storage → “Proxied skill embeds” for the
+              built-in tab. A 502 almost always means that upstream process
+              exited.
+            </p>
+          </div>
+        )}
+        {state.status === "ok-json" && (
+          <pre className="sy-proxied-skill-json">{state.text}</pre>
+        )}
+        {state.status === "ok-text" && (
+          <pre className="sy-proxied-skill-text">{state.text}</pre>
+        )}
+        <div
+          ref={mountRef}
+          className="sy-proxied-skill-html"
+          data-sy-embed-root="1"
+          hidden={state.status !== "ok-html"}
+        />
+      </div>
+    </div>
+  );
+}
diff --git a/frontend/src/widgets/embed/ceEmbedBootstrap.ts b/frontend/src/widgets/embed/ceEmbedBootstrap.ts
new file mode 100644
index 0000000..79898f8
--- /dev/null
+++ b/frontend/src/widgets/embed/ceEmbedBootstrap.ts
@@ -0,0 +1,471 @@
+/**
+ * Same-origin CE atlas embed bootstrap (no full-document HTML remount).
+ *
+ * Prefer `window.CEEmbed.mount` when CE ships embed mode. Until then, load
+ * CE static modules from `/embed/ce/static/…` and run a Switchbay stub that
+ * mirrors `main.js` without Sidebar / filebrowser chrome.
+ *
+ * CE hook (for CE Benchmarker) — see docs/CE-EMBED-HOOK.md:
+ *   window.CEEmbed.mount(container, {
+ *     embed: true,
+ *     dataUrl: "/embed/ce/data.json",
+ *     publicBase: "/embed/ce",
+ *     chrome: false,  // no sidebar / workspace title / theme footer
+ *   }) => { destroy(): void }
+ */
+
+import { isSwitchbayReservedApi } from "./embedMount.ts";
+export type CeEmbedOptions = {
+  embed: true;
+  dataUrl: string;
+  publicBase: string;
+  /** When false (default), skip CE pages sidebar / atlas chrome duplicates. */
+  chrome?: boolean;
+  /** Workspace path or basename — keys CEAtlasCache (IndexedDB cold start). */
+  workspace?: string;
+  /** Explicit atlas cache key (overrides workspace). */
+  cacheKey?: string;
+};
+
+export type CeEmbedHandle = {
+  destroy: () => void;
+};
+
+/** Dual-mount handle from window.CEEmbed.create */
+export type CeCreateHandle = {
+  mountSidebar: (el: HTMLElement) => void;
+  mountCanvas: (el: HTMLElement) => void;
+  /** Soft park by default; pass {destroy:true} to tear down atlas. */
+  unmountCanvas?: (opts?: { destroy?: boolean }) => void;
+  destroy: () => void;
+  getData?: () => unknown;
+  isCanvasLive?: () => boolean;
+  revalidate?: (currentPageId?: string) => Promise<void> | void;
+  getCacheInfo?: () => {
+    key: string | null;
+    tip: string;
+    usedCache: boolean;
+    hasPositions: boolean;
+  };
+};
+
+type CeEmbedGlobal = {
+  mount: (container: HTMLElement, opts: CeEmbedOptions) => CeEmbedHandle | Promise<CeEmbedHandle>;
+};
+
+/** Loose CE globals (wiki-view IIFEs). Avoid augmenting Window — GraphTab already does. */
+type CeWindow = Window & {
+  CEEmbed?: CeEmbedGlobal;
+  CE_PUBLIC_BASE?: string;
+  CE_HOSTED?: string;
+  ceApi?: (path: string) => string;
+  Theme?: { init: () => void };
+  Sidebar?: { init: (data: unknown) => void };
+  Subgraph?: { init: (data: unknown) => void };
+  Modal?: { init: (data: unknown) => void };
+  Edit?: {
+    init: (data: unknown, refetch: (id?: string) => Promise<void>) => void;
+  };
+  Graph?: { init: (data: unknown) => unknown };
+  AtlasViewer?: {
+    enabled?: (data: unknown) => boolean;
+    classicSafe?: (data: unknown) => boolean;
+    initChoice?: (data: unknown, mode: string) => void;
+    init: (data: unknown) => unknown;
+  };
+  KnowledgeAtlas?: unknown;
+  GraphSearch?: { init: (data: unknown, api: unknown) => void };
+  __syEmbedReleaseFetch?: () => void;
+};
+
+const w = () => window as CeWindow;
+
+const SCRIPT_ORDER = [
+  "vendor/d3.min.js",
+  "vendor/fuse.min.js",
+  "vendor/jszip.min.js",
+  "theme.js",
+  "sidebar.js",
+  "filebrowser.js",
+  "split.js",
+  "replay.js",
+  "subgraph.js",
+  "vault.js",
+  "modal.js",
+  "edit.js",
+  "graph.js",
+  "vendor/knowledge-atlas.js",
+  "atlas.js",
+  "search.js",
+  "atlas-cache.js",
+  "embed.js",
+  // skip main.js — dual-mount session / CEEmbed boots instead
+] as const;
+
+function loadScript(src: string): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const existing = document.querySelector<HTMLScriptElement>(
+      `script[data-sy-ce-embed-src="${src}"]`,
+    );
+    if (existing) {
+      if (existing.dataset.loaded === "1") {
+        resolve();
+        return;
+      }
+      existing.addEventListener("load", () => resolve(), { once: true });
+      existing.addEventListener(
+        "error",
+        () => reject(new Error(`Failed to load ${src}`)),
+        { once: true },
+      );
+      return;
+    }
+    const el = document.createElement("script");
+    el.src = src;
+    el.async = false;
+    el.dataset.syCeEmbedSrc = src;
+    el.onload = () => {
+      el.dataset.loaded = "1";
+      resolve();
+    };
+    el.onerror = () => reject(new Error(`Failed to load ${src}`));
+    document.head.appendChild(el);
+  });
+}
+
+function loadCss(href: string): HTMLLinkElement {
+  let link = document.querySelector<HTMLLinkElement>(
+    `link[data-sy-ce-embed-css="${href}"]`,
+  );
+  if (link) return link;
+  link = document.createElement("link");
+  link.rel = "stylesheet";
+  link.href = href;
+  link.dataset.syCeEmbedCss = href;
+  document.head.appendChild(link);
+  return link;
+}
+
+function installPublicBase(publicBase: string): void {
+  const base = publicBase.replace(/\/$/, "") || "";
+  const win = w();
+  win.CE_PUBLIC_BASE = base;
+  win.CE_HOSTED = "switchbay";
+  // CE FileBrowser uses ceApi("/api/tree") — older CE viewers 404 that
+  // under /embed/ce. Keep Switchbay control-plane paths on the daemon
+  // (tree SSOT, llm providers, …) so dual-mount Files + rail pickers work.
+  win.ceApi = (path: string) => {
+    const p = path.startsWith("/") ? path : `/${path}`;
+    if (isSwitchbayReservedApi(p)) return p;
+    return `${base}${p}`;
+  };
+  try {
+    document.documentElement.dataset.syHost = "1";
+  } catch {
+    /* ignore */
+  }
+  try {
+    document.body.classList.add("sy-embed-hosting");
+  } catch {
+    /* ignore */
+  }
+}
+
+/**
+ * Fetch-shim scoped for CE relative + CE /api/* only (reserved Switchbay
+ * paths untouched). Reuses embedMount helpers via dynamic import when
+ * available; inlined here to avoid circular deps at call sites.
+ */
+async function installFetchShim(publicBase: string): Promise<() => void> {
+  const { embedFetchShimScript } = await import("./embedMount.ts");
+  const shim = embedFetchShimScript(publicBase);
+  const el = document.createElement("script");
+  el.textContent = shim.content ?? "";
+  document.head.appendChild(el);
+  el.remove();
+  return () => {
+    try {
+      w().__syEmbedReleaseFetch?.();
+    } catch {
+      /* ignore */
+    }
+  };
+}
+
+async function loadCeModules(publicBase: string): Promise<void> {
+  const base = publicBase.replace(/\/$/, "") || "";
+  loadCss(`${base}/static/main.css`);
+  for (const rel of SCRIPT_ORDER) {
+    // split/replay may 404 on older wiki-view bundles — skip soft-fail
+    try {
+      await loadScript(`${base}/static/${rel}`);
+    } catch (e) {
+      if (rel === "split.js" || rel === "replay.js" || rel === "filebrowser.js") {
+        console.warn("[CeAtlasEmbed] optional script missing:", rel);
+        continue;
+      }
+      throw e;
+    }
+  }
+}
+
+async function stubMount(
+  container: HTMLElement,
+  opts: CeEmbedOptions,
+): Promise<CeEmbedHandle> {
+  const dataUrl = opts.dataUrl;
+  let destroyed = false;
+  let data: unknown = null;
+
+  const res = await fetch(dataUrl, { cache: "no-store" });
+  if (!res.ok) {
+    throw new Error(`CE data ${res.status} from ${dataUrl}`);
+  }
+  data = await res.json();
+
+  // Ensure #graph exists inside container (shell HTML already injected).
+  const graphEl = container.querySelector("#graph") || document.getElementById("graph");
+  if (!graphEl) {
+    throw new Error("CE embed shell missing #graph");
+  }
+
+  const win = w();
+  win.Theme?.init();
+  // chrome-off: do NOT call Sidebar.init
+  win.Subgraph?.init(data);
+  win.Modal?.init(data);
+
+  let graphApi: unknown = win.Graph;
+  const atlasViewer = win.AtlasViewer;
+  const wantAtlas = !!(
+    atlasViewer &&
+    win.KnowledgeAtlas &&
+    (atlasViewer.enabled?.(data) ?? true)
+  );
+  const classicOk =
+    !(atlasViewer && typeof atlasViewer.classicSafe === "function") ||
+    !!atlasViewer.classicSafe?.(data);
+  let viewerMode = wantAtlas ? "atlas" : "classic";
+  if (!classicOk && win.KnowledgeAtlas && atlasViewer) {
+    viewerMode = "atlas";
+  }
+  try {
+    document.body.dataset.viewer = viewerMode;
+  } catch {
+    /* ignore */
+  }
+  atlasViewer?.initChoice?.(data, viewerMode);
+
+  if (viewerMode === "atlas" && atlasViewer && win.KnowledgeAtlas) {
+    const atlas = atlasViewer.init(data);
+    if (atlas) {
+      graphApi = atlas;
+    } else if (classicOk && win.Graph) {
+      win.Graph.init(data);
+      viewerMode = "classic";
+      document.body.dataset.viewer = viewerMode;
+    } else if (graphEl instanceof HTMLElement) {
+      graphEl.innerHTML =
+        '<div style="padding:28px;color:#ccc;font:14px system-ui">' +
+        "Atlas failed to start.</div>";
+    }
+  } else if (classicOk && win.Graph) {
+    win.Graph.init(data);
+  } else if (graphEl instanceof HTMLElement) {
+    graphEl.innerHTML =
+      '<div style="padding:28px;color:#ccc;font:14px system-ui">' +
+      "Classic disabled for large wikis; Atlas unavailable.</div>";
+  }
+
+  win.GraphSearch?.init(data, graphApi);
+
+  async function refetchData(currentPageId?: string) {
+    if (destroyed) return;
+    try {
+      const r = await fetch(
+        dataUrl.includes("?") ? `${dataUrl}&t=${Date.now()}` : `${dataUrl}?t=${Date.now()}`,
+        { cache: "no-store" },
+      );
+      if (!r.ok) return;
+      data = await r.json();
+      const rw = w();
+      rw.Subgraph?.init(data);
+      rw.Modal?.init(data);
+      // Soft refresh: search re-bind; leave atlas camera alone (parity with main.js)
+      rw.GraphSearch?.init(data, graphApi);
+      void currentPageId;
+    } catch (e) {
+      console.warn("[CeAtlasEmbed] refetch failed", e);
+    }
+  }
+
+  win.Edit?.init(data, refetchData);
+
+  return {
+    destroy: () => {
+      destroyed = true;
+      try {
+        delete document.body.dataset.viewer;
+      } catch {
+        /* ignore */
+      }
+      // Clear canvas host; CE modules do not always expose destroy.
+      const g = document.getElementById("graph");
+      if (g) g.innerHTML = "";
+    },
+  };
+}
+
+/**
+ * Mount CE atlas into an already-prepared shell container.
+ */
+export async function mountCeAtlas(
+  container: HTMLElement,
+  opts: CeEmbedOptions,
+): Promise<CeEmbedHandle> {
+  const publicBase = (opts.publicBase || "/embed/ce").replace(/\/$/, "") || "/embed/ce";
+  const dataUrl =
+    opts.dataUrl ||
+    `${publicBase}/data.json`;
+
+  installPublicBase(publicBase);
+  const releaseFetch = await installFetchShim(publicBase);
+  await loadCeModules(publicBase);
+
+  const fullOpts: CeEmbedOptions = {
+    embed: true,
+    dataUrl,
+    publicBase,
+    chrome: opts.chrome ?? false,
+  };
+
+  let handle: CeEmbedHandle;
+  const ceEmbed = w().CEEmbed;
+  if (ceEmbed && typeof ceEmbed.mount === "function") {
+    handle = await ceEmbed.mount(container, fullOpts);
+  } else {
+    handle = await stubMount(container, fullOpts);
+  }
+
+  const innerDestroy = handle.destroy.bind(handle);
+  return {
+    destroy: () => {
+      try {
+        innerDestroy();
+      } catch {
+        /* ignore */
+      }
+      releaseFetch();
+      try {
+        document.body.classList.remove("sy-embed-hosting", "hosted");
+      } catch {
+        /* ignore */
+      }
+    },
+  };
+}
+
+
+export type PreparedSession = {
+  data: unknown;
+  publicBase: string;
+  dataUrl: string;
+  /** Full CEEmbed.create handle when CE ships dual-mount embed.js. */
+  createHandle: CeCreateHandle | null;
+  /** Release fetch shim + optional CEEmbed.create handle. */
+  nativeRelease: { destroy: () => void } | null;
+  releaseFetch: () => void;
+};
+
+/**
+ * Load CE modules + data.json once for dual-mount (sidebar + canvas).
+ * Does not paint atlas — CeEmbedSession attaches mounts afterwards.
+ */
+/** Basename of the focused Switchbay workspace (localStorage snapshot). */
+function activeWorkspaceHint(): string | undefined {
+  try {
+    const raw = localStorage.getItem("sy.workspaces.snapshot");
+    if (!raw) return undefined;
+    const snap = JSON.parse(raw) as { workspace?: string };
+    if (typeof snap.workspace === "string" && snap.workspace.trim()) {
+      const parts = snap.workspace.split("/").filter(Boolean);
+      return parts[parts.length - 1] || snap.workspace;
+    }
+  } catch {
+    /* ignore */
+  }
+  return undefined;
+}
+
+export async function prepareSession(
+  opts: CeEmbedOptions,
+): Promise<PreparedSession> {
+  const publicBase = (opts.publicBase || "/embed/ce").replace(/\/$/, "") || "/embed/ce";
+  const dataUrl = opts.dataUrl || `${publicBase}/data.json`;
+
+  installPublicBase(publicBase);
+  const releaseFetch = await installFetchShim(publicBase);
+  await loadCeModules(publicBase);
+
+  const ce = w().CEEmbed as
+    | {
+        create?: (o: CeEmbedOptions) => Promise<CeCreateHandle>;
+        mount?: unknown;
+      }
+    | undefined;
+
+  let createHandle: CeCreateHandle | null = null;
+  let nativeRelease: { destroy: () => void } | null = null;
+  if (ce && typeof ce.create === "function") {
+    const workspace = opts.workspace || activeWorkspaceHint();
+    const created = await ce.create({
+      embed: true,
+      dataUrl,
+      publicBase,
+      chrome: opts.chrome ?? false,
+      workspace,
+      cacheKey: opts.cacheKey,
+    });
+    createHandle = created;
+    nativeRelease = {
+      destroy: () => {
+        try {
+          created.destroy();
+        } catch {
+          /* ignore */
+        }
+        releaseFetch();
+      },
+    };
+  }
+
+  // Prefer data from create handle when available (single fetch).
+  let data: unknown = null;
+  if (createHandle && typeof createHandle.getData === "function") {
+    data = createHandle.getData() ?? null;
+  }
+  if (data == null) {
+    const res = await fetch(dataUrl, { cache: "no-store" });
+    if (!res.ok) {
+      try {
+        createHandle?.destroy();
+      } catch {
+        /* ignore */
+      }
+      releaseFetch();
+      throw new Error(`CE data ${res.status} from ${dataUrl}`);
+    }
+    data = await res.json();
+  }
+
+  return {
+    data,
+    publicBase,
+    dataUrl,
+    createHandle,
+    nativeRelease,
+    releaseFetch: nativeRelease ? () => {} : releaseFetch,
+  };
+}
+
+export const CE_EMBED_SCRIPT_ORDER = SCRIPT_ORDER;
diff --git a/frontend/src/widgets/embed/ceEmbedSession.ts b/frontend/src/widgets/embed/ceEmbedSession.ts
new file mode 100644
index 0000000..47525ed
--- /dev/null
+++ b/frontend/src/widgets/embed/ceEmbedSession.ts
@@ -0,0 +1,526 @@
+/**
+ * One CE embed session, two mount points (shell sidebar + Graph canvas).
+ *
+ * Shares a single data.json + module load across Switchbay's left column
+ * (CE Pages|Files sidebar) and the Graph tab (atlas canvas only). Survives
+ * Graph↔Agents tab switches: canvas soft-parks (atlas stays warm) while
+ * sidebar stays mounted; return reattaches instantly without re-layout.
+ *
+ * Prefer window.CEEmbed.create/mount when CE ships dual-mount embed mode;
+ * stub path below coordinates Sidebar + AtlasViewer until then.
+ *
+ * See docs/CE-EMBED-HOOK.md.
+ */
+
+import {
+  type CeCreateHandle,
+  type CeEmbedHandle,
+  type CeEmbedOptions,
+} from "./ceEmbedBootstrap.ts";
+
+export type CeMountPoints = {
+  sidebar?: HTMLElement | null;
+  canvas?: HTMLElement | null;
+};
+
+type Listener = () => void;
+
+type SessionState =
+  | { status: "idle" }
+  | { status: "loading" }
+  | { status: "ready"; data: unknown }
+  | { status: "error"; message: string };
+
+const PUBLIC_BASE = "/embed/ce";
+const DATA_URL = "/embed/ce/data.json";
+
+type CeWin = Window & {
+  CEEmbed?: {
+    create?: (opts: CeEmbedOptions) => Promise<{
+      mountSidebar?: (el: HTMLElement) => void;
+      mountCanvas?: (el: HTMLElement) => void;
+      destroy: () => void;
+    }>;
+    mount?: (
+      container: HTMLElement,
+      opts: CeEmbedOptions & { mounts?: CeMountPoints },
+    ) => CeEmbedHandle | Promise<CeEmbedHandle>;
+  };
+  Sidebar?: {
+    init: (data: unknown) => void;
+    setActive?: (id: string | null) => void;
+    setSearchHits?: (ids: string[] | null) => void;
+  };
+  FileBrowser?: { init?: (opts?: unknown) => void };
+  GraphSearch?: { init: (data: unknown, api: unknown) => void };
+  AtlasViewer?: {
+    enabled?: (data: unknown) => boolean;
+    classicSafe?: (data: unknown) => boolean;
+    initChoice?: (data: unknown, mode: string) => void;
+    init: (data: unknown) => unknown;
+  };
+  KnowledgeAtlas?: unknown;
+  Graph?: { init: (data: unknown) => unknown };
+  Subgraph?: { init: (data: unknown) => void };
+  Modal?: { init: (data: unknown) => void };
+  Theme?: { init: () => void };
+  Edit?: {
+    init: (data: unknown, refetch: (id?: string) => Promise<void>) => void;
+  };
+};
+
+function win(): CeWin {
+  return window as CeWin;
+}
+
+
+function workspaceLabel(data: unknown): string {
+  if (data && typeof data === "object" && "workspace" in data) {
+    const w = (data as { workspace?: unknown }).workspace;
+    if (typeof w === "string" && w.trim()) {
+      const parts = w.split("/").filter(Boolean);
+      return parts[parts.length - 1] || w;
+    }
+  }
+  return "workspace";
+}
+
+function injectSidebarHtml(el: HTMLElement, html: string, data: unknown): void {
+  const label = workspaceLabel(data);
+  el.innerHTML = html.replace(/\{\{WORKSPACE\}\}/g, label);
+  const nameEl = el.querySelector(".workspace-name");
+  if (nameEl) nameEl.textContent = label;
+}
+
+class CeEmbedSession {
+  private state: SessionState = { status: "idle" };
+  private listeners = new Set<Listener>();
+  private sidebarEl: HTMLElement | null = null;
+  private canvasEl: HTMLElement | null = null;
+  private sidebarHtml: string | null = null;
+  private canvasHtml: string | null = null;
+  private canvasHandle: CeEmbedHandle | null = null;
+  private createHandle: CeCreateHandle | null = null;
+  private ceNative: { destroy: () => void } | null = null;
+  private modulesReady = false;
+  private bootPromise: Promise<void> | null = null;
+  private gen = 0;
+
+  subscribe(fn: Listener): () => void {
+    this.listeners.add(fn);
+    return () => this.listeners.delete(fn);
+  }
+
+  getState(): SessionState {
+    return this.state;
+  }
+
+  /** Atlas/graph still warm (mounted or soft-parked). */
+  hasLiveCanvas(): boolean {
+    if (this.createHandle?.isCanvasLive) {
+      try {
+        return !!this.createHandle.isCanvasLive();
+      } catch {
+        /* fall through */
+      }
+    }
+    return !!this.canvasHandle;
+  }
+
+  /** Background data.json refresh without tearing down atlas layout. */
+  softRevalidate(): void {
+    try {
+      void this.createHandle?.revalidate?.();
+    } catch {
+      /* ignore */
+    }
+  }
+
+  /** Drop cached layout positions (tip / files_changed) so next mount re-layouts. */
+  invalidateAtlasLayoutCache(): void {
+    try {
+      const w = window as unknown as {
+        CEAtlasCache?: {
+          resolveKey: (o?: { workspace?: string }) => string;
+          putPositions: (key: string, positions: null) => Promise<unknown>;
+          clear?: (key?: string) => Promise<unknown>;
+        };
+        __CE_ATLAS_POSITIONS?: unknown;
+      };
+      w.__CE_ATLAS_POSITIONS = null;
+      const cache = w.CEAtlasCache;
+      if (!cache) return;
+      const key = cache.resolveKey();
+      void cache.putPositions(key, null);
+    } catch {
+      /* ignore */
+    }
+  }
+
+  private emit() {
+    for (const fn of this.listeners) fn();
+  }
+
+  private setState(next: SessionState) {
+    this.state = next;
+    this.emit();
+  }
+
+  /**
+   * Ensure CE modules + data.json are loaded once for this workspace session.
+   */
+  async ensure(): Promise<void> {
+    if (this.state.status === "ready" && this.modulesReady) return;
+    if (this.bootPromise) return this.bootPromise;
+
+    this.bootPromise = (async () => {
+      this.setState({ status: "loading" });
+      try {
+        // Reuse bootstrap loader (CSS/scripts + fetch shim + public base).
+        // mountCeAtlas with a throwaway off-DOM node is heavy; load via
+        // a dedicated path: import bootstrap internals.
+        const { prepareSession } = await import("./ceEmbedBootstrap.ts");
+        const prepared = await prepareSession({
+          embed: true,
+          dataUrl: DATA_URL,
+          publicBase: PUBLIC_BASE,
+          chrome: false,
+        });
+        this.modulesReady = true;
+        this.createHandle = prepared.createHandle ?? null;
+        this.ceNative = prepared.nativeRelease ?? {
+          destroy: prepared.releaseFetch,
+        };
+        this.setState({ status: "ready", data: prepared.data });
+        this.syncMounts();
+      } catch (e) {
+        this.setState({
+          status: "error",
+          message: (e as Error).message || "CE embed session failed",
+        });
+        throw e;
+      } finally {
+        this.bootPromise = null;
+      }
+    })();
+
+    return this.bootPromise;
+  }
+
+  attachSidebar(el: HTMLElement, html: string) {
+    this.sidebarEl = el;
+    this.sidebarHtml = html;
+    void this.ensure()
+      .then(() => this.syncMounts())
+      .catch(() => {
+        /* state already error */
+      });
+  }
+
+  detachSidebar(el?: HTMLElement) {
+    if (el && this.sidebarEl !== el) return;
+    this.sidebarEl = null;
+    // Keep session/data alive for canvas; do not destroy modules.
+  }
+
+  attachCanvas(el: HTMLElement, html: string) {
+    this.canvasEl = el;
+    this.canvasHtml = html;
+    void this.ensure()
+      .then(() => this.syncMounts())
+      .catch(() => {
+        /* state already error */
+      });
+  }
+
+  /**
+   * Soft-park by default (keeps atlas + loaded data warm for instant
+   * Graph return). Pass `{ destroy: true }` for hard teardown (files
+   * remount / workspace switch).
+   */
+  detachCanvas(el?: HTMLElement, opts?: { destroy?: boolean }) {
+    if (el && this.canvasEl !== el) return;
+    const hard = !!opts?.destroy;
+    try {
+      if (this.createHandle?.unmountCanvas) {
+        this.createHandle.unmountCanvas(hard ? { destroy: true } : undefined);
+      } else if (hard) {
+        this.canvasHandle?.destroy();
+        this.parkCanvasStub(true);
+      } else {
+        this.parkCanvasStub(false);
+      }
+    } catch {
+      /* ignore */
+    }
+    if (hard) {
+      this.canvasHandle = null;
+      if (this.canvasEl) this.canvasEl.innerHTML = "";
+    }
+    // Keep canvasHandle on soft park so syncMounts reattaches, not reinits.
+    this.canvasEl = null;
+  }
+
+  /** Stub-path park: move canvas DOM into a session-owned offscreen host. */
+  private parkHost: HTMLElement | null = null;
+
+  private ensureParkHost(): HTMLElement {
+    if (this.parkHost?.isConnected) return this.parkHost;
+    const host = document.createElement("div");
+    host.setAttribute("data-sy-ce-canvas-park", "1");
+    host.setAttribute("aria-hidden", "true");
+    host.style.cssText =
+      "position:fixed;left:-10000px;top:0;width:800px;height:600px;" +
+      "overflow:hidden;visibility:hidden;pointer-events:none;z-index:-1;";
+    document.body.appendChild(host);
+    this.parkHost = host;
+    return host;
+  }
+
+  private parkCanvasStub(hard: boolean) {
+    const el = this.canvasEl;
+    if (hard) {
+      try {
+        this.canvasHandle?.destroy();
+      } catch {
+        /* ignore */
+      }
+      this.canvasHandle = null;
+      if (el) el.innerHTML = "";
+      if (this.parkHost) this.parkHost.innerHTML = "";
+      return;
+    }
+    if (!el) return;
+    const g = el.querySelector("#graph") || el;
+    const w = (g as HTMLElement).clientWidth || el.clientWidth;
+    const h = (g as HTMLElement).clientHeight || el.clientHeight;
+    const host = this.ensureParkHost();
+    if (w > 0 && h > 0) {
+      host.style.width = `${w}px`;
+      host.style.height = `${h}px`;
+    }
+    while (el.firstChild) host.appendChild(el.firstChild);
+  }
+
+  private reattachParkedStub(el: HTMLElement) {
+    const host = this.parkHost;
+    if (!host) return false;
+    if (!host.firstChild && !this.canvasHandle) return false;
+    while (host.firstChild) el.appendChild(host.firstChild);
+    return true;
+  }
+
+  private syncMounts() {
+    if (this.state.status !== "ready") return;
+    const data = this.state.data;
+    const w = win();
+    const handle = this.createHandle;
+
+    // Prefer CE-native dual mount (embed.js CEEmbed.create).
+    if (handle && typeof handle.mountSidebar === "function") {
+      if (this.sidebarEl && this.sidebarHtml) {
+        if (!this.sidebarEl.querySelector("#sidebar")) {
+          injectSidebarHtml(this.sidebarEl, this.sidebarHtml, data);
+        } else {
+          const nameEl = this.sidebarEl.querySelector(".workspace-name");
+          if (nameEl) nameEl.textContent = workspaceLabel(data);
+        }
+        try {
+          handle.mountSidebar(this.sidebarEl);
+        } catch (e) {
+          console.warn("[CeEmbedSession] mountSidebar failed", e);
+        }
+      }
+
+      if (this.canvasEl && this.canvasHtml) {
+        const live =
+          !!this.canvasHandle ||
+          (typeof handle.isCanvasLive === "function" && handle.isCanvasLive());
+        const needInject =
+          !live && !this.canvasEl.querySelector("#graph");
+        if (needInject) {
+          this.canvasEl.innerHTML = this.canvasHtml;
+        }
+        try {
+          // First mount OR soft reattach from park — CEEmbed decides.
+          handle.mountCanvas(this.canvasEl);
+          if (!this.canvasHandle) {
+            this.canvasHandle = {
+              destroy: () => {
+                try {
+                  handle.unmountCanvas?.({ destroy: true });
+                } catch {
+                  /* ignore */
+                }
+              },
+            };
+          }
+        } catch (e) {
+          console.error("[CeEmbedSession] mountCanvas failed", e);
+          this.setState({
+            status: "error",
+            message: (e as Error).message || "canvas mount failed",
+          });
+        }
+      }
+      return;
+    }
+
+    // Stub path until CE ships embed.js
+    if (this.sidebarEl && this.sidebarHtml) {
+      if (!this.sidebarEl.querySelector("#sidebar")) {
+        injectSidebarHtml(this.sidebarEl, this.sidebarHtml, data);
+      } else {
+        const nameEl = this.sidebarEl.querySelector(".workspace-name");
+        if (nameEl) nameEl.textContent = workspaceLabel(data);
+      }
+      try {
+        w.Sidebar?.init(data);
+        w.FileBrowser?.init?.();
+      } catch (e) {
+        console.warn("[CeEmbedSession] Sidebar.init failed", e);
+      }
+    }
+
+    if (this.canvasEl && this.canvasHtml) {
+      if (this.canvasHandle) {
+        // Soft reattach: move parked DOM back into the new Graph root.
+        if (!this.reattachParkedStub(this.canvasEl)) {
+          const needInject = !this.canvasEl.querySelector("#graph");
+          if (needInject) this.canvasEl.innerHTML = this.canvasHtml;
+        }
+      } else {
+        const needInject = !this.canvasEl.querySelector("#graph");
+        if (needInject) {
+          this.canvasEl.innerHTML = this.canvasHtml;
+        }
+        void this.mountCanvasStub(data);
+      }
+    }
+  }
+
+  private async mountCanvasStub(data: unknown) {
+    const el = this.canvasEl;
+    if (!el) return;
+    const gen = ++this.gen;
+    const w = win();
+
+    try {
+      w.Theme?.init();
+      w.Subgraph?.init(data);
+      w.Modal?.init(data);
+
+      let graphApi: unknown = w.Graph;
+      const atlasViewer = w.AtlasViewer;
+      const wantAtlas = !!(
+        atlasViewer &&
+        w.KnowledgeAtlas &&
+        (atlasViewer.enabled?.(data) ?? true)
+      );
+      const classicOk =
+        !(atlasViewer && typeof atlasViewer.classicSafe === "function") ||
+        !!atlasViewer.classicSafe?.(data);
+      let viewerMode = wantAtlas ? "atlas" : "classic";
+      if (!classicOk && w.KnowledgeAtlas && atlasViewer) viewerMode = "atlas";
+      try {
+        document.body.dataset.viewer = viewerMode;
+      } catch {
+        /* ignore */
+      }
+      atlasViewer?.initChoice?.(data, viewerMode);
+
+      if (viewerMode === "atlas" && atlasViewer && w.KnowledgeAtlas) {
+        const atlas = atlasViewer.init(data);
+        if (atlas) graphApi = atlas;
+        else if (classicOk && w.Graph) {
+          w.Graph.init(data);
+          graphApi = w.Graph;
+        }
+      } else if (classicOk && w.Graph) {
+        w.Graph.init(data);
+        graphApi = w.Graph;
+      }
+
+      if (gen !== this.gen) return;
+      w.GraphSearch?.init(data, graphApi);
+
+      this.canvasHandle = {
+        destroy: () => {
+          const g = el.querySelector("#graph");
+          if (g) g.innerHTML = "";
+        },
+      };
+    } catch (e) {
+      console.error("[CeEmbedSession] canvas mount failed", e);
+      this.setState({
+        status: "error",
+        message: (e as Error).message || "canvas mount failed",
+      });
+    }
+  }
+
+  /** Full teardown (workspace switch / proxied off). */
+  destroy() {
+    this.gen++;
+    try {
+      this.createHandle?.unmountCanvas?.({ destroy: true });
+    } catch {
+      /* ignore */
+    }
+    try {
+      this.canvasHandle?.destroy();
+    } catch {
+      /* ignore */
+    }
+    this.canvasHandle = null;
+    try {
+      this.ceNative?.destroy();
+    } catch {
+      /* ignore */
+    }
+    this.ceNative = null;
+    this.createHandle = null;
+    if (this.sidebarEl) this.sidebarEl.innerHTML = "";
+    if (this.canvasEl) this.canvasEl.innerHTML = "";
+    if (this.parkHost) {
+      try {
+        this.parkHost.innerHTML = "";
+        this.parkHost.remove();
+      } catch {
+        /* ignore */
+      }
+    }
+    this.parkHost = null;
+    this.sidebarEl = null;
+    this.canvasEl = null;
+    this.modulesReady = false;
+    this.bootPromise = null;
+    // Release fetch shim via bootstrap if it was installed
+    try {
+      (window as unknown as { __syEmbedReleaseFetch?: () => void })
+        .__syEmbedReleaseFetch?.();
+    } catch {
+      /* ignore */
+    }
+    try {
+      document.body.classList.remove("sy-embed-hosting", "hosted");
+    } catch {
+      /* ignore */
+    }
+    this.setState({ status: "idle" });
+  }
+}
+
+/** Process-wide session (one CE wiki embed at a time per PWA). */
+let singleton: CeEmbedSession | null = null;
+
+export function getCeEmbedSession(): CeEmbedSession {
+  if (!singleton) singleton = new CeEmbedSession();
+  return singleton;
+}
+
+export function resetCeEmbedSession(): void {
+  singleton?.destroy();
+  singleton = null;
+}
+
diff --git a/frontend/src/widgets/embed/ceEmbedShell.html b/frontend/src/widgets/embed/ceEmbedShell.html
new file mode 100644
index 0000000..42908b8
--- /dev/null
+++ b/frontend/src/widgets/embed/ceEmbedShell.html
@@ -0,0 +1,118 @@
+<!-- CE canvas embed shell: graph-pane + modal (no sidebar). -->
+<main id="graph-pane">
+    <div id="graph"></div>
+    <div class="graph-search">
+      <input id="graph-search-input" type="search" placeholder="Search wiki…" autocomplete="off" spellcheck="false" aria-label="Search the graph">
+      <span id="graph-search-count" class="graph-search-count" hidden></span>
+      <button id="graph-search-clear" class="icon-btn graph-search-clear" title="Clear search" aria-label="Clear search" hidden>
+        <svg viewBox="0 0 16 16" width="12" height="12"><line x1="4" y1="4" x2="12" y2="12" stroke="currentColor" stroke-width="1.4" stroke-linecap="round"/><line x1="12" y1="4" x2="4" y2="12" stroke="currentColor" stroke-width="1.4" stroke-linecap="round"/></svg>
+      </button>
+    </div>
+    <div class="graph-controls">
+      <button id="viewer-mode" class="ctrl-btn hidden" title="Switch graph viewer" aria-label="Switch graph viewer">
+        <span class="ctrl-label">view:</span><span id="viewer-mode-state">classic</span>
+      </button>
+      <button id="label-mode" class="ctrl-btn" title="Label visibility" aria-label="Label visibility">
+        <span class="ctrl-label">labels:</span><span id="label-mode-state">auto</span>
+      </button>
+      <button id="edge-mode" class="ctrl-btn hidden" title="Edge visibility (Atlas)" aria-label="Edge visibility">
+        <span class="ctrl-label">edges:</span><span id="edge-mode-state">auto</span>
+      </button>
+      <button id="split-toggle" class="ctrl-btn" title="Partition selected pages (rubber-band / Shift-click on graph)" aria-label="Workspace split" aria-pressed="false">
+        <span class="ctrl-label">split</span><span id="split-count">0</span>
+      </button>
+      <button id="replay-toggle" class="ctrl-btn" title="Replay curation history animation" aria-label="Replay curation history" aria-pressed="false">
+        <span class="ctrl-label">replay</span><span aria-hidden="true">↻</span>
+      </button>
+      <button id="label-types" class="ctrl-btn" title="Which page types show labels" aria-label="Which page types show labels">
+        <span class="ctrl-label">types:</span><span id="label-types-state">4/11</span>
+      </button>
+      <div id="label-types-panel" class="label-types-panel hidden" role="dialog" aria-label="Label types">
+        <div class="label-types-head">Show labels for</div>
+        <label class="label-types-row" data-type="project"><input type="checkbox"><span class="dot dot-project"></span><span>Projects</span></label>
+        <label class="label-types-row" data-type="analysis"><input type="checkbox"><span class="dot dot-analysis"></span><span>Analyses</span></label>
+        <label class="label-types-row" data-type="concept"><input type="checkbox"><span class="dot dot-concept"></span><span>Concepts</span></label>
+        <label class="label-types-row" data-type="entity"><input type="checkbox"><span class="dot dot-entity"></span><span>Entities</span></label>
+        <label class="label-types-row" data-type="evidence"><input type="checkbox"><span class="dot dot-evidence"></span><span>Evidence</span></label>
+        <label class="label-types-row" data-type="fact"><input type="checkbox"><span class="dot dot-fact"></span><span>Facts</span></label>
+        <label class="label-types-row" data-type="figure"><input type="checkbox"><span class="dot dot-figure"></span><span>Figures</span></label>
+        <label class="label-types-row" data-type="table"><input type="checkbox"><span class="dot dot-table"></span><span>Tables</span></label>
+        <label class="label-types-row" data-type="source"><input type="checkbox"><span class="dot dot-source"></span><span>Sources</span></label>
+        <label class="label-types-row" data-type="note"><input type="checkbox"><span class="dot dot-note"></span><span>Notes</span></label>
+        <label class="label-types-row" data-type="todo"><input type="checkbox"><span class="dot dot-todo"></span><span>Todos</span></label>
+        <label class="label-types-row" data-type="unclassified"><input type="checkbox"><span class="dot dot-unclassified"></span><span>Unclassified</span></label>
+        <button id="label-types-reset" class="settings-reset">Reset</button>
+      </div>
+    </div>
+
+    <div id="split-panel" class="split-panel" hidden>
+      <div class="split-head">Partition workspace</div>
+      <p class="split-help">Move or copy wiki pages into a new workspace. Classic: Ctrl/⌘-drag rubber-band, Shift-click multi-select, click toggle, right-click flips move↔copy. Shells keep tab/registry chrome.</p>
+      <div class="split-fields">
+        <label class="split-field">Name <input id="split-name" type="text" placeholder="new-workspace" autocomplete="off" spellcheck="false"></label>
+        <label class="split-field">Target <input id="split-target" type="text" placeholder="optional absolute path (or CE_SPLIT_HOME/name)" autocomplete="off" spellcheck="false"></label>
+      </div>
+      <div id="split-list" class="split-list"></div>
+      <div class="split-actions">
+        <button type="button" id="split-add" class="ctrl-btn">Add current</button>
+        <button type="button" id="split-submit" class="ctrl-btn" disabled>Split</button>
+        <button type="button" id="split-cancel" class="ctrl-btn">Cancel</button>
+      </div>
+      <div id="split-status" class="split-status" aria-live="polite"></div>
+    </div>
+
+    <button id="settings-trigger" class="icon-btn settings-trigger" title="Physics settings" aria-label="Physics settings">
+      <svg viewBox="0 0 24 24" width="14" height="14" fill="none" stroke="currentColor" stroke-width="1.6" stroke-linecap="round" stroke-linejoin="round">
+        <path d="M10.325 4.317c.426-1.756 2.924-1.756 3.35 0a1.724 1.724 0 002.573 1.066c1.543-.94 3.31.826 2.37 2.37a1.724 1.724 0 001.065 2.572c1.756.426 1.756 2.924 0 3.35a1.724 1.724 0 00-1.066 2.573c.94 1.543-.826 3.31-2.37 2.37a1.724 1.724 0 00-2.572 1.065c-.426 1.756-2.924 1.756-3.35 0a1.724 1.724 0 00-2.573-1.066c-1.543.94-3.31-.826-2.37-2.37a1.724 1.724 0 00-1.065-2.572c-1.756-.426-1.756-2.924 0-3.35a1.724 1.724 0 001.066-2.573c-.94-1.543.826-3.31 2.37-2.37.996.608 2.296.07 2.572-1.065z"/>
+        <circle cx="12" cy="12" r="3"/>
+      </svg>
+    </button>
+    <div id="settings-panel" class="settings-panel hidden" role="dialog" aria-label="Physics settings">
+      <div class="settings-head">Physics</div>
+      <div class="settings-row">
+        <label for="phys-charge">Repulsion</label>
+        <input id="phys-charge" type="range" min="-2000" max="-50" step="10" value="-1000">
+        <span id="phys-charge-val" class="settings-val">-1000</span>
+      </div>
+      <div class="settings-row">
+        <label for="phys-link">Link distance</label>
+        <input id="phys-link" type="range" min="20" max="400" step="5" value="220">
+        <span id="phys-link-val" class="settings-val">220</span>
+      </div>
+      <div class="settings-row">
+        <label for="phys-collide">Collide pad</label>
+        <input id="phys-collide" type="range" min="0" max="40" step="1" value="28">
+        <span id="phys-collide-val" class="settings-val">28</span>
+      </div>
+      <button id="phys-reset" class="settings-reset">Reset</button>
+    </div>
+  </main>
+<div id="modal-backdrop" class="hidden" aria-hidden="true"></div>
+  <div id="modal" class="hidden" role="dialog" aria-modal="true" aria-hidden="true">
+    <button id="modal-padlock" class="icon-btn modal-padlock" title="Edit" aria-label="Edit page" data-editing="false" style="display:none">
+      <!-- Two padlock paths swapped via CSS based on data-editing. -->
+      <svg class="padlock-closed" viewBox="0 0 16 16" width="13" height="13" fill="none" stroke="currentColor" stroke-width="1.4" stroke-linecap="round" stroke-linejoin="round">
+        <rect x="3.5" y="7.5" width="9" height="6" rx="1"/>
+        <path d="M5.5 7.5 V5.5 a 2.5 2.5 0 0 1 5 0 V7.5"/>
+      </svg>
+      <svg class="padlock-open" viewBox="0 0 16 16" width="13" height="13" fill="none" stroke="currentColor" stroke-width="1.4" stroke-linecap="round" stroke-linejoin="round">
+        <rect x="3.5" y="7.5" width="9" height="6" rx="1"/>
+        <path d="M5.5 7.5 V5.5 a 2.5 2.5 0 0 1 5 0"/>
+      </svg>
+    </button>
+    <button id="modal-close" class="icon-btn modal-close" title="Close" aria-label="Close">
+      <svg viewBox="0 0 16 16" width="12" height="12"><line x1="4" y1="4" x2="12" y2="12" stroke="currentColor" stroke-width="1.4" stroke-linecap="round"/><line x1="12" y1="4" x2="4" y2="12" stroke="currentColor" stroke-width="1.4" stroke-linecap="round"/></svg>
+    </button>
+    <div id="modal-content">
+      <h1 id="modal-title"></h1>
+      <section class="properties">
+        <div class="properties-head">Properties</div>
+        <table id="modal-properties"></table>
+      </section>
+      <article id="modal-body"></article>
+      <section class="subgraph-pane">
+        <div class="subgraph-head" id="modal-subgraph-head"></div>
+        <div id="modal-subgraph"></div>
+      </section>
+    </div>
+  </div>
diff --git a/frontend/src/widgets/embed/ceSidebarShell.html b/frontend/src/widgets/embed/ceSidebarShell.html
new file mode 100644
index 0000000..41ed566
--- /dev/null
+++ b/frontend/src/widgets/embed/ceSidebarShell.html
@@ -0,0 +1,47 @@
+<!-- CE sidebar embed shell: Pages|Files + search (persistent shell left column). -->
+<aside id="sidebar">
+    <header class="sidebar-head">
+      <button id="sidebar-toggle" class="icon-btn" title="Collapse sidebar" aria-label="Collapse sidebar">
+        <svg viewBox="0 0 16 16" width="14" height="14"><path d="M10 4 L6 8 L10 12" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/></svg>
+      </button>
+      <span class="workspace-name">{{WORKSPACE}}</span>
+      <div class="sidebar-mode-seg" role="group" aria-label="Sidebar mode">
+        <button type="button" id="sidebar-mode-pages" class="sidebar-mode-btn" aria-pressed="true">Pages</button>
+        <button type="button" id="sidebar-mode-files" class="sidebar-mode-btn" aria-pressed="false" title="Browse vault/ and wiki/ files">Files</button>
+      </div>
+    </header>
+    <div class="sidebar-search-wrap">
+      <input id="sidebar-search" type="search" placeholder="Search pages…" autocomplete="off" spellcheck="false">
+      <button id="sidebar-toggle-all" class="icon-btn sidebar-toggle-all" data-action="toggle-all-groups" title="Collapse or expand all page types" aria-label="Collapse or expand all page types">
+        <svg viewBox="0 0 16 16" width="14" height="14" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round">
+          <path d="M3 6 L8 2.5 L13 6"/>
+          <path d="M3 10 L8 13.5 L13 10"/>
+        </svg>
+      </button>
+      <button id="sidebar-upload" class="icon-btn sidebar-upload" title="Upload to vault" aria-label="Upload to vault">
+        <svg viewBox="0 0 16 16" width="14" height="14" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round">
+          <line x1="8" y1="3" x2="8" y2="13"/>
+          <line x1="3" y1="8" x2="13" y2="8"/>
+        </svg>
+      </button>
+      <input id="sidebar-upload-input" type="file" multiple style="display:none">
+    </div>
+    <div id="sidebar-list" class="sidebar-list" role="listbox"></div>
+    <div id="filebrowser-pane" class="filebrowser-pane" hidden>
+      <div class="filebrowser-toolbar">
+        <input id="filebrowser-search" type="search" placeholder="Filter files… /re/ or *.md" autocomplete="off" spellcheck="false" aria-label="Filter files">
+        <button type="button" id="filebrowser-sort" class="icon-btn" title="Sort A→Z" aria-label="Sort A→Z">⇅</button>
+        <button type="button" id="filebrowser-refresh" class="icon-btn" title="Refresh tree" aria-label="Refresh tree">↻</button>
+      </div>
+      <div id="filebrowser-list" class="filebrowser-list" role="tree" aria-label="Vault and wiki files"></div>
+      <div id="filebrowser-status" class="filebrowser-status" aria-live="polite"></div>
+    </div>
+    <div id="filebrowser-menu" class="filebrowser-menu" hidden role="menu"></div>
+    <footer class="sidebar-foot">
+      <button id="theme-toggle" class="icon-btn" title="Toggle theme" aria-label="Toggle theme">
+        <svg id="theme-icon-sun" viewBox="0 0 16 16" width="14" height="14"><circle cx="8" cy="8" r="3" fill="currentColor"/><g stroke="currentColor" stroke-width="1.3" stroke-linecap="round"><line x1="8" y1="1.5" x2="8" y2="3"/><line x1="8" y1="13" x2="8" y2="14.5"/><line x1="1.5" y1="8" x2="3" y2="8"/><line x1="13" y1="8" x2="14.5" y2="8"/><line x1="3.4" y1="3.4" x2="4.5" y2="4.5"/><line x1="11.5" y1="11.5" x2="12.6" y2="12.6"/><line x1="3.4" y1="12.6" x2="4.5" y2="11.5"/><line x1="11.5" y1="4.5" x2="12.6" y2="3.4"/></g></svg>
+        <svg id="theme-icon-moon" viewBox="0 0 16 16" width="14" height="14"><path d="M12.5 9.5 a 5 5 0 1 1 -6 -6 a 4 4 0 0 0 6 6 z" fill="currentColor"/></svg>
+      </button>
+      <span class="meta-counts" id="meta-counts"></span>
+    </footer>
+  </aside>
diff --git a/frontend/src/widgets/embed/embedMount.test.ts b/frontend/src/widgets/embed/embedMount.test.ts
new file mode 100644
index 0000000..4210409
--- /dev/null
+++ b/frontend/src/widgets/embed/embedMount.test.ts
@@ -0,0 +1,209 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import {
+  documentDir,
+  embedFetchShimScript,
+  embedHostShimScript,
+  extractScripts,
+  isSwitchbayReservedApi,
+  mapStatusBanner,
+  prepareEmbedHtml,
+  rewriteAssetUrl,
+  rewriteHtmlUrls,
+} from "./embedMount.ts";
+
+test("documentDir resolves trailing and file paths", () => {
+  assert.equal(documentDir("/embed/ce", "/"), "/embed/ce/");
+  assert.equal(documentDir("/embed/ce", "/observer/"), "/embed/ce/observer/");
+  assert.equal(documentDir("/embed/okstratr", "/observer/index.html"), "/embed/okstratr/observer/");
+});
+
+test("rewriteAssetUrl maps relative, root-relative, and loopback", () => {
+  assert.equal(
+    rewriteAssetUrl("static/main.js", "/embed/ce", "/"),
+    "/embed/ce/static/main.js",
+  );
+  assert.equal(
+    rewriteAssetUrl("observer.css", "/embed/okstratr", "/observer/"),
+    "/embed/okstratr/observer/observer.css",
+  );
+  assert.equal(
+    rewriteAssetUrl("/api/graph", "/embed/ce", "/"),
+    "/embed/ce/api/graph",
+  );
+  assert.equal(
+    rewriteAssetUrl("http://127.0.0.1:8766/static/x.js", "/embed/ce", "/"),
+    "/embed/ce/static/x.js",
+  );
+  assert.equal(
+    rewriteAssetUrl("https://fonts.googleapis.com/css", "/embed/ce", "/"),
+    "https://fonts.googleapis.com/css",
+  );
+  assert.equal(
+    rewriteAssetUrl("data:image/png;base64,xx", "/embed/ce", "/"),
+    "data:image/png;base64,xx",
+  );
+  assert.equal(
+    rewriteAssetUrl("/embed/ce/static/main.js", "/embed/ce", "/"),
+    "/embed/ce/static/main.js",
+  );
+  assert.equal(
+    rewriteAssetUrl("../vendor/d3.js", "/embed/ce", "/static/app/"),
+    "/embed/ce/static/vendor/d3.js",
+  );
+});
+
+test("rewriteHtmlUrls rewrites src/href/srcset and style url()", () => {
+  const html = `
+<link rel="stylesheet" href="static/main.css">
+<img srcset="a.png 1x, /b.png 2x">
+<div style="background:url('img/bg.png')"></div>
+<script src="static/main.js"></script>
+`;
+  const out = rewriteHtmlUrls(html, "/embed/ce", "/");
+  assert.match(out, /href="\/embed\/ce\/static\/main\.css"/);
+  assert.match(out, /src="\/embed\/ce\/static\/main\.js"/);
+  assert.match(out, /srcset="\/embed\/ce\/a\.png 1x, \/embed\/ce\/b\.png 2x"/);
+  assert.match(out, /url\('\/embed\/ce\/img\/bg\.png'\)/);
+});
+
+test("extractScripts preserves order and module/classic", () => {
+  const html = `
+<script src="/embed/ce/a.js"></script>
+<script type="module">import "/x";</script>
+<script>window.BOOT=1;</script>
+`;
+  const { htmlWithoutScripts, scripts } = extractScripts(html);
+  assert.equal(scripts.length, 3);
+  assert.equal(scripts[0].type, "classic");
+  assert.equal(scripts[0].src, "/embed/ce/a.js");
+  assert.equal(scripts[1].type, "module");
+  assert.equal(scripts[1].content, 'import "/x";');
+  assert.equal(scripts[2].content, "window.BOOT=1;");
+  assert.equal(htmlWithoutScripts.includes("<script"), false);
+});
+
+test("prepareEmbedHtml yields markup + rewritten script srcs", () => {
+  const html = `<!DOCTYPE html><html><head>
+<link rel="stylesheet" href="static/main.css">
+</head><body>
+<div id="graph"></div>
+<script src="static/main.js"></script>
+</body></html>`;
+  const { markup, scripts } = prepareEmbedHtml(html, "/embed/ce", "/");
+  assert.match(markup, /id="graph"/);
+  assert.match(markup, /href="\/embed\/ce\/static\/main\.css"/);
+  assert.equal(scripts.length, 1);
+  assert.equal(scripts[0].src, "/embed/ce/static/main.js");
+  assert.equal(markup.includes("<script"), false);
+});
+
+test("mapStatusBanner: starting suppresses 502 and blocks mount", () => {
+  const b = mapStatusBanner("ce", {
+    ce: { state: "starting", detail: "booting" },
+    okstratr: { state: "healthy" },
+    wiki_build: { state: "idle", pages: null, detail: "" },
+  });
+  assert.equal(b.kind, "starting");
+  assert.equal(b.allowMount, false);
+  assert.equal(b.suppressFetchError, true);
+  assert.match(b.label, /starting/i);
+});
+
+test("mapStatusBanner: stopped treated as starting wait chrome", () => {
+  const b = mapStatusBanner("okstratr", {
+    ce: { state: "healthy" },
+    okstratr: { state: "stopped" },
+    wiki_build: { state: "idle" },
+  });
+  assert.equal(b.kind, "starting");
+  assert.equal(b.suppressFetchError, true);
+});
+
+test("mapStatusBanner: unhealthy", () => {
+  const b = mapStatusBanner("ce", {
+    ce: { state: "unhealthy", detail: "exit 1" },
+    wiki_build: { state: "idle" },
+  });
+  assert.equal(b.kind, "unhealthy");
+  assert.equal(b.allowMount, false);
+  assert.match(b.label, /unhealthy/);
+});
+
+test("mapStatusBanner: live vs building wiki", () => {
+  const live = mapStatusBanner("ce", {
+    ce: { state: "healthy" },
+    wiki_build: { state: "idle" },
+  });
+  assert.equal(live.kind, "live");
+  assert.equal(live.allowMount, true);
+
+  const building = mapStatusBanner("ce", {
+    ce: { state: "healthy" },
+    wiki_build: { state: "building", pages: 3 },
+  });
+  assert.equal(building.kind, "building_wiki");
+  assert.equal(building.allowMount, true);
+  assert.match(building.label, /wiki/i);
+});
+
+test("isSwitchbayReservedApi protects control-plane paths", () => {
+  assert.equal(isSwitchbayReservedApi("/api/settings"), true);
+  assert.equal(isSwitchbayReservedApi("/api/core-skills/status"), true);
+  assert.equal(isSwitchbayReservedApi("/api/graph/data"), true);
+  assert.equal(isSwitchbayReservedApi("/api/workspaces/switch"), true);
+  assert.equal(isSwitchbayReservedApi("/api/tree"), true);
+  assert.equal(isSwitchbayReservedApi("/api/llm/providers"), true);
+  assert.equal(isSwitchbayReservedApi("/api/page?path=x"), false);
+  assert.equal(isSwitchbayReservedApi("/api/vault/foo"), false);
+  assert.equal(isSwitchbayReservedApi("/api/desk/status"), false);
+  assert.equal(isSwitchbayReservedApi("/api/workspace/select"), false);
+});
+
+test("embedFetchShimScript rewrites data.json onto public base", () => {
+  const shim = embedFetchShimScript("/embed/ce");
+  assert.equal(shim.type, "classic");
+  assert.ok(shim.content);
+  assert.match(shim.content!, /\/embed\/ce/);
+  assert.match(shim.content!, /data\.json/);
+  // Evaluate shim in a minimal fetch stub.
+  const calls: string[] = [];
+  const g = globalThis as typeof globalThis & {
+    window: any;
+    fetch: typeof fetch;
+  };
+  g.window = g;
+  g.fetch = (async (input: any) => {
+    calls.push(typeof input === "string" ? input : String(input?.url));
+    return new Response("{}");
+  }) as typeof fetch;
+  // eslint-disable-next-line no-eval
+  eval(shim.content!);
+  void g.fetch("data.json");
+  void g.fetch("data.json?t=1");
+  void g.fetch("/api/page?path=notes/x.md");
+  void g.fetch("/embed/ce/already");
+  void g.fetch("/api/settings");
+  void g.fetch("/api/core-skills/status");
+  void g.fetch("/api/tree");
+  void g.fetch("/api/llm/providers");
+  assert.equal(calls[0], "/embed/ce/data.json");
+  assert.equal(calls[1], "/embed/ce/data.json?t=1");
+  assert.equal(calls[2], "/embed/ce/api/page?path=notes/x.md");
+  assert.equal(calls[3], "/embed/ce/already");
+  assert.equal(calls[4], "/api/settings");
+  assert.equal(calls[5], "/api/core-skills/status");
+  assert.equal(calls[6], "/api/tree");
+  assert.equal(calls[7], "/api/llm/providers");
+  // Release restores fetch
+  assert.equal(typeof g.window.__syEmbedReleaseFetch, "function");
+  g.window.__syEmbedReleaseFetch();
+  assert.equal(g.window.__syEmbedFetchBase, null);
+});
+
+test("embedHostShimScript marks syHost and guards body.innerHTML", () => {
+  const shim = embedHostShimScript('[data-sy-embed-root="1"]');
+  assert.equal(shim.type, "classic");
+  assert.match(shim.content!, /syHost/);
+  assert.match(shim.content!, /innerHTML/);
+});
diff --git a/frontend/src/widgets/embed/embedMount.ts b/frontend/src/widgets/embed/embedMount.ts
new file mode 100644
index 0000000..b56a5cd
--- /dev/null
+++ b/frontend/src/widgets/embed/embedMount.ts
@@ -0,0 +1,555 @@
+/**
+ * Embed v2 same-document mount helpers (no iframe).
+ *
+ * Mount algorithm (see docs/ADR-004b-embed-v2-same-document-mount.md):
+ * 1. Tear down prior mount (clear panel root + remove injected <script> nodes).
+ * 2. fetch(`/embed/{ce|okstratr}/…`) for proxied HTML.
+ * 3. rewriteHtmlUrls → absolute `/embed/…` asset paths.
+ * 4. extractScripts → markup without <script>; script descriptors for execution.
+ * 5. Inject markup into the panel root (innerHTML).
+ * 6. Recreate each <script> via createElement + append so the browser executes
+ *    classic and module scripts (innerHTML never runs scripts).
+ * Soft-reload / unmount repeats step 1 first to avoid duplicate roots/listeners.
+ */
+
+export type EmbedScript = {
+  type: "classic" | "module";
+  src?: string;
+  content?: string;
+  async?: boolean;
+  defer?: boolean;
+  crossOrigin?: string | null;
+  integrity?: string | null;
+  referrerPolicy?: string | null;
+  noModule?: boolean;
+};
+
+export type PrepareResult = {
+  /** Body (+ head stylesheet/style) markup with scripts removed and URLs rewritten. */
+  markup: string;
+  scripts: EmbedScript[];
+};
+
+/** Directory URL (trailing slash) for resolving relative asset paths. */
+export function documentDir(publicBase: string, pagePath: string): string {
+  const base = publicBase.replace(/\/$/, "") || "";
+  let path = pagePath.startsWith("/") ? pagePath : `/${pagePath}`;
+  if (!path) path = "/";
+  const full = `${base}${path}`;
+  if (full.endsWith("/")) return full;
+  const idx = full.lastIndexOf("/");
+  return idx >= 0 ? full.slice(0, idx + 1) : `${base}/`;
+}
+
+function joinResolved(docDir: string, relative: string): string {
+  // docDir always ends with /
+  const parts = docDir.replace(/\/$/, "").split("/");
+  for (const seg of relative.split("/")) {
+    if (!seg || seg === ".") continue;
+    if (seg === "..") {
+      if (parts.length > 1) parts.pop();
+      continue;
+    }
+    parts.push(seg);
+  }
+  // parts[0] is "" for absolute paths like ["", "embed", "ce", ...]
+  return parts.join("/") || "/";
+}
+
+/**
+ * Rewrite a single URL attribute value under publicBase.
+ * Leaves fragments, data:, blob:, javascript:, and external http(s) hosts alone.
+ * Maps loopback absolute URLs and root-relative paths onto publicBase.
+ */
+export function rewriteAssetUrl(
+  raw: string,
+  publicBase: string,
+  pagePath: string,
+): string {
+  const u = (raw || "").trim();
+  if (!u) return u;
+  if (
+    u.startsWith("#") ||
+    u.startsWith("data:") ||
+    u.startsWith("blob:") ||
+    u.startsWith("javascript:") ||
+    u.startsWith("mailto:")
+  ) {
+    return u;
+  }
+
+  const base = publicBase.replace(/\/$/, "") || "";
+
+  // Protocol-relative — leave (external CDN etc.)
+  if (u.startsWith("//")) return u;
+
+  // Absolute with scheme
+  if (/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(u)) {
+    try {
+      const parsed = new URL(u);
+      const host = parsed.hostname.toLowerCase();
+      if (host === "127.0.0.1" || host === "localhost" || host === "::1") {
+        const path = parsed.pathname || "/";
+        return `${base}${path}${parsed.search}${parsed.hash}`;
+      }
+    } catch {
+      /* keep */
+    }
+    return u;
+  }
+
+  // Already under public base
+  if (base && (u === base || u.startsWith(`${base}/`))) return u;
+
+  // Root-relative → prefix public base
+  if (u.startsWith("/")) return `${base}${u}`;
+
+  // Relative → resolve against document directory
+  const dir = documentDir(publicBase, pagePath);
+  return joinResolved(dir, u);
+}
+
+function rewriteSrcset(
+  value: string,
+  publicBase: string,
+  pagePath: string,
+): string {
+  return value
+    .split(",")
+    .map((part) => {
+      const trimmed = part.trim();
+      if (!trimmed) return trimmed;
+      const m = trimmed.match(/^(\S+)(\s+.*)?$/);
+      if (!m) return trimmed;
+      const rewritten = rewriteAssetUrl(m[1], publicBase, pagePath);
+      return m[2] ? `${rewritten}${m[2]}` : rewritten;
+    })
+    .join(", ");
+}
+
+function rewriteCssUrls(
+  css: string,
+  publicBase: string,
+  pagePath: string,
+): string {
+  return css.replace(/url\(\s*(['"]?)([^'")]+)\1\s*\)/gi, (_all, quote: string, ref: string) => {
+    const next = rewriteAssetUrl(ref.trim(), publicBase, pagePath);
+    const q = quote || "";
+    return `url(${q}${next}${q})`;
+  });
+}
+
+const ATTR_URL_RE =
+  /\b(src|href|poster|action|formaction|data-src|data-href)\s*=\s*(["'])([^"']*)\2/gi;
+const SRCSET_RE = /\bsrcset\s*=\s*(["'])([^"']*)\1/gi;
+/** Rewrite asset URLs in an HTML string for same-origin `/embed/*` serving. */
+export function rewriteHtmlUrls(
+  html: string,
+  publicBase: string,
+  pagePath: string,
+): string {
+  let out = html.replace(ATTR_URL_RE, (_all, attr: string, quote: string, val: string) => {
+    const next = rewriteAssetUrl(val, publicBase, pagePath);
+    return `${attr}=${quote}${next}${quote}`;
+  });
+  out = out.replace(SRCSET_RE, (_all, quote: string, val: string) => {
+    return `srcset=${quote}${rewriteSrcset(val, publicBase, pagePath)}${quote}`;
+  });
+  // Double- and single-quoted style attrs separately so nested quotes in url() work.
+  out = out.replace(/\bstyle\s*=\s*"([^"]*)"/gi, (_all, val: string) => {
+    return `style="${rewriteCssUrls(val, publicBase, pagePath)}"`;
+  });
+  out = out.replace(/\bstyle\s*=\s*'([^']*)'/gi, (_all, val: string) => {
+    return `style='${rewriteCssUrls(val, publicBase, pagePath)}'`;
+  });
+  out = out.replace(
+    /<style\b([^>]*)>([\s\S]*?)<\/style>/gi,
+    (_all, attrs: string, body: string) =>
+      `<style${attrs}>${rewriteCssUrls(body, publicBase, pagePath)}</style>`,
+  );
+  return out;
+}
+
+function parseScriptOpeningAttrs(attrText: string): EmbedScript {
+  const lower = attrText.toLowerCase();
+  const typeMatch = attrText.match(/\btype\s*=\s*(["'])([^"']*)\1/i);
+  const typeVal = (typeMatch?.[2] || "").trim().toLowerCase();
+  const isModule = typeVal === "module" || /\btype\s*=\s*module\b/i.test(attrText);
+  const srcMatch = attrText.match(/\bsrc\s*=\s*(["'])([^"']*)\1/i);
+  const crossMatch = attrText.match(/\bcrossorigin\s*=\s*(["'])([^"']*)\1/i);
+  const integrityMatch = attrText.match(/\bintegrity\s*=\s*(["'])([^"']*)\1/i);
+  const referrerMatch = attrText.match(/\breferrerpolicy\s*=\s*(["'])([^"']*)\1/i);
+  return {
+    type: isModule ? "module" : "classic",
+    src: srcMatch?.[2],
+    async: /\basync\b/i.test(lower),
+    defer: /\bdefer\b/i.test(lower),
+    noModule: /\bnomodule\b/i.test(lower),
+    crossOrigin: crossMatch ? crossMatch[2] : /\bcrossorigin\b/i.test(lower) ? "" : null,
+    integrity: integrityMatch?.[2] ?? null,
+    referrerPolicy: referrerMatch?.[2] ?? null,
+  };
+}
+
+/**
+ * Pull `<script>` tags out of HTML (order preserved) and return markup without them.
+ * Script `src` values should already be rewritten (call rewriteHtmlUrls first).
+ */
+export function extractScripts(html: string): {
+  htmlWithoutScripts: string;
+  scripts: EmbedScript[];
+} {
+  const scripts: EmbedScript[] = [];
+  const htmlWithoutScripts = html.replace(
+    /<script\b([^>]*)>([\s\S]*?)<\/script>/gi,
+    (_all, attrs: string, body: string) => {
+      const desc = parseScriptOpeningAttrs(attrs || "");
+      if (desc.src) {
+        scripts.push({ ...desc, content: undefined });
+      } else {
+        scripts.push({ ...desc, content: body, src: undefined });
+      }
+      return "";
+    },
+  );
+  return { htmlWithoutScripts, scripts };
+}
+
+/** Collect head stylesheets/styles + body inner HTML for panel injection. */
+export function extractMountMarkup(html: string): string {
+  const headMatch = html.match(/<head\b[^>]*>([\s\S]*?)<\/head>/i);
+  const bodyMatch = html.match(/<body\b[^>]*>([\s\S]*)<\/body>/i);
+  const head = headMatch ? headMatch[1] : "";
+  const body = bodyMatch ? bodyMatch[1] : html;
+
+  const headAssets: string[] = [];
+  const linkRe = /<link\b[^>]*>/gi;
+  let m: RegExpExecArray | null;
+  while ((m = linkRe.exec(head)) !== null) {
+    const tag = m[0];
+    if (/\brel\s*=\s*(["'])stylesheet\1/i.test(tag) || /\brel\s*=\s*stylesheet\b/i.test(tag)) {
+      headAssets.push(tag);
+    }
+  }
+  const styleRe = /<style\b[^>]*>[\s\S]*?<\/style>/gi;
+  while ((m = styleRe.exec(head)) !== null) {
+    headAssets.push(m[0]);
+  }
+
+  return `${headAssets.join("\n")}\n${body}`.trim();
+}
+
+/** Full prepare pipeline: rewrite → extract scripts → mount markup. */
+export function prepareEmbedHtml(
+  html: string,
+  publicBase: string,
+  pagePath: string,
+): PrepareResult {
+  const rewritten = rewriteHtmlUrls(html, publicBase, pagePath);
+  const { htmlWithoutScripts, scripts } = extractScripts(rewritten);
+  // Rewrite script.src again is already done via ATTR_URL_RE on the full doc.
+  const markup = extractMountMarkup(htmlWithoutScripts);
+  return { markup, scripts };
+}
+
+/**
+ * Switchbay control-plane `/api/*` prefixes that must NOT be rewritten onto
+ * `/embed/{ce|okstratr}` by the fetch shim. Skill UIs share the document, so
+ * a global fetch patch would otherwise break `/api/settings`, graph SSOT,
+ * core-skills status polls, etc. — leaving Agents stuck on Loading and the
+ * shell unable to talk to the daemon while Graph is open.
+ */
+export const SWITCHBAY_API_RESERVED_PREFIXES = [
+  "/api/settings",
+  "/api/core-skills",
+  "/api/graph",
+  "/api/workspaces",
+  "/api/desks",
+  "/api/mode",
+  "/api/files",
+  "/api/tree",
+  "/api/llm",
+  "/api/rail",
+  "/api/threads",
+  "/api/packs",
+  "/api/pack",
+  "/api/auth",
+  "/api/health",
+  "/api/version",
+  "/api/config",
+  "/api/models",
+  "/api/providers",
+  "/api/orchestration",
+  "/api/micro",
+  "/api/schedules",
+  "/api/projects",
+  "/api/library",
+  "/api/report",
+  "/api/reports",
+  "/api/sketch",
+  "/api/sketches",
+  "/api/sheet",
+  "/api/duckdb",
+  "/api/vega",
+  "/api/terminal",
+  "/api/pty",
+  "/api/ws",
+  "/api/events",
+  "/api/notify",
+  "/api/pasteboard",
+  "/api/clipboard",
+  "/api/owid",
+  "/api/thrusters",
+  "/api/intro",
+] as const;
+
+/** True when a path is a Switchbay daemon route (do not remap onto /embed/*). */
+export function isSwitchbayReservedApi(path: string): boolean {
+  if (!path) return false;
+  let p = path;
+  try {
+    if (/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(path)) {
+      p = new URL(path).pathname;
+    }
+  } catch {
+    /* keep */
+  }
+  const q = p.indexOf("?");
+  if (q >= 0) p = p.slice(0, q);
+  if (!p.startsWith("/api/")) return false;
+  return SWITCHBAY_API_RESERVED_PREFIXES.some(
+    (prefix) => p === prefix || p.startsWith(`${prefix}/`) || p.startsWith(`${prefix}?`),
+  );
+}
+
+/**
+ * Inline classic script that remaps relative + skill `/api/*` fetches onto the
+ * embed public base. Same-document mount keeps Switchbay's document URL, so
+ * CE's `fetch('data.json')` / `fetch('/api/page')` would otherwise miss
+ * `/embed/ce/…`. Injected only by ProxiedSkillPanel — CE standalone on
+ * :8766 is untouched.
+ *
+ * Does **not** rewrite Switchbay reserved `/api/*` (settings, graph, …).
+ * Exposes `window.__syEmbedReleaseFetch` so teardown restores `window.fetch`
+ * (removing the script node alone does not undo the patch).
+ */
+export function embedFetchShimScript(publicBase: string): EmbedScript {
+  const base = JSON.stringify((publicBase || "").replace(/\/$/, "") || "");
+  const reserved = JSON.stringify([...SWITCHBAY_API_RESERVED_PREFIXES]);
+  // Built as an array + join so // and /\./ never appear inside a template
+  // literal (those sequences break when the shim is eval'd / injected).
+  const lines = [
+    "(function(base, reserved){",
+    "  if (!base) return;",
+    "  if (!window.__syEmbedOrigFetch) {",
+    "    window.__syEmbedOrigFetch = window.fetch.bind(window);",
+    "  }",
+    "  window.__syEmbedFetchBase = base;",
+    "  window.__syEmbedFetchDepth = (window.__syEmbedFetchDepth || 0) + 1;",
+    "  var orig = window.__syEmbedOrigFetch;",
+    "  function isReserved(path) {",
+    "    var p = path;",
+    "    var q = p.indexOf('?');",
+    "    if (q >= 0) p = p.slice(0, q);",
+    "    if (p.indexOf('/api/') !== 0) return false;",
+    "    for (var i = 0; i < reserved.length; i++) {",
+    "      var pref = reserved[i];",
+    "      if (p === pref || p.indexOf(pref + '/') === 0) return true;",
+    "    }",
+    "    return false;",
+    "  }",
+    "  function rewrite(u) {",
+    '    if (typeof u !== "string") return u;',
+    '    if (u === "data.json" || u.indexOf("data.json?") === 0) return base + "/" + u;',
+    '    if (u.charAt(0) === "/" && u.indexOf("/embed/") !== 0 && u.indexOf("/api/") === 0) {',
+    "      if (isReserved(u)) return u;",
+    "      return base + u;",
+    "    }",
+    "    if (/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(u)) return u;",
+    '    if (u.indexOf("//") === 0) return u;',
+    '    if (u.charAt(0) === "/") return u;',
+    '    if (u.indexOf("./") === 0) u = u.slice(2);',
+    '    return base + "/" + u;',
+    "  }",
+    "  window.fetch = function(input, init) {",
+    '    if (typeof input === "string") input = rewrite(input);',
+    '    else if (input && typeof Request !== "undefined" && input instanceof Request) {',
+    "      var nu = rewrite(input.url);",
+    "      if (nu !== input.url) input = new Request(nu, input);",
+    "    }",
+    "    return orig(input, init);",
+    "  };",
+    "  window.__syEmbedReleaseFetch = function() {",
+    "    window.__syEmbedFetchDepth = Math.max(0, (window.__syEmbedFetchDepth || 1) - 1);",
+    "    if (window.__syEmbedFetchDepth > 0) return;",
+    "    if (window.__syEmbedOrigFetch) {",
+    "      window.fetch = window.__syEmbedOrigFetch;",
+    "      window.__syEmbedOrigFetch = null;",
+    "    }",
+    "    window.__syEmbedFetchBase = null;",
+    "    window.__syEmbedReleaseFetch = null;",
+    "  };",
+    "})(" + base + ", " + reserved + ");",
+  ];
+  return {
+    type: "classic",
+    content: lines.join("\n"),
+  };
+}
+
+/**
+ * Host shim: mark syHost, keep CE/okstratr from wiping or flex-splitting the
+ * Switchbay shell via document.body, and mirror layout dataset onto the
+ * embed mount root so scoped CSS can follow.
+ */
+export function embedHostShimScript(rootSelector: string): EmbedScript {
+  const sel = JSON.stringify(rootSelector || '[data-sy-embed-root="1"]');
+  const lines = [
+    "(function(sel){",
+    "  var root = document.querySelector(sel);",
+    "  if (!root) return;",
+    "  try { document.documentElement.dataset.syHost = '1'; } catch (e) {}",
+    "  try { document.body.classList.add('sy-embed-hosting'); } catch (e) {}",
+    "  var body = document.body;",
+    "  var proto = Object.getOwnPropertyDescriptor(Element.prototype, 'innerHTML');",
+    "  if (proto && proto.set && proto.get && !body.__syEmbedInnerHtmlPatched) {",
+    "    Object.defineProperty(body, 'innerHTML', {",
+    "      configurable: true,",
+    "      enumerable: true,",
+    "      get: function() { return proto.get.call(this); },",
+    "      set: function(v) {",
+    "        // CE main.js wipes body on data.json failure — keep shell intact.",
+    "        if (root && root.isConnected) { root.innerHTML = v; return; }",
+    "        proto.set.call(this, v);",
+    "      }",
+    "    });",
+    "    body.__syEmbedInnerHtmlPatched = true;",
+    "  }",
+    "  var keys = ['sidebar', 'viewer', 'modal'];",
+    "  function mirror() {",
+    "    if (!root || !root.isConnected) return;",
+    "    for (var i = 0; i < keys.length; i++) {",
+    "      var k = keys[i];",
+    "      var v = body.dataset[k];",
+    "      if (v == null || v === '') root.removeAttribute('data-' + k);",
+    "      else root.setAttribute('data-' + k, v);",
+    "    }",
+    "  }",
+    "  mirror();",
+    "  if (!body.__syEmbedDatasetObserver) {",
+    "    var obs = new MutationObserver(mirror);",
+    "    obs.observe(body, { attributes: true, attributeFilter: keys.map(function(k){ return 'data-' + k; }) });",
+    "    body.__syEmbedDatasetObserver = obs;",
+    "  }",
+    "  window.__syEmbedReleaseHost = function() {",
+    "    try { document.body.classList.remove('sy-embed-hosting'); } catch (e) {}",
+    "    try { document.body.classList.remove('hosted'); } catch (e) {}",
+    "    if (body.__syEmbedDatasetObserver) {",
+    "      try { body.__syEmbedDatasetObserver.disconnect(); } catch (e) {}",
+    "      body.__syEmbedDatasetObserver = null;",
+    "    }",
+    "    if (body.__syEmbedInnerHtmlPatched && proto) {",
+    "      try { delete body.innerHTML; } catch (e) {}",
+    "      body.__syEmbedInnerHtmlPatched = false;",
+    "    }",
+    "    window.__syEmbedReleaseHost = null;",
+    "  };",
+    "})(" + sel + ");",
+  ];
+  return {
+    type: "classic",
+    content: lines.join("\n"),
+  };
+}
+
+// ── Status banner mapping (C1 status shape) ──────────────────────────
+
+export type SkillHealthState = "starting" | "healthy" | "unhealthy" | "stopped";
+export type WikiBuildState = "idle" | "building" | "failed";
+
+export type CoreSkillsStatus = {
+  ce?: { state?: string; url?: string; detail?: string };
+  okstratr?: { state?: string; url?: string; detail?: string };
+  wiki_build?: { state?: string; pages?: number | null; detail?: string };
+};
+
+export type BannerKind = "starting" | "unhealthy" | "building_wiki" | "live" | "unknown";
+
+export type StatusBanner = {
+  kind: BannerKind;
+  label: string;
+  /** True when it is safe to fetch+mount the proxied HTML. */
+  allowMount: boolean;
+  /** True while supervisor is coming up — suppress full 502 error chrome. */
+  suppressFetchError: boolean;
+};
+
+const LABELS: Record<"ce" | "okstratr", string> = {
+  ce: "CE",
+  okstratr: "okstratr",
+};
+
+export function mapStatusBanner(
+  kind: "ce" | "okstratr",
+  status: CoreSkillsStatus | null | undefined,
+): StatusBanner {
+  const slice = kind === "ce" ? status?.ce : status?.okstratr;
+  const state = (slice?.state || "").toLowerCase() as SkillHealthState | "";
+  const wiki = (status?.wiki_build?.state || "").toLowerCase() as WikiBuildState | "";
+  const name = LABELS[kind];
+
+  if (!status || !state) {
+    return {
+      kind: "unknown",
+      label: `Checking ${name} status…`,
+      allowMount: false,
+      suppressFetchError: true,
+    };
+  }
+
+  if (state === "starting" || state === "stopped") {
+    return {
+      kind: "starting",
+      label:
+        state === "stopped"
+          ? `${name} stopped — auto-start pending…`
+          : `${name} starting…`,
+      allowMount: false,
+      suppressFetchError: true,
+    };
+  }
+
+  if (state === "unhealthy") {
+    const detail = slice?.detail ? ` — ${slice.detail}` : "";
+    return {
+      kind: "unhealthy",
+      label: `${name} unhealthy${detail}`,
+      allowMount: false,
+      suppressFetchError: false,
+    };
+  }
+
+  if (state === "healthy") {
+    if (wiki === "building") {
+      return {
+        kind: "building_wiki",
+        label: "Building wiki…",
+        allowMount: true,
+        suppressFetchError: false,
+      };
+    }
+    return {
+      kind: "live",
+      label: `${name} live`,
+      allowMount: true,
+      suppressFetchError: false,
+    };
+  }
+
+  return {
+    kind: "unknown",
+    label: `${name}: ${state || "unknown"}`,
+    allowMount: false,
+    suppressFetchError: true,
+  };
+}
diff --git a/frontend/src/widgets/embed/useProxiedSkillEmbeds.ts b/frontend/src/widgets/embed/useProxiedSkillEmbeds.ts
new file mode 100644
index 0000000..79ae624
--- /dev/null
+++ b/frontend/src/widgets/embed/useProxiedSkillEmbeds.ts
@@ -0,0 +1,58 @@
+import { useEffect, useState } from "react";
+
+/**
+ * Phase 4a feature flag: when true, Graph/Agents use `/embed/*` panels.
+ * Returns `null` until `/api/settings` resolves so adapters do not flash the
+ * built-in (lazy) tabs — that flash caused "Importing a module script failed"
+ * when Agents opened while proxied was actually on.
+ *
+ * Module-level cache: tab switches remount adapters; without a cache each
+ * remount starts at `null` and shows "Loading…" until settings returns
+ * (and a stale CE fetch shim could strand that request).
+ */
+let cachedProxied: boolean | null = null;
+
+export function useProxiedSkillEmbeds(): boolean | null {
+  const [on, setOn] = useState<boolean | null>(() => cachedProxied);
+
+  useEffect(() => {
+    let cancelled = false;
+    void fetch("/api/settings")
+      .then((r) => (r.ok ? r.json() : null))
+      .then((j) => {
+        if (cancelled) return;
+        if (j && typeof j.proxied_skill_embeds === "boolean") {
+          cachedProxied = j.proxied_skill_embeds;
+          setOn(j.proxied_skill_embeds);
+        } else {
+          cachedProxied = false;
+          setOn(false);
+        }
+      })
+      .catch(() => {
+        if (!cancelled) {
+          // Prefer last known cache over forcing false on transient errors
+          // (e.g. brief network blip). First visit still falls back to off.
+          if (cachedProxied === null) {
+            cachedProxied = false;
+            setOn(false);
+          }
+        }
+      });
+
+    const onEvt = (ev: Event) => {
+      const detail = (ev as CustomEvent<{ enabled?: boolean }>).detail;
+      if (detail && typeof detail.enabled === "boolean") {
+        cachedProxied = detail.enabled;
+        setOn(detail.enabled);
+      }
+    };
+    window.addEventListener("sy:proxied-skill-embeds", onEvt);
+    return () => {
+      cancelled = true;
+      window.removeEventListener("sy:proxied-skill-embeds", onEvt);
+    };
+  }, []);
+
+  return on;
+}
diff --git a/frontend/src/widgets/graph/GraphTab.tsx b/frontend/src/widgets/graph/GraphTab.tsx
index ad8c77e..6701c85 100644
--- a/frontend/src/widgets/graph/GraphTab.tsx
+++ b/frontend/src/widgets/graph/GraphTab.tsx
@@ -25,6 +25,23 @@ export default function GraphTab({ data, error, suppressDocModal, showAddFile }:
   const containerRef = useRef<HTMLDivElement>(null);
   const addFileInputRef = useRef<HTMLInputElement>(null);
   const [addingFile, setAddingFile] = useState(false);
+  const [progressMsg, setProgressMsg] = useState<string | null>(
+    data ? null : "Loading graph from cache…",
+  );
+  useEffect(() => {
+    const onProg = (ev: Event) => {
+      const d = (ev as CustomEvent<{ message?: string; done?: boolean }>).detail;
+      if (!d) return;
+      if (d.done) setProgressMsg(null);
+      else if (d.message) setProgressMsg(d.message);
+    };
+    window.addEventListener("sy:graph-progress", onProg);
+    return () => window.removeEventListener("sy:graph-progress", onProg);
+  }, []);
+  useEffect(() => {
+    if (data && !progressMsg) return;
+    if (!data && !progressMsg) setProgressMsg("Loading graph from cache…");
+  }, [data, progressMsg]);
   // The curation replay is OPT-IN now (top-left ↻ button) — it
   // never auto-mounts on workspace load. First-load shows the
   // "Building bundle…" placeholder until data arrives, then the
@@ -287,19 +304,22 @@ export default function GraphTab({ data, error, suppressDocModal, showAddFile }:
     );
   }
   if (!data) {
-    // First-load / workspace-switch placeholder. The animation is
-    // opt-in via the replay button (which only appears once data
-    // is ready) so cold loads stay quiet instead of getting
-    // distracted by the unfinished history.
+    // First-load / workspace-switch placeholder. Prefer live
+    // graph_progress messages so large vaults never look wedged.
     return (
       <div className="sy-placeholder">
         <h2>Graph</h2>
-        <p>Building bundle (running <code>viewer.sh build</code>)…</p>
+        <p>{progressMsg ?? "Loading graph from cache…"}</p>
       </div>
     );
   }
   return (
     <div className="sy-graph-host">
+      {progressMsg && (
+        <div className="sy-graph-progress" role="status" aria-live="polite">
+          {progressMsg}
+        </div>
+      )}
       {hasEditor && selection?.kind === "page" && (
         <button
           type="button"
diff --git a/frontend/src/ws.ts b/frontend/src/ws.ts
index 0a78c85..58093d6 100644
--- a/frontend/src/ws.ts
+++ b/frontend/src/ws.ts
@@ -258,6 +258,17 @@ export type Nav = {
  *  Triggers the Browser file-tree re-fetch and a graph re-fetch. */
 export type FilesChanged = { type: "files_changed" };
 
+/** Background graph cache sync progress (daemon enrich / rebuild). */
+export type GraphProgress = {
+  type: "graph_progress";
+  stage: string;
+  message: string;
+  workspace?: string;
+  current?: number;
+  total?: number;
+  done?: boolean;
+};
+
 /** A capable model produced a rich HTML report (create_report). The
  *  Report tab should focus and load `/api/report/<report_id>`. */
 export type OpenReport = {
@@ -601,6 +612,7 @@ export type ServerMessage =
   | StepFinished
   | Nav
   | FilesChanged
+  | GraphProgress
   | OpenReport
   | OpenIntro
   | OpenComms
diff --git a/frontend/vite.config.ts b/frontend/vite.config.ts
index 0266f6d..ba9bbe9 100644
--- a/frontend/vite.config.ts
+++ b/frontend/vite.config.ts
@@ -18,6 +18,8 @@ export default defineConfig({
       // daemon so handle_figure_file can serve from <ws>/figures/ or
       // <ws>/wiki/figures/ (PDF page rasters, sketch PNGs, etc.).
       "/figures": DAEMON,
+      // Phase 4a: same-origin embed reverse-proxy (CE + okstratr).
+      "/embed": DAEMON,
     },
   },
 });
diff --git a/src/switchbay/app_settings.py b/src/switchbay/app_settings.py
index a06ed57..0735a1f 100644
--- a/src/switchbay/app_settings.py
+++ b/src/switchbay/app_settings.py
@@ -13,6 +13,7 @@
     "workspaces_home": "~/Workspaces",   # see below
     "orchestration_preference": 0.5,  # 0 Economy … 1 Maximum
     "orchestration_denied_models": []  # seed until a workspace file exists
+    "proxied_skill_embeds": false  # Phase 4a: Graph/Agents via /embed/*
   }
 
 `rail_history_local` — where the per-workspace rail-history DB
@@ -32,6 +33,7 @@
 from __future__ import annotations
 
 import json
+import os
 from typing import Any
 
 from . import workspaces
@@ -158,3 +160,23 @@ def set_desk_max_live_workers(value: int) -> int:
     data["desk_max_live_workers"] = n
     save(data)
     return n
+
+
+# `proxied_skill_embeds` — Phase 4a feature flag. When true, the Graph and
+# Agents tabs use same-origin proxied panels under `/embed/ce/` and
+# `/embed/okstratr/` instead of the built-in implementations. Default
+# false so existing UX is unchanged. Env SWITCHBAY_PROXIED_SKILL_EMBEDS=1
+# overrides settings.json to true (useful for local E2E).
+def get_proxied_skill_embeds() -> bool:
+    env = (os.environ.get("SWITCHBAY_PROXIED_SKILL_EMBEDS") or "").strip().lower()
+    if env in ("1", "true", "yes", "on"):
+        return True
+    if env in ("0", "false", "no", "off"):
+        return False
+    return bool(load().get("proxied_skill_embeds", False))
+
+
+def set_proxied_skill_embeds(value: bool) -> None:
+    data = load()
+    data["proxied_skill_embeds"] = bool(value)
+    save(data)
diff --git a/src/switchbay/ce_viewer_supervisor.py b/src/switchbay/ce_viewer_supervisor.py
new file mode 100644
index 0000000..e65d627
--- /dev/null
+++ b/src/switchbay/ce_viewer_supervisor.py
@@ -0,0 +1,538 @@
+"""Keep the CE HTML viewer alive for Switchbay proxied Graph embeds.
+
+When ``proxied_skill_embeds`` is on, Graph loads CE through ``/embed/ce/*``.
+That requires a long-lived CE ``viewer.sh serve`` on loopback. This module
+starts it, health-checks it, and restarts it if it dies. Optional wiki
+mtime polling triggers ``viewer.sh build`` so the served bundle tracks
+wiki edits (reload still needed in the Phase 4a HTML panel).
+
+The viewer is bound to one workspace at a time. ``start(workspace)``
+retargets (stop + serve) when healthy but bound to a different tip so
+``/embed/ce/`` always follows the active workspace.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import os
+import signal
+import subprocess
+import threading
+import time
+from pathlib import Path
+from typing import Any
+from urllib.error import URLError
+from urllib.parse import urlparse
+from urllib.request import urlopen
+
+from . import app_settings, cebridge, embed_proxy
+
+log = logging.getLogger("switchbay.ce_viewer_supervisor")
+
+_PID_NAME = "ce-viewer.pid"
+_LOG_NAME = "ce-viewer.log"
+_WS_NAME = "ce-viewer.workspace"
+_HEALTH_PATH = "/"
+_POLL_SEC = 5.0
+_WIKI_POLL_SEC = 3.0
+
+# Contract C1 wiki_build + CE state (module-level; supervisor updates).
+_CE_STATE: dict[str, str] = {"state": "stopped", "detail": ""}
+_WIKI_BUILD: dict[str, object] = {
+    "state": "idle",  # idle|building|failed
+    "pages": None,
+    "detail": "",
+}
+
+_start_lock = threading.Lock()
+
+
+def _set_ce_state(state: str, detail: str = "") -> None:
+    _CE_STATE["state"] = state
+    _CE_STATE["detail"] = detail
+
+
+def _set_wiki_build(state: str, *, pages=None, detail: str = "") -> None:
+    _WIKI_BUILD["state"] = state
+    _WIKI_BUILD["pages"] = pages
+    _WIKI_BUILD["detail"] = detail
+
+
+def contract_slice(workspace: Path | None = None) -> dict[str, Any]:
+    """C1 status slice for CE."""
+    healthy = is_healthy()
+    pid = _read_pid()
+    if healthy:
+        state = "healthy"
+        detail = _CE_STATE.get("detail") or "up"
+    elif _CE_STATE.get("state") == "starting":
+        state = "starting"
+        detail = _CE_STATE.get("detail") or "starting"
+    elif pid and _pid_alive(pid):
+        state = "unhealthy"
+        detail = _CE_STATE.get("detail") or "process up but health failing"
+    elif _CE_STATE.get("state") == "unhealthy":
+        state = "unhealthy"
+        detail = _CE_STATE.get("detail") or "unhealthy"
+    else:
+        state = "stopped"
+        detail = _CE_STATE.get("detail") or "stopped"
+    return {"state": state, "url": upstream_base(), "detail": detail}
+
+
+def wiki_build_slice() -> dict[str, Any]:
+    """C1 wiki_build slice."""
+    return {
+        "state": str(_WIKI_BUILD.get("state") or "idle"),
+        "pages": _WIKI_BUILD.get("pages"),
+        "detail": str(_WIKI_BUILD.get("detail") or ""),
+    }
+
+
+
+def _state_dir() -> Path:
+    d = Path.home() / ".local" / "state" / "switchbay"
+    d.mkdir(parents=True, exist_ok=True)
+    return d
+
+
+def pid_path() -> Path:
+    return _state_dir() / _PID_NAME
+
+
+def log_path() -> Path:
+    return _state_dir() / _LOG_NAME
+
+
+def workspace_state_path() -> Path:
+    return _state_dir() / _WS_NAME
+
+
+def bound_workspace() -> Path | None:
+    """Workspace the running CE viewer was last successfully started for."""
+    p = workspace_state_path()
+    if not p.is_file():
+        return None
+    try:
+        raw = p.read_text(encoding="utf-8").strip()
+        return Path(raw).expanduser().resolve() if raw else None
+    except OSError:
+        return None
+
+
+def _set_bound_workspace(workspace: Path | None) -> None:
+    p = workspace_state_path()
+    if workspace is None:
+        try:
+            p.unlink(missing_ok=True)
+        except OSError:
+            pass
+        return
+    try:
+        p.write_text(
+            str(Path(workspace).expanduser().resolve()) + "\n",
+            encoding="utf-8",
+        )
+    except OSError as e:
+        log.warning("could not write ce-viewer workspace: %s", e)
+
+
+def upstream_base() -> str:
+    return embed_proxy.ce_upstream()
+
+
+def upstream_port() -> int:
+    u = urlparse(upstream_base())
+    if u.port:
+        return int(u.port)
+    return 443 if u.scheme == "https" else 80
+
+
+def health_url() -> str:
+    return upstream_base().rstrip("/") + _HEALTH_PATH
+
+
+def is_healthy(*, timeout: float = 2.0) -> bool:
+    try:
+        with urlopen(health_url(), timeout=timeout) as resp:  # noqa: S310 — loopback only
+            return 200 <= int(getattr(resp, "status", 200)) < 500
+    except (URLError, OSError, TimeoutError, ValueError):
+        return False
+
+
+def _read_pid() -> int | None:
+    p = pid_path()
+    if not p.is_file():
+        return None
+    try:
+        raw = p.read_text(encoding="utf-8").strip()
+        return int(raw) if raw else None
+    except (OSError, ValueError):
+        return None
+
+
+def _pid_alive(pid: int) -> bool:
+    if pid <= 0:
+        return False
+    try:
+        os.kill(pid, 0)
+        return True
+    except OSError:
+        return False
+
+
+def _public_base() -> str:
+    # Match embed proxy prefix so asset URLs work under /embed/ce/.
+    return (os.environ.get("CE_PUBLIC_BASE") or "/embed/ce").rstrip("/") or "/embed/ce"
+
+
+def bundle_ready(workspace: Path) -> bool:
+    """True when wiki-view cache has enough to serve without a full build."""
+    out = cebridge.output_dir(Path(workspace))
+    return (out / "index.html").is_file() and (out / "data.json").is_file()
+
+
+def _spawn_argv(workspace: Path, port: int) -> tuple[list[str], str]:
+    """Return (argv, mode) for CE serve. Prefer serve-only when cache exists."""
+    script_dir = cebridge.ce_root() / "scripts"
+    if bundle_ready(workspace):
+        server = script_dir / "viewer_server.py"
+        bundle = cebridge.output_dir(workspace)
+        # Match viewer.sh: uv run --no-project python3 viewer_server.py …
+        return (
+            [
+                "uv",
+                "run",
+                "--no-project",
+                "python3",
+                str(server),
+                str(bundle),
+                str(workspace),
+                str(port),
+            ],
+            "serve_only",
+        )
+    script = script_dir / "viewer.sh"
+    return (["bash", str(script), "serve", str(port)], "build_and_serve")
+
+
+def start(workspace: Path) -> dict[str, Any]:
+    """Start CE viewer for ``workspace``. Retargets if healthy but mistargeted."""
+    workspace = Path(workspace).expanduser().resolve()
+    with _start_lock:
+        return _start_unlocked(workspace)
+
+
+def _start_unlocked(workspace: Path) -> dict[str, Any]:
+    retargeted = False
+    if is_healthy():
+        bound = bound_workspace()
+        if bound is not None and bound == workspace:
+            _set_ce_state("healthy", "already running")
+            return {
+                "ok": True,
+                "already_running": True,
+                "retargeted": False,
+                "healthy": True,
+                "url": upstream_base(),
+                "port": upstream_port(),
+                "pid": _read_pid(),
+                "workspace": str(workspace),
+            }
+        # Healthy but bound elsewhere (or unknown) — stop then re-serve.
+        log.info(
+            "CE viewer retarget %s → %s",
+            bound if bound is not None else "(unknown)",
+            workspace,
+        )
+        stop()
+        retargeted = True
+        # Brief pause so the port is free before re-bind.
+        time.sleep(0.3)
+
+    if not cebridge.has_wiki(workspace):
+        return {
+            "ok": False,
+            "error": f"no wiki/ under workspace {workspace}",
+            "hint": "Open a CE wiki workspace or run curiosity-engine setup.",
+        }
+
+    script = cebridge.ce_root() / "scripts" / "viewer.sh"
+    if not script.is_file():
+        return {
+            "ok": False,
+            "error": f"viewer.sh not found under {cebridge.ce_root()}",
+            "hint": "Install CE skill or set SWITCHBAY_CE_ROOT.",
+        }
+    server_py = cebridge.ce_root() / "scripts" / "viewer_server.py"
+    if not server_py.is_file():
+        return {
+            "ok": False,
+            "error": f"viewer_server.py not found under {cebridge.ce_root()}",
+            "hint": "Install CE skill or set SWITCHBAY_CE_ROOT.",
+        }
+
+    port = upstream_port()
+    # Drop stale pid if process is gone.
+    old = _read_pid()
+    if old and not _pid_alive(old):
+        try:
+            pid_path().unlink(missing_ok=True)
+        except OSError:
+            pass
+
+    argv, mode = _spawn_argv(workspace, port)
+    _set_ce_state("starting", f"spawning CE viewer ({mode})")
+    env = os.environ.copy()
+    env["CE_PUBLIC_BASE"] = _public_base()
+    # Prefer the same CE root Switchbay already resolved.
+    env.setdefault("SWITCHBAY_CE_ROOT", str(cebridge.ce_root()))
+
+    logf = log_path().open("a", encoding="utf-8")
+    try:
+        proc = subprocess.Popen(  # noqa: S603
+            argv,
+            cwd=str(workspace),
+            env=env,
+            stdout=logf,
+            stderr=subprocess.STDOUT,
+            start_new_session=True,
+        )
+    except OSError as e:
+        logf.close()
+        return {"ok": False, "error": f"failed to spawn viewer: {e}"}
+
+    try:
+        pid_path().write_text(str(proc.pid) + "\n", encoding="utf-8")
+    except OSError as e:
+        log.warning("could not write ce-viewer pid: %s", e)
+
+    # Wait briefly for bind.
+    deadline = time.time() + 12.0
+    while time.time() < deadline:
+        if is_healthy():
+            _set_bound_workspace(workspace)
+            _set_ce_state("healthy", f"up ({mode})")
+            return {
+                "ok": True,
+                "already_running": False,
+                "retargeted": retargeted,
+                "healthy": True,
+                "url": upstream_base(),
+                "port": port,
+                "pid": proc.pid,
+                "workspace": str(workspace),
+                "mode": mode,
+                "log": str(log_path()),
+            }
+        if proc.poll() is not None:
+            return {
+                "ok": False,
+                "error": f"viewer exited early code={proc.returncode}",
+                "log": str(log_path()),
+                "mode": mode,
+            }
+        time.sleep(0.4)
+
+    return {
+        "ok": False,
+        "error": "viewer started but health check timed out",
+        "pid": proc.pid,
+        "log": str(log_path()),
+        "url": upstream_base(),
+        "mode": mode,
+    }
+
+
+def stop() -> dict[str, Any]:
+    pid = _read_pid()
+    if not pid:
+        _set_bound_workspace(None)
+        return {"ok": True, "stopped": False, "note": "no pid file"}
+    # Spawn used start_new_session=True → pid is session/pgid leader.
+    try:
+        os.killpg(pid, signal.SIGTERM)
+    except OSError:
+        try:
+            os.kill(pid, signal.SIGTERM)
+        except OSError as e:
+            pid_path().unlink(missing_ok=True)
+            _set_bound_workspace(None)
+            return {"ok": True, "stopped": False, "note": f"pid gone: {e}"}
+    deadline = time.time() + 5.0
+    while time.time() < deadline and _pid_alive(pid):
+        time.sleep(0.2)
+    if _pid_alive(pid):
+        try:
+            os.killpg(pid, signal.SIGKILL)
+        except OSError:
+            try:
+                os.kill(pid, signal.SIGKILL)
+            except OSError:
+                pass
+    pid_path().unlink(missing_ok=True)
+    _set_bound_workspace(None)
+    _set_ce_state("stopped", "stopped")
+    return {"ok": True, "stopped": True, "pid": pid}
+
+
+def status(workspace: Path | None = None) -> dict[str, Any]:
+    pid = _read_pid()
+    bound = bound_workspace()
+    return {
+        "ok": True,
+        "healthy": is_healthy(),
+        "url": upstream_base(),
+        "port": upstream_port(),
+        "pid": pid,
+        "pid_alive": _pid_alive(pid) if pid else False,
+        "public_base": _public_base(),
+        "ce_root": str(cebridge.ce_root()),
+        "workspace": str(workspace) if workspace else None,
+        "bound_workspace": str(bound) if bound else None,
+        "proxied_skill_embeds": app_settings.get_proxied_skill_embeds(),
+        "log": str(log_path()),
+    }
+
+
+def rebuild_bundle(workspace: Path) -> dict[str, Any]:
+    """Run viewer.sh build so the served bundle picks up wiki edits."""
+    workspace = Path(workspace).expanduser().resolve()
+    if not cebridge.has_wiki(workspace):
+        _set_wiki_build("failed", detail="no wiki/")
+        return {"ok": False, "error": "no wiki/"}
+    script = cebridge.ce_root() / "scripts" / "viewer.sh"
+    if not script.is_file():
+        _set_wiki_build("failed", detail=f"viewer.sh missing under {cebridge.ce_root()}")
+        return {"ok": False, "error": f"viewer.sh missing under {cebridge.ce_root()}"}
+    env = os.environ.copy()
+    env["CE_PUBLIC_BASE"] = _public_base()
+    _set_wiki_build("building", detail="viewer.sh build")
+    try:
+        proc = subprocess.run(  # noqa: S603
+            ["bash", str(script), "build"],
+            cwd=str(workspace),
+            env=env,
+            capture_output=True,
+            text=True,
+            timeout=600,
+            check=False,
+        )
+    except (OSError, subprocess.TimeoutExpired) as e:
+        _set_wiki_build("failed", detail=str(e))
+        return {"ok": False, "error": str(e)}
+    if proc.returncode != 0:
+        tail = (proc.stderr or proc.stdout or "")[-800:]
+        _set_wiki_build("failed", detail=f"build exit {proc.returncode}")
+        return {"ok": False, "error": f"build exit {proc.returncode}", "detail": tail}
+    _set_wiki_build("idle", detail="rebuilt")
+    return {"ok": True, "rebuilt": True}
+
+
+def _wiki_mtime(workspace: Path) -> float:
+    wiki = Path(workspace) / "wiki"
+    if not wiki.is_dir():
+        return 0.0
+    newest = 0.0
+    try:
+        for p in wiki.rglob("*"):
+            if p.is_file():
+                try:
+                    newest = max(newest, p.stat().st_mtime)
+                except OSError:
+                    continue
+    except OSError:
+        return newest
+    return newest
+
+
+
+async def _broadcast_files_changed(app: Any) -> None:
+    """Notify connected clients (proxied panel listens via App → CustomEvent)."""
+    from . import protocol
+
+    # Prefer the daemon's own _broadcast if the app stored a bound helper.
+    bc = app.get("_broadcast_fn")
+    if callable(bc):
+        await bc(app, protocol.files_changed())
+        return
+    # Fallback: import daemon._broadcast (circular-import safe at call time).
+    from . import daemon as _daemon
+
+    await _daemon._broadcast(app, protocol.files_changed())
+
+
+async def run_supervisor(app: Any) -> None:
+    """Background task: always keep CE up (core experience; Ben lock).
+
+    Proxied-embeds flag still chooses the Graph UI panel; supervisors bring
+    the skill up regardless so status is never an empty Graph. Retargets
+    when ``app["workspace"]`` diverges from the bound CE viewer workspace.
+    """
+    last_wiki_mtime = 0.0
+    last_rebuild = 0.0
+    while True:
+        try:
+            ws = Path(app["workspace"]).expanduser().resolve()
+            if not is_healthy():
+                log.info("CE viewer unhealthy — starting for %s", ws)
+                _set_ce_state("starting", "supervisor restart")
+                out = await asyncio.to_thread(start, ws)
+                if not out.get("ok"):
+                    _set_ce_state("unhealthy", str(out.get("error") or "start failed"))
+                    log.warning("CE viewer start failed: %s", out.get("error"))
+                else:
+                    _set_ce_state("healthy", "supervisor")
+                    last_wiki_mtime = 0.0
+            else:
+                bound = bound_workspace()
+                if bound is None or bound != ws:
+                    log.info(
+                        "CE viewer mistargeted (%s) — retargeting to %s",
+                        bound if bound is not None else "(unknown)",
+                        ws,
+                    )
+                    out = await asyncio.to_thread(start, ws)
+                    if not out.get("ok"):
+                        _set_ce_state(
+                            "unhealthy",
+                            str(out.get("error") or "retarget failed"),
+                        )
+                        log.warning(
+                            "CE viewer retarget failed: %s", out.get("error")
+                        )
+                    else:
+                        _set_ce_state("healthy", "supervisor retarget")
+                        last_wiki_mtime = 0.0
+                else:
+                    _set_ce_state("healthy", "supervisor")
+                    # Rebuild static bundle when wiki changes (Phase 4a panel
+                    # still needs a browser reload; keep-alive is the hard part).
+                    mtime = await asyncio.to_thread(_wiki_mtime, ws)
+                    now = time.time()
+                    if (
+                        mtime > last_wiki_mtime
+                        and last_wiki_mtime > 0.0
+                        and (now - last_rebuild) > _WIKI_POLL_SEC
+                    ):
+                        last_rebuild = now
+                        last_wiki_mtime = mtime
+                        reb = await asyncio.to_thread(rebuild_bundle, ws)
+                        log.info("CE viewer rebuild after wiki change: %s", reb)
+                        if reb.get("ok"):
+                            # Tell proxied Graph panels to soft-refetch /embed/ce.
+                            try:
+                                await _broadcast_files_changed(app)
+                            except Exception:  # noqa: BLE001
+                                log.exception(
+                                    "files_changed after CE rebuild failed"
+                                )
+                    elif last_wiki_mtime == 0.0:
+                        last_wiki_mtime = mtime
+        except asyncio.CancelledError:
+            raise
+        except Exception:  # noqa: BLE001
+            log.exception("CE viewer supervisor loop error")
+            _set_ce_state("unhealthy", "supervisor loop error")
+        await asyncio.sleep(_POLL_SEC)
diff --git a/src/switchbay/cebridge.py b/src/switchbay/cebridge.py
index 42695ba..bda908a 100644
--- a/src/switchbay/cebridge.py
+++ b/src/switchbay/cebridge.py
@@ -432,12 +432,21 @@ def _trusted_enterprise_setup_script(
     return True, "trusted bundled CE setup", candidate
 
 
-def read_cached(workspace: Path) -> dict[str, Any] | None:
+def read_cached(
+    workspace: Path, *, enrich: bool = False,
+) -> dict[str, Any] | None:
     """Return the on-disk data.json from a previous viewer.sh build,
-    if one exists. Cheap (single file read + json parse) — usable on
-    the hot path so a workspace switch shows the graph instantly,
-    even if it's a few minutes stale. Pair with `build()` running in
-    the background to refresh.
+    if one exists.
+
+    Hot path (``enrich=False``, default): single file read + json
+    parse + cheap in-memory backfills. Usable on workspace switch so
+    the graph paints in milliseconds even when the vault is huge.
+    Pair with ``enrich_from_disk`` / a background rebuild to refresh
+    filesystem truth (types, decks, on-disk pages) off the request.
+
+    ``enrich=True`` also runs the full disk-truth pass (resync types,
+    inject decks, inject on-disk pages). Prefer that only on slow
+    paths (curation history, post-build) — never on ``/api/graph/data``.
 
     Returns None when no cached build is on disk yet OR the file
     parses badly OR the workspace has no wiki/."""
@@ -451,23 +460,36 @@ def read_cached(workspace: Path) -> dict[str, Any] | None:
     except (OSError, json.JSONDecodeError):
         return None
     _backfill_unclassified_types(data)
-    # Filesystem-truth pass — CE's wiki_render occasionally ships
-    # node entries typed `unclassified` even when the page's
-    # frontmatter declares a real type. The sidebar reads node.type
-    # for grouping, so without this fix tables / sources / etc. end
-    # up under UNCLASSIFIED despite the .md declaring type:table.
-    resync_types_from_disk(workspace, data)
-    # Sketch decks (`kind: deck`, title `[deck] …`) live under
-    # wiki/analyses/ but CE's graph intentionally omits them from
-    # `nodes` (curator exclusion). Inject them so the BROWSER
-    # ANALYSES group lists them alongside real analyses.
-    inject_deck_nodes(workspace, data)
-    from . import wiki_sync
-    wiki_sync.inject_on_disk_pages(workspace, data)
     _override_palette(data)
+    if enrich:
+        enrich_from_disk(workspace, data)
     return data
 
 
+def enrich_from_disk(workspace: Path, data: dict[str, Any]) -> dict[str, int]:
+    """Filesystem-truth pass over an in-memory viewer bundle.
+
+    Runs the three expensive walks that used to live inside
+    ``read_cached``:
+      1. ``resync_types_from_disk`` — align node/page types with
+         frontmatter (full wiki rglob + per-file reads).
+      2. ``inject_deck_nodes`` — ensure ``kind: deck`` pages appear
+         in nodes/pages.
+      3. ``wiki_sync.inject_on_disk_pages`` — fold in new/deleted
+         wiki docs + wikilink edges (full-file reads).
+
+    Mutates ``data``. Returns per-stage change counts so callers can
+    surface progress. Safe to call repeatedly; designed for the
+    background sync kicked by ``/api/graph/data``.
+    """
+    from . import wiki_sync
+    types_n = int(resync_types_from_disk(workspace, data) or 0)
+    decks_n = int(inject_deck_nodes(workspace, data) or 0)
+    pages_n = int(wiki_sync.inject_on_disk_pages(workspace, data) or 0)
+    _override_palette(data)
+    return {"types": types_n, "decks": decks_n, "pages": pages_n}
+
+
 def has_workspace_venv(workspace: Path) -> bool:
     """True when the workspace has a CE `.venv` with a Python binary.
 
@@ -894,10 +916,12 @@ async def build(
     # follows system 3.14.
     env = _scrubbed_env()
 
+    # Prefer workspace .venv python (has kuzu) over sys.executable
+    # (Switchbay's own venv usually does not). Falls back to CE venv /
+    # uv run via _script_python.
     if render_py.is_file():
-        import sys
         cmd = [
-            sys.executable, str(render_py), "build",
+            *_script_python(Path(workspace)), str(render_py), "build",
             str(workspace / "wiki"),
             "--output-dir", str(output_dir(workspace)),
         ]
@@ -930,16 +954,9 @@ async def build(
         log.warning("could not parse %s: %s", data_path, e)
         return None
     _backfill_unclassified_types(data)
-    # Filesystem-truth pass — CE's wiki_render occasionally ships
-    # node entries typed `unclassified` even when the page's
-    # frontmatter declares a real type. The sidebar reads node.type
-    # for grouping, so without this fix tables / sources / etc. end
-    # up under UNCLASSIFIED despite the .md declaring type:table.
-    resync_types_from_disk(workspace, data)
-    inject_deck_nodes(workspace, data)
-    from . import wiki_sync
-    wiki_sync.inject_on_disk_pages(workspace, data)
-    _override_palette(data)
+    # Post-build disk-truth pass — same stages as enrich_from_disk.
+    # Build is already the slow path, so running them here is fine.
+    enrich_from_disk(workspace, data)
     return data
 
 
@@ -984,6 +1001,10 @@ async def build(
     "notes":           "#6f4070",
     "todo":            "#9656a2",  # lighter purple
     "todo-list":       "#9656a2",
+    "procedure":       "#5e4fa2",  # indigo — CE how-to hubs
+    "procedures":      "#5e4fa2",
+    "execution":       "#c51b8a",  # pink-magenta — dated instances
+    "executions":      "#c51b8a",
     "unclassified":    "#ffffff",  # white + black stroke via graph.js
 }
 
@@ -1012,6 +1033,8 @@ def _override_palette(data: dict) -> None:
     "note": "note",
     "todo": "todo",
     "proj": "project",
+    "proc": "procedure",
+    "exec": "execution",
     # Decks scaffolded by switchbay's → Slides path. CE doesn't
     # ship a `deck` type; render them as `analysis` so the existing
     # palette / sidebar bucket picks them up. The `[deck]` title
@@ -1129,6 +1152,7 @@ def resync_types_from_disk(workspace: Path, data: dict) -> int:
             "tables": "table", "sources": "source",
             "notes": "note", "todo": "todo-list",
             "todos": "todo-list",
+            "procedures": "procedure", "executions": "execution",
             "extracted-table": "table",
             "extracted_table": "table",
         }.get(type_line, type_line)
diff --git a/src/switchbay/core_skills.py b/src/switchbay/core_skills.py
new file mode 100644
index 0000000..68f17ec
--- /dev/null
+++ b/src/switchbay/core_skills.py
@@ -0,0 +1,23 @@
+"""Combined core-skills status (CE + okstratr + wiki_build).
+
+Contract C1 shared status shape for UI / Herdr / CLI.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from . import ce_viewer_supervisor, okstratr_supervisor
+
+
+def status(workspace: Path | None = None) -> dict[str, Any]:
+    """Return the C1 status object."""
+    ce = ce_viewer_supervisor.contract_slice(workspace)
+    oks = okstratr_supervisor.contract_slice()
+    wiki = ce_viewer_supervisor.wiki_build_slice()
+    return {
+        "ce": ce,
+        "okstratr": oks,
+        "wiki_build": wiki,
+    }
diff --git a/src/switchbay/curation_history.py b/src/switchbay/curation_history.py
index 2e90f21..b004508 100644
--- a/src/switchbay/curation_history.py
+++ b/src/switchbay/curation_history.py
@@ -426,7 +426,7 @@ def _assemble_history(
     # workspace hasn't been built yet, fall back to body-wikilink
     # resolution so we still produce *some* animation.
     from . import cebridge
-    ce_data = cebridge.read_cached(workspace)
+    ce_data = cebridge.read_cached(workspace, enrich=True)
 
     nodes: dict[str, dict[str, Any]] = {}
     by_first_seen: list[tuple[int, str]] = []
diff --git a/src/switchbay/daemon.py b/src/switchbay/daemon.py
index 1436a26..a277b1b 100644
--- a/src/switchbay/daemon.py
+++ b/src/switchbay/daemon.py
@@ -37,9 +37,9 @@
     ce_tools, command_palettes,
     commands, conversations, curation_history, dbintrospect,
     demo_workspace,
-    duckdb_starters, file_state, fileops, llm_config, llmgateway,
+    duckdb_starters, embed_proxy, ce_viewer_supervisor, okstratr_supervisor, core_skills, host_notify, okstratr_harness, file_state, fileops, llm_config, llmgateway,
     localllm, orchestrator_fs, schedules,
-    mcpstore, merging, model_cache, modestore, owid, packstore, pasteboard, permissions, plots,
+    mcpstore, merging, model_cache, modestore, owid, pack_run_drain, ingest_run_drain, packstore, pasteboard, permissions, plots,
     html_decks, library, local_models, media_settings, micro_edits, projects, proposals, protocol, rail, report_html, report_packages, reports, secrets, selection, service, share, sheets,
     routing_status,
     sheet_focus, sketches, skillkit, slide_layouts, slideshow_from_md, sources, splitting, statedir,
@@ -274,6 +274,23 @@ async def handle_file(request: web.Request) -> web.Response:
         return web.json_response({"error": "missing path"}, status=400)
     target = _safe_resolve(workspace, rel)
     if target is None or not target.is_file():
+        # Vault extracts: fall back to FTS body in vault/vault.db when the
+        # on-disk *.extracted.md is absent (wiki-only tip checkouts).
+        body = await asyncio.to_thread(fileops.vault_db_read_body, workspace, rel)
+        if body is not None:
+            if len(body.encode("utf-8")) > MAX_FILE_BYTES:
+                return web.json_response({"error": "file too large"}, status=413)
+            return web.json_response({
+                "path": rel, "text": body, "source": "vault.db",
+            })
+        if fileops.vault_extracted_basename(rel):
+            return web.json_response({
+                "error": (
+                    f"vault source missing on disk and not in vault.db: {rel}. "
+                    "Restore vault/*.extracted.md (or a populated vault.db) "
+                    "from the hybrid vault / tip archive."
+                ),
+            }, status=404)
         return web.json_response({"error": "not found"}, status=404)
     # Cloud-sync placeholder: the bytes aren't local yet, so reading
     # them would block for tens of seconds while the sync service
@@ -477,18 +494,16 @@ async def handle_graph_data(request: web.Request) -> web.Response:
       1. In-memory cache from a previous build / read in this
          daemon process (`app["graph_data_per_ws"]`).
       2. On-disk data.json from a *previous* viewer.sh build —
-         possibly stale, but loads in milliseconds.
+         possibly stale, but loads in milliseconds (json only —
+         no wiki FS walks on the request path).
       3. Synchronous viewer.sh build — only when neither cache hit.
 
-    Whenever we serve a stale (1 or 2) result we kick an
-    `asyncio.create_task` rebuild that refreshes the in-memory cache
-    and broadcasts `files_changed` so the frontend re-fetches the
-    fresh data. The user sees the graph immediately on workspace
-    switch and the freshness comes in seconds later.
-
-    Per-workspace caching means switching back to a previously-
-    visited workspace also returns instantly — the daemon process
-    keeps each one's data.json in memory.
+    Disk-truth enrichment (resync types / inject decks / inject
+    on-disk pages) and the heavier kuzu+viewer rebuild both run
+    in background tasks. Progress is broadcast as ``graph_progress``;
+    when enrich finishes the cache is updated and ``files_changed``
+    tells the frontend to re-fetch. Large vaults (tens of thousands
+    of pages) must never wedge the PWA on first paint.
     """
     # Optional `?workspace=<abs-path>` arg lets the client warm
     # another workspace's cache without changing app["workspace"].
@@ -505,36 +520,51 @@ async def handle_graph_data(request: web.Request) -> web.Response:
     ws_key = str(workspace.resolve())
     cache: dict[str, dict] = request.app.setdefault("graph_data_per_ws", {})
     cached = cache.get(ws_key)
+    enriched: set[str] = request.app.setdefault("graph_enriched_ws", set())
+    served_from_disk = False
     if cached is None:
-        # Try the on-disk cache before going to the slow build path.
-        # read_cached reads data.json AND resyncs types by rglob-ing
-        # the wiki — that walk blocks the loop on a large vault, so
-        # it goes off-thread. This is the hot workspace-switch path.
-        cached = await asyncio.to_thread(cebridge.read_cached, workspace)
-        if cached is not None:
-            _put_graph_cache(request.app, ws_key, cached)
-            asyncio.create_task(_refresh_graph_cache(request.app, ws_key))
-    if isinstance(cached, dict):
-        # In-memory / on-disk cache can miss pages written since the
-        # last viewer build, and still list wiki docs that were
-        # deleted in the file browser. Fold the FS in cheaply so the
-        # wiki list updates without waiting for curate/rescan.
-        added = await asyncio.to_thread(
-            wiki_sync.inject_on_disk_pages, workspace, cached,
+        # Hot path: json.load only. enrich=False — FS walks are minutes
+        # on a 29k-page vault and must not block the response.
+        await _broadcast(request.app, protocol.graph_progress(
+            "cache", "Loading graph from cache…", workspace=ws_key,
+        ))
+        cached = await asyncio.to_thread(
+            cebridge.read_cached, workspace, enrich=False,
         )
-        if added:
+        if cached is not None:
             _put_graph_cache(request.app, ws_key, cached)
-            asyncio.create_task(_refresh_graph_cache(request.app, ws_key))
+            enriched.discard(ws_key)  # needs background enrich
+            served_from_disk = True
     if cached is None:
         # First time we've ever seen this workspace, no on-disk
         # build either — synchronous build is unavoidable.
+        await _broadcast(request.app, protocol.graph_progress(
+            "build", "Building graph (viewer.sh)…", workspace=ws_key,
+        ))
         cached = await cebridge.build(workspace)
         if cached is None:
+            await _broadcast(request.app, protocol.graph_progress(
+                "ready", "Graph unavailable", workspace=ws_key, done=True,
+            ))
             return web.json_response(
                 {"error": "no wiki/ in workspace, or viewer.sh build failed"},
                 status=404,
             )
         _put_graph_cache(request.app, ws_key, cached)
+        enriched.add(ws_key)  # build() already ran enrich_from_disk
+        await _broadcast(request.app, protocol.graph_progress(
+            "ready", "Graph ready", workspace=ws_key, done=True,
+        ))
+    else:
+        # Serve immediately. Enrich at most once per cold disk load
+        # (deduped); full rebuild only when we just hydrated from disk.
+        if ws_key not in enriched:
+            asyncio.create_task(_enrich_graph_cache(request.app, ws_key))
+        if served_from_disk:
+            # Stale-while-revalidate: also kick the heavier rebuild so
+            # kuzu edges catch up eventually. Enrich finishes first
+            # and paints a fresher node set; rebuild may take longer.
+            asyncio.create_task(_refresh_graph_cache(request.app, ws_key))
     cached = request.app.get("graph_data_per_ws", {}).get(ws_key) or cached
     return web.json_response(cached)
 
@@ -729,23 +759,123 @@ def _hello_payload(app: web.Application) -> dict:
     )
 
 
+async def _enrich_graph_cache(app: web.Application, ws_key: str) -> None:
+    """Background filesystem-truth enrich of an already-served graph.
+
+    Runs resync_types / inject_deck / inject_on_disk_pages off the
+    request path with ``graph_progress`` stages so the UI never
+    whites out on a large vault. Deduped per workspace via
+    ``app["graph_enrich_inflight"]``.
+    """
+    from pathlib import Path as _Path
+    inflight: set[str] = app.setdefault("graph_enrich_inflight", set())
+    if ws_key in inflight:
+        return
+    inflight.add(ws_key)
+    workspace = _Path(ws_key)
+    try:
+        # Fresh json-only load so we don't deepcopy a multi-10MB
+        # in-memory bundle (BioCure ~51MB) and so the served snapshot
+        # stays untouched until we swap the cache at the end.
+        data = await asyncio.to_thread(
+            cebridge.read_cached, workspace, enrich=False,
+        )
+        if data is None:
+            await _broadcast(app, protocol.graph_progress(
+                "ready", "Graph ready", workspace=ws_key, done=True,
+            ))
+            return
+
+        await _broadcast(app, protocol.graph_progress(
+            "types", "Syncing page types…", workspace=ws_key,
+        ))
+        types_n = await asyncio.to_thread(
+            cebridge.resync_types_from_disk, workspace, data,
+        )
+        await _broadcast(app, protocol.graph_progress(
+            "types",
+            f"Syncing page types… ({int(types_n or 0)} updated)",
+            workspace=ws_key, current=int(types_n or 0),
+        ))
+
+        await _broadcast(app, protocol.graph_progress(
+            "decks", "Refreshing deck nodes…", workspace=ws_key,
+        ))
+        decks_n = await asyncio.to_thread(
+            cebridge.inject_deck_nodes, workspace, data,
+        )
+        await _broadcast(app, protocol.graph_progress(
+            "decks",
+            f"Refreshing deck nodes… ({int(decks_n or 0)} added)",
+            workspace=ws_key, current=int(decks_n or 0),
+        ))
+
+        await _broadcast(app, protocol.graph_progress(
+            "pages", "Refreshing links…", workspace=ws_key,
+        ))
+        pages_n = await asyncio.to_thread(
+            wiki_sync.inject_on_disk_pages, workspace, data,
+        )
+        await _broadcast(app, protocol.graph_progress(
+            "pages",
+            f"Refreshing links… ({int(pages_n or 0)} updates)",
+            workspace=ws_key, current=int(pages_n or 0),
+        ))
+
+        _put_graph_cache(app, ws_key, data)
+        app.setdefault("graph_enriched_ws", set()).add(ws_key)
+        await _broadcast(app, protocol.graph_progress(
+            "ready", "Graph ready", workspace=ws_key, done=True,
+        ))
+        # Only bump files_changed when something actually moved —
+        # otherwise every prefetch would remount the graph.
+        if int(types_n or 0) or int(decks_n or 0) or int(pages_n or 0):
+            await _broadcast(app, protocol.files_changed())
+    except Exception:  # noqa: BLE001
+        log.exception("background graph enrich failed for %s", ws_key)
+        try:
+            await _broadcast(app, protocol.graph_progress(
+                "ready", "Graph sync failed (showing cache)",
+                workspace=ws_key, done=True,
+            ))
+        except Exception:  # noqa: BLE001
+            pass
+    finally:
+        inflight.discard(ws_key)
+
+
 async def _refresh_graph_cache(app: web.Application, ws_key: str) -> None:
     """Background rebuild of the per-workspace graph cache. Fires
     after a stale-while-revalidate hit on /api/graph/data so the
     next fetch returns the fresh data.json. Broadcasts a
-    `files_changed` so any connected client re-fetches."""
+    `files_changed` so any connected client re-fetches.
+
+    Deduped per workspace. This is the heavy path (venv + kuzu +
+    viewer.sh); prefer ``_enrich_graph_cache`` for fast FS truth.
+    """
     from pathlib import Path as _Path
+    inflight: set[str] = app.setdefault("graph_rebuild_inflight", set())
+    if ws_key in inflight:
+        return
+    inflight.add(ws_key)
     workspace = _Path(ws_key)
     try:
-        await cebridge.ensure_venv(workspace)
-        await cebridge.graph_rebuild(workspace)
-    except Exception:  # noqa: BLE001
-        log.exception("background kuzu rebuild failed for %s", ws_key)
-    fresh = await cebridge.build(workspace)
-    if fresh is None:
-        return
-    _put_graph_cache(app, ws_key, fresh)
-    await _broadcast(app, protocol.files_changed())
+        try:
+            await cebridge.ensure_venv(workspace)
+            await cebridge.graph_rebuild(workspace)
+        except Exception:  # noqa: BLE001
+            log.exception("background kuzu rebuild failed for %s", ws_key)
+        fresh = await cebridge.build(workspace)
+        if fresh is None:
+            return
+        _put_graph_cache(app, ws_key, fresh)
+        app.setdefault("graph_enriched_ws", set()).add(ws_key)
+        await _broadcast(app, protocol.files_changed())
+        await _broadcast(app, protocol.graph_progress(
+            "ready", "Graph ready", workspace=ws_key, done=True,
+        ))
+    finally:
+        inflight.discard(ws_key)
 
 
 async def _activate(app: web.Application, new_path: Path) -> None:
@@ -814,6 +944,14 @@ async def _activate(app: web.Application, new_path: Path) -> None:
     # natively. Idempotent no-op once done; off-loop and best-effort.
     asyncio.create_task(_migrate_figures(app, new_path))
     asyncio.create_task(_migrate_legacy_decks(app, new_path))
+    # Keep proxied Graph CE (:8766) on the active tip — best-effort, off-thread.
+    async def _kick_ce_viewer() -> None:
+        try:
+            out = await asyncio.to_thread(ce_viewer_supervisor.start, new_path)
+            log.info("CE viewer retarget on workspace switch: %s", out)
+        except Exception:  # noqa: BLE001
+            log.exception("CE viewer retarget on workspace switch failed")
+    asyncio.create_task(_kick_ce_viewer())
     await _broadcast(app, _hello_payload(app))
 
 
@@ -905,6 +1043,7 @@ async def handle_settings_get(request: web.Request) -> web.Response:
         "orchestration_preference": orchestration_policy.get_preference(),
         "orchestration_denied_models": orchestration_policy.get_denied_models(workspace),
         **_desk_live_view(workspace),
+        "proxied_skill_embeds": app_settings.get_proxied_skill_embeds(),
     })
 
 
@@ -957,6 +1096,22 @@ async def handle_settings_post(request: web.Request) -> web.Response:
         # Re-select the backend on next use; the drain's reconcile then
         # rebuilds the index if the vector space changed.
         conversations.reset_embedder()
+    if "proxied_skill_embeds" in body:
+        want = bool(body["proxied_skill_embeds"])
+        had = app_settings.get_proxied_skill_embeds()
+        app_settings.set_proxied_skill_embeds(want)
+        # Proxied flag only switches Graph/Agents UI panels. Core skills
+        # (CE + okstratr) stay supervised either way (Ben lock / C1).
+        if want and not had:
+            async def _kick() -> None:
+                ce_out = await asyncio.to_thread(
+                    ce_viewer_supervisor.start, workspace,
+                )
+                oks_out = await asyncio.to_thread(
+                    okstratr_supervisor.start, workspace,
+                )
+                log.info("core skills kick via settings: ce=%s oks=%s", ce_out, oks_out)
+            asyncio.create_task(_kick())
     # Media: { media: { image?: {provider, model}|null, video?: …, voice?: … } }
     if "media" in body and isinstance(body["media"], dict):
         if not admin_policy.feature_enabled("media_generation"):
@@ -992,6 +1147,85 @@ async def handle_settings_post(request: web.Request) -> web.Response:
     return await handle_settings_get(request)
 
 
+
+async def handle_core_skills_status(request: web.Request) -> web.Response:
+    """C1 shared status: CE + okstratr + wiki_build."""
+    workspace: Path = request.app["workspace"]
+    return web.json_response(core_skills.status(workspace))
+
+
+async def handle_okstratr_host_notify(request: web.Request) -> web.Response:
+    """C2 path-native notify: okstratr → Switchbay rail (protocol.notice)."""
+    try:
+        body = await request.json()
+    except json.JSONDecodeError:
+        return web.json_response({"ok": False, "error": "invalid json"}, status=400)
+    result = await host_notify.apply_host_notify(request.app, body)
+    status = 200 if result.get("ok") else 400
+    return web.json_response(result, status=status)
+
+
+async def handle_okstratr_harness_get(request: web.Request) -> web.Response:
+    """Thin client: GET okstratr harness registry (SSOT). No Switchbay allowlist."""
+    try:
+        data = await okstratr_harness.list_harnesses(request.app)
+    except okstratr_harness.OkstratrHarnessError as e:
+        return okstratr_harness.error_response(e)
+    return web.json_response(data)
+
+
+async def handle_okstratr_harness_enable(request: web.Request) -> web.Response:
+    try:
+        body = await request.json()
+    except json.JSONDecodeError:
+        return web.json_response({"ok": False, "error": "invalid json"}, status=400)
+    hid = str((body or {}).get("id") or (body or {}).get("harness") or "").strip()
+    try:
+        data = await okstratr_harness.enable_harness(hid, app=request.app)
+    except okstratr_harness.OkstratrHarnessError as e:
+        return okstratr_harness.error_response(e)
+    return web.json_response(data)
+
+
+async def handle_okstratr_harness_disable(request: web.Request) -> web.Response:
+    try:
+        body = await request.json()
+    except json.JSONDecodeError:
+        return web.json_response({"ok": False, "error": "invalid json"}, status=400)
+    hid = str((body or {}).get("id") or (body or {}).get("harness") or "").strip()
+    try:
+        data = await okstratr_harness.disable_harness(hid, app=request.app)
+    except okstratr_harness.OkstratrHarnessError as e:
+        return okstratr_harness.error_response(e)
+    return web.json_response(data)
+
+
+async def handle_okstratr_harness_set(request: web.Request) -> web.Response:
+    try:
+        body = await request.json()
+    except json.JSONDecodeError:
+        return web.json_response({"ok": False, "error": "invalid json"}, status=400)
+    key = str((body or {}).get("key") or "").strip()
+    value = (body or {}).get("value")
+    if value is None:
+        value = ""
+    try:
+        data = await okstratr_harness.set_harness_value(
+            key, str(value), app=request.app
+        )
+    except okstratr_harness.OkstratrHarnessError as e:
+        return okstratr_harness.error_response(e)
+    return web.json_response(data)
+
+
+async def handle_okstratr_harness_reload(request: web.Request) -> web.Response:
+    try:
+        data = await okstratr_harness.reload_harnesses(request.app)
+    except okstratr_harness.OkstratrHarnessError as e:
+        return okstratr_harness.error_response(e)
+    return web.json_response(data)
+
+
 async def handle_orchestration_policy_get(request: web.Request) -> web.Response:
     """Inspectable Auto-orchestration policy + hard bounds. No secrets.
 
@@ -4131,6 +4365,29 @@ async def _tag_run() -> None:
     return web.json_response({"run_id": run_id, "pack": pack, "action": action})
 
 
+async def handle_packs_drain(request: web.Request) -> web.Response:
+    """Drain CE-queued ``.workbench/pack-runs/*.json`` into rail LLM seats.
+
+    CE's proxied filebrowser only writes ``status: queued`` files; this
+    endpoint (and the background poll loop) seats ``_dispatch_chat`` the
+    same way ``handle_pack_action`` does. Returns
+    ``{drained, skipped, errors, …}``.
+    """
+    summary = await pack_run_drain.drain_once(request.app)
+    return web.json_response(summary)
+
+
+async def handle_ingest_drain(request: web.Request) -> web.Response:
+    """Drain CE-queued ``.workbench/ingest-runs/*.json``.
+
+    Prefer deterministic ``local_ingest``; escalate to rail LLM only when
+    run metadata opts in (see ADR-007). Returns
+    ``{drained, skipped, errors, …}``.
+    """
+    summary = await ingest_run_drain.drain_once(request.app)
+    return web.json_response(summary)
+
+
 async def handle_packs_uninstall(request: web.Request) -> web.Response:
     workspace: Path = request.app["workspace"]
     name = request.query.get("name", "").strip()
@@ -6495,11 +6752,31 @@ async def handle_fs_raw(request: web.Request) -> web.StreamResponse:
 
     Same path-resolution rules as /api/file (no escape, no NUL); no
     extension restriction (DuckDB needs CSV/parquet/etc.).
+
+    Vault extracts: when `vault/*.extracted.md` is missing on disk but
+    present in vault/vault.db FTS, return the indexed body as text/markdown
+    so Editor / CE "Open full vault source" still works on wiki-only tips.
     """
     workspace: Path = request.app["workspace"]
     rel = request.query.get("path", "")
     target = _safe_resolve(workspace, rel)
     if target is None or not target.is_file():
+        body = await asyncio.to_thread(fileops.vault_db_read_body, workspace, rel)
+        if body is not None:
+            return web.Response(
+                text=body,
+                content_type="text/markdown",
+                charset="utf-8",
+                headers={"X-Switchbay-Vault-Source": "vault.db"},
+            )
+        if fileops.vault_extracted_basename(rel):
+            return web.json_response({
+                "error": (
+                    f"vault source missing on disk and not in vault.db: {rel}. "
+                    "Restore vault/*.extracted.md (or a populated vault.db) "
+                    "from the hybrid vault / tip archive."
+                ),
+            }, status=404)
         return web.json_response({"error": "not found"}, status=404)
     return web.FileResponse(target)
 
@@ -16146,6 +16423,17 @@ def _broadcast_files_changed_soon(app: web.Application) -> None:
     except RuntimeError:
         return  # not inside an event loop (test context, etc.)
     loop.create_task(_broadcast(app, protocol.files_changed()))
+    # Opportunistic pack-run drain when workspace files change (CE may
+    # have just written ``.workbench/pack-runs/*.json``). No-op if the
+    # dir is absent; dedupes via ``pack_run_inflight``.
+    try:
+        ws = app.get("workspace")
+        if ws and pack_run_drain.runs_dir(Path(ws)).is_dir():
+            pack_run_drain.kick_drain(app)
+        if ws and ingest_run_drain.runs_dir(Path(ws)).is_dir():
+            ingest_run_drain.kick_drain(app)
+    except Exception:  # noqa: BLE001
+        pass
 
 
 def _check_external_edit(app: web.Application, rel: str) -> None:
@@ -17091,7 +17379,11 @@ async def handle_spa(request: web.Request) -> web.StreamResponse:
     # Never serve the SPA for API/WS paths — an unregistered /api GET
     # must 404 (so clients that probe GET-then-POST fall back correctly),
     # not silently receive index.html.
-    if rel == "api" or rel.startswith("api/") or rel == "ws" or rel.startswith("ws/"):
+    if (
+        rel == "api" or rel.startswith("api/")
+        or rel == "ws" or rel.startswith("ws/")
+        or rel == "embed" or rel.startswith("embed/")
+    ):
         return web.Response(status=404)
     if rel:
         candidate = (dist / rel).resolve()
@@ -17326,10 +17618,12 @@ def build_app(workspace: Path) -> web.Application:
     app.router.add_post(
         "/api/packs/{pack}/action/{action}", handle_pack_action,
     )
+    app.router.add_post("/api/packs/drain", handle_packs_drain)
     app.router.add_get("/figures/{path:.*}", handle_figure_file)
     app.router.add_post("/api/chat/upload", handle_chat_upload)
     app.router.add_post("/api/ingest/from-upload", handle_ingest_from_upload)
     app.router.add_post("/api/ingest/from-path", handle_ingest_from_path)
+    app.router.add_post("/api/ingest/drain", handle_ingest_drain)
     app.router.add_get("/api/action-buttons", handle_action_buttons_list)
     app.router.add_post("/api/action-buttons", handle_action_buttons_add)
     app.router.add_delete("/api/action-buttons", handle_action_buttons_delete)
@@ -17370,6 +17664,13 @@ def build_app(workspace: Path) -> web.Application:
     app.router.add_post("/api/llm/refresh_models", handle_llm_refresh_models)
     app.router.add_get("/api/rail/events", handle_rail_events)
     app.router.add_get("/api/settings", handle_settings_get)
+    app.router.add_get("/api/core-skills/status", handle_core_skills_status)
+    app.router.add_post("/api/okstratr/host-notify", handle_okstratr_host_notify)
+    app.router.add_get("/api/okstratr/harness", handle_okstratr_harness_get)
+    app.router.add_post("/api/okstratr/harness/enable", handle_okstratr_harness_enable)
+    app.router.add_post("/api/okstratr/harness/disable", handle_okstratr_harness_disable)
+    app.router.add_post("/api/okstratr/harness/set", handle_okstratr_harness_set)
+    app.router.add_post("/api/okstratr/harness/reload", handle_okstratr_harness_reload)
     app.router.add_get("/api/curator-profile", handle_curator_profile_get)
     app.router.add_post("/api/curator-profile", handle_curator_profile_post)
     app.router.add_post("/api/curator-profile/draft", handle_curator_profile_draft)
@@ -17448,6 +17749,9 @@ def build_app(workspace: Path) -> web.Application:
     app.router.add_post("/api/tabs/vault-doc", handle_tab_vault_doc_add)
     app.router.add_post("/api/tabs/vault-doc/remove", handle_tab_vault_doc_remove)
     app.router.add_get("/ws", handle_ws)
+    # Phase 4a: same-origin reverse proxy for CE (:8766) and okstratr
+    # (:8767). Must register BEFORE the SPA catch-all.
+    embed_proxy.register_routes(app)
     # Catch-all LAST: serves the built SPA + PWA assets (manifest, icons)
     # for any non-API GET. aiohttp matches in registration order, so the
     # specific /api and /ws routes above always take precedence.
@@ -17482,6 +17786,54 @@ async def _go() -> None:
         _app["_ce_skill_task"] = asyncio.create_task(_go())
     app.on_startup.append(_ensure_ce_skill)
 
+    async def _start_core_skill_supervisors(_app: web.Application) -> None:
+        # C1: always auto-start CE + okstratr with the shell (Ben lock).
+        # Proxied embeds only choose which UI panels load /embed/* — supervisors
+        # still bring skills up. Never block bind — background tasks only.
+        _app["_broadcast_fn"] = _broadcast
+
+        async def _go_ce() -> None:
+            ws = Path(_app["workspace"])
+            out = await asyncio.to_thread(ce_viewer_supervisor.start, ws)
+            if out.get("ok"):
+                log.info("CE viewer supervisor initial start: %s", out)
+            else:
+                log.warning(
+                    "CE viewer supervisor initial start failed: %s",
+                    out.get("error"),
+                )
+            await ce_viewer_supervisor.run_supervisor(_app)
+
+        async def _go_oks() -> None:
+            ws = Path(_app["workspace"])
+            out = await asyncio.to_thread(okstratr_supervisor.start, ws)
+            if out.get("ok"):
+                log.info("okstratr supervisor initial start: %s", out)
+            else:
+                log.warning(
+                    "okstratr supervisor initial start failed: %s",
+                    out.get("error"),
+                )
+            await okstratr_supervisor.run_supervisor(_app)
+
+        async def _stop(_a: web.Application) -> None:
+            for key in ("_ce_viewer_supervisor_task", "_okstratr_supervisor_task"):
+                t = _a.get(key)
+                if t:
+                    t.cancel()
+                    try:
+                        await t
+                    except (asyncio.CancelledError, Exception):
+                        pass
+            # Leave skill processes up across daemon restarts (supervisors
+            # re-attach via health check). Matches prior CE-when-proxied-on.
+
+        _app["_ce_viewer_supervisor_task"] = asyncio.create_task(_go_ce())
+        _app["_okstratr_supervisor_task"] = asyncio.create_task(_go_oks())
+        _app.on_cleanup.append(_stop)
+
+    app.on_startup.append(_start_core_skill_supervisors)
+
     # The launch workspace is set directly (no _activate), so relocate
     # its rail-history DB to match the current setting on startup too.
     async def _relocate_rail_history(_app: web.Application) -> None:
@@ -17777,6 +18129,50 @@ async def _stop_watch(_app: web.Application) -> None:
     app.on_startup.append(_start_watch)
     app.on_cleanup.append(_stop_watch)
 
+    # CE pack-run drain: poll ``.workbench/pack-runs/`` so proxied CE
+    # filebrowser queues actually seat a Switchbay rail LLM (CE only
+    # writes status=queued JSON). Also exposed as POST /api/packs/drain.
+    async def _start_pack_drain(_app: web.Application) -> None:
+        _app["pack_run_inflight"] = set()
+        _app["pack_run_drain_task"] = asyncio.create_task(
+            pack_run_drain.pack_run_drain_loop(_app),
+        )
+
+    async def _stop_pack_drain(_app: web.Application) -> None:
+        t = _app.get("pack_run_drain_task")
+        if t:
+            t.cancel()
+            try:
+                await t
+            except (asyncio.CancelledError, Exception):
+                pass
+
+    app.on_startup.append(_start_pack_drain)
+    app.on_cleanup.append(_stop_pack_drain)
+
+
+    # CE ingest-run drain: poll ``.workbench/ingest-runs/`` so proxied CE
+    # drop-ingest queues actually run local_ingest (or rail when metadata
+    # opts in). Also exposed as POST /api/ingest/drain.
+    async def _start_ingest_drain(_app: web.Application) -> None:
+        _app["ingest_run_inflight"] = set()
+        _app["ingest_run_drain_task"] = asyncio.create_task(
+            ingest_run_drain.ingest_run_drain_loop(_app),
+        )
+
+    async def _stop_ingest_drain(_app: web.Application) -> None:
+        t = _app.get("ingest_run_drain_task")
+        if t:
+            t.cancel()
+            try:
+                await t
+            except (asyncio.CancelledError, Exception):
+                pass
+
+    app.on_startup.append(_start_ingest_drain)
+    app.on_cleanup.append(_stop_ingest_drain)
+
+
     # Event-loop watchdog. A daemon thread watches a heartbeat that an
     # asyncio task bumps every 250ms; if the loop blocks past 1s the
     # heartbeat goes stale and the thread dumps every thread's stack
diff --git a/src/switchbay/embed_proxy.py b/src/switchbay/embed_proxy.py
new file mode 100644
index 0000000..017db5e
--- /dev/null
+++ b/src/switchbay/embed_proxy.py
@@ -0,0 +1,451 @@
+"""Same-origin reverse proxy for CE + okstratr (Phase 4a).
+
+Charter locked decision #1: Switchbay reverse-proxies loopback skill
+daemons under ``/embed/ce/`` and ``/embed/okstratr/`` so in-app panels
+can load first-party routes (no cross-origin iframes).
+
+Upstream targets are **loopback-only** (127.0.0.1 / ::1). Non-loopback
+upstream configuration is rejected. Proxied requests carry hosted-shell
+headers so CE/okstratr can enter hosted mode:
+
+  X-CE-Host: switchbay
+  X-Okstratr-Host: switchbay
+"""
+
+from __future__ import annotations
+
+import gzip
+import ipaddress
+import logging
+import os
+from typing import Mapping
+from urllib.parse import urlsplit, urlunsplit
+
+from aiohttp import ClientSession, ClientTimeout, web
+
+log = logging.getLogger("switchbay.embed_proxy")
+
+# Public path prefixes (no trailing slash).
+PREFIX_CE = "/embed/ce"
+PREFIX_OKSTRATR = "/embed/okstratr"
+
+HOST_HEADER_CE = "X-CE-Host"
+HOST_HEADER_OKSTRATR = "X-Okstratr-Host"
+HOSTED_SHELL = "switchbay"
+
+# Charter defaults: CE :8766, okstratr :8767.
+_DEFAULT_CE = "http://127.0.0.1:8766"
+_DEFAULT_OKSTRATR = "http://127.0.0.1:8767"
+
+_HOP_BY_HOP = frozenset({
+    "connection",
+    "keep-alive",
+    "proxy-authenticate",
+    "proxy-authorization",
+    "te",
+    "trailers",
+    "transfer-encoding",
+    "upgrade",
+    "host",
+    "content-length",
+})
+
+# Gzip large JSON/static through the proxy even when upstream is plain.
+_MIN_GZIP_BYTES = 1024
+_GZIP_EXT = frozenset({
+    ".json", ".js", ".mjs", ".cjs", ".css", ".html", ".htm",
+    ".svg", ".txt", ".md", ".xml", ".csv", ".map", ".wasm",
+})
+_GZIP_TYPE_PREFIXES = (
+    "application/json",
+    "application/javascript",
+    "application/xml",
+    "application/xhtml",
+    "application/wasm",
+    "image/svg",
+    "text/",
+)
+
+
+def client_accepts_gzip(headers: Mapping[str, str]) -> bool:
+    """True if Accept-Encoding lists gzip (ignore q=0)."""
+    raw = headers.get("Accept-Encoding") or headers.get("accept-encoding") or ""
+    for part in raw.split(","):
+        token = part.strip().lower()
+        if not token:
+            continue
+        coding = token.split(";", 1)[0].strip()
+        if coding != "gzip":
+            continue
+        # Honour explicit q=0
+        q = 1.0
+        if ";" in token:
+            for param in token.split(";")[1:]:
+                p = param.strip()
+                if p.startswith("q="):
+                    try:
+                        q = float(p[2:])
+                    except ValueError:
+                        q = 0.0
+        return q > 0.0
+    return False
+
+
+def _header_ci(headers: Mapping[str, str], name: str) -> str | None:
+    want = name.lower()
+    for k, v in headers.items():
+        if k.lower() == want:
+            return v
+    return None
+
+
+def is_compressible_payload(
+    content_type: str | None,
+    path: str,
+    *,
+    size: int,
+) -> bool:
+    """Whether *path* / Content-Type should be gzipped when large enough."""
+    if size < _MIN_GZIP_BYTES:
+        return False
+    ct = (content_type or "").split(";", 1)[0].strip().lower()
+    if ct and any(ct.startswith(p) or ct == p.rstrip("/") for p in _GZIP_TYPE_PREFIXES):
+        return True
+    # Path fallback (data.json often arrives with application/json already,
+    # but keep extension check for mislabeled upstreams).
+    clean = (path or "").split("?", 1)[0].lower()
+    for ext in _GZIP_EXT:
+        if clean.endswith(ext):
+            return True
+    # Bare "data.json" style names without a leading slash segment
+    base = clean.rsplit("/", 1)[-1]
+    if base == "data.json" or base.endswith(".json"):
+        return True
+    return False
+
+
+def maybe_gzip_body(
+    payload: bytes,
+    resp_headers: dict[str, str],
+    *,
+    accept_gzip: bool,
+    path: str,
+) -> tuple[bytes, dict[str, str]]:
+    """Gzip *payload* when the client accepts it and content is compressible.
+
+    Upstream may be uncompressed (CE SimpleHTTP). Never double-compress.
+    Returns ``(body, headers)`` with Content-Encoding/Vary adjusted.
+    """
+    out = dict(resp_headers)
+    # Drop hop leftovers aiohttp may leave after auto-decompress.
+    for k in list(out):
+        if k.lower() in {"content-encoding", "content-length"}:
+            del out[k]
+
+    if not accept_gzip or not payload:
+        return payload, out
+
+    existing = _header_ci(resp_headers, "Content-Encoding")
+    if existing and existing.strip().lower() not in ("", "identity"):
+        # Pass through already-encoded body as-is (restore encoding header).
+        out["Content-Encoding"] = existing.strip()
+        return payload, out
+
+    ct = _header_ci(resp_headers, "Content-Type")
+    if not is_compressible_payload(ct, path, size=len(payload)):
+        return payload, out
+
+    level = 1 if len(payload) >= 1_000_000 else 6
+    compressed = gzip.compress(payload, compresslevel=level)
+    if len(compressed) >= len(payload):
+        return payload, out
+
+    out["Content-Encoding"] = "gzip"
+    vary = _header_ci(out, "Vary")
+    if vary:
+        parts = [p.strip() for p in vary.split(",") if p.strip()]
+        if not any(p.lower() == "accept-encoding" for p in parts):
+            parts.append("Accept-Encoding")
+        # Replace any Vary key casing with canonical
+        for k in list(out):
+            if k.lower() == "vary":
+                del out[k]
+        out["Vary"] = ", ".join(parts)
+    else:
+        out["Vary"] = "Accept-Encoding"
+    return compressed, out
+
+
+
+class UpstreamNotLoopback(ValueError):
+    """Raised when an embed upstream is not a loopback address."""
+
+
+def _env_upstream(name: str, default: str) -> str:
+    raw = (os.environ.get(name) or "").strip()
+    return raw or default
+
+
+def ce_upstream() -> str:
+    return _normalize_base(_env_upstream("SWITCHBAY_CE_UPSTREAM", _DEFAULT_CE))
+
+
+def okstratr_upstream() -> str:
+    return _normalize_base(
+        _env_upstream("SWITCHBAY_OKSTRATR_UPSTREAM", _DEFAULT_OKSTRATR)
+    )
+
+
+def _normalize_base(url: str) -> str:
+    u = url.rstrip("/")
+    if "://" not in u:
+        u = "http://" + u
+    return u
+
+
+def is_loopback_host(host: str) -> bool:
+    """True iff *host* (no port) is a loopback literal."""
+    h = (host or "").strip().lower()
+    if h in ("localhost", "127.0.0.1", "::1"):
+        return True
+    # Bracketed IPv6 from urlsplit netloc
+    if h.startswith("[") and h.endswith("]"):
+        h = h[1:-1]
+    try:
+        return ipaddress.ip_address(h).is_loopback
+    except ValueError:
+        return False
+
+
+def assert_loopback_upstream(url: str) -> str:
+    """Validate upstream URL is http(s) to a loopback host. Return normalized base."""
+    base = _normalize_base(url)
+    parts = urlsplit(base)
+    if parts.scheme not in ("http", "https"):
+        raise UpstreamNotLoopback(f"embed upstream scheme must be http(s): {url!r}")
+    host = parts.hostname or ""
+    if not is_loopback_host(host):
+        raise UpstreamNotLoopback(
+            f"embed upstream must be loopback-only (got host {host!r} from {url!r})"
+        )
+    # Rebuild without path/query/fragment so join is predictable
+    netloc = parts.netloc
+    return urlunsplit((parts.scheme, netloc, "", "", "")).rstrip("/")
+
+
+def embed_targets() -> dict[str, dict[str, str]]:
+    """Prefix → {upstream, host_header, host_value} (validated loopback)."""
+    return {
+        PREFIX_CE: {
+            "upstream": assert_loopback_upstream(ce_upstream()),
+            "host_header": HOST_HEADER_CE,
+            "host_value": HOSTED_SHELL,
+        },
+        PREFIX_OKSTRATR: {
+            "upstream": assert_loopback_upstream(okstratr_upstream()),
+            "host_header": HOST_HEADER_OKSTRATR,
+            "host_value": HOSTED_SHELL,
+        },
+    }
+
+
+def match_embed_prefix(path: str) -> tuple[str, str] | None:
+    """Return ``(prefix, rest)`` if *path* is under an embed prefix.
+
+    *rest* is the upstream path including a leading ``/`` (or ``/`` when
+    the request targeted the prefix alone).
+    """
+    p = path or "/"
+    for prefix in (PREFIX_CE, PREFIX_OKSTRATR):
+        if p == prefix or p == prefix + "/":
+            return prefix, "/"
+        if p.startswith(prefix + "/"):
+            rest = p[len(prefix) :]
+            return prefix, rest if rest else "/"
+    return None
+
+
+def build_upstream_url(prefix: str, rest: str, query: str = "") -> str:
+    """Compose absolute upstream URL for a matched embed request."""
+    targets = embed_targets()
+    if prefix not in targets:
+        raise KeyError(prefix)
+    base = targets[prefix]["upstream"]
+    path = rest if rest.startswith("/") else "/" + rest
+    q = f"?{query}" if query else ""
+    return f"{base}{path}{q}"
+
+
+def filter_request_headers(
+    headers: Mapping[str, str],
+    *,
+    host_header: str,
+    host_value: str,
+) -> dict[str, str]:
+    """Copy inbound headers minus hop-by-hop; inject hosted-shell header."""
+    out: dict[str, str] = {}
+    for k, v in headers.items():
+        if k.lower() in _HOP_BY_HOP:
+            continue
+        # Drop client-supplied hosted-shell headers; we set them.
+        if k.lower() in (HOST_HEADER_CE.lower(), HOST_HEADER_OKSTRATR.lower()):
+            continue
+        out[k] = v
+    out[host_header] = host_value
+    return out
+
+
+def filter_response_headers(headers: Mapping[str, str]) -> dict[str, str]:
+    out: dict[str, str] = {}
+    for k, v in headers.items():
+        if k.lower() in _HOP_BY_HOP:
+            continue
+        # Drop upstream cache directives — proxied Graph soft-reloads on
+        # wiki changes and must not keep a stale HTML shell.
+        if k.lower() in {"cache-control", "etag", "last-modified", "expires"}:
+            continue
+        # Content-Encoding is re-decided in maybe_gzip_body (aiohttp may
+        # auto-decompress while leaving a stale encoding header).
+        if k.lower() == "content-encoding":
+            continue
+        out[k] = v
+    out["Cache-Control"] = "no-store"
+    return out
+
+
+async def _proxy_http(request: web.Request) -> web.StreamResponse:
+    matched = match_embed_prefix(request.path)
+    if not matched:
+        return web.Response(status=404, text="not an embed path")
+    prefix, rest = matched
+    try:
+        targets = embed_targets()
+    except UpstreamNotLoopback as e:
+        log.error("embed upstream rejected: %s", e)
+        return web.json_response({"error": str(e)}, status=502)
+
+    meta = targets[prefix]
+    upstream_url = build_upstream_url(prefix, rest, request.query_string)
+    # Defense in depth: re-check the concrete URL we are about to hit.
+    try:
+        assert_loopback_upstream(
+            urlunsplit(urlsplit(upstream_url)[:2] + ("", "", ""))
+        )
+    except UpstreamNotLoopback as e:
+        return web.json_response({"error": str(e)}, status=502)
+
+    req_headers = filter_request_headers(
+        request.headers,
+        host_header=meta["host_header"],
+        host_value=meta["host_value"],
+    )
+    body = await request.read()
+    timeout = ClientTimeout(total=120, connect=5, sock_connect=5)
+
+    session: ClientSession | None = request.app.get("embed_http")
+    owns_session = False
+    if session is None or session.closed:
+        session = ClientSession(timeout=timeout)
+        owns_session = True
+
+    try:
+        async with session.request(
+            request.method,
+            upstream_url,
+            headers=req_headers,
+            data=body if body else None,
+            allow_redirects=False,
+        ) as upstream:
+            resp_headers = filter_response_headers(upstream.headers)
+            payload = await upstream.read()
+            # Compress large JSON/static for browsers even when CE serves plain.
+            if request.method.upper() != "HEAD":
+                payload, resp_headers = maybe_gzip_body(
+                    payload,
+                    resp_headers,
+                    accept_gzip=client_accepts_gzip(request.headers),
+                    path=rest,
+                )
+            return web.Response(
+                status=upstream.status,
+                body=payload,
+                headers=resp_headers,
+            )
+    except OSError as e:
+        log.warning("embed upstream unreachable %s: %s", upstream_url, e)
+        return web.json_response(
+            {
+                "error": "embed upstream unreachable",
+                "upstream": meta["upstream"],
+                "prefix": prefix,
+                "detail": str(e),
+            },
+            status=502,
+        )
+    except Exception as e:  # noqa: BLE001
+        log.exception("embed proxy failed for %s", upstream_url)
+        return web.json_response(
+            {"error": "embed proxy failed", "detail": str(e)},
+            status=502,
+        )
+    finally:
+        if owns_session and session is not None:
+            await session.close()
+
+
+async def handle_embed(request: web.Request) -> web.StreamResponse:
+    """HTTP reverse-proxy handler for ``/embed/ce/*`` and ``/embed/okstratr/*``."""
+    if request.method == "OPTIONS":
+        # Let upstream decide CORS; we still inject host headers via proxy.
+        return await _proxy_http(request)
+    return await _proxy_http(request)
+
+
+def register_routes(app: web.Application) -> None:
+    """Mount embed proxy routes (call before the SPA catch-all)."""
+    # Bare prefix + wildcard. Methods mirror what skill UIs typically need.
+    paths = (
+        PREFIX_CE,
+        PREFIX_CE + "/",
+        PREFIX_CE + "/{tail:.*}",
+        PREFIX_OKSTRATR,
+        PREFIX_OKSTRATR + "/",
+        PREFIX_OKSTRATR + "/{tail:.*}",
+    )
+    methods = ("GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD")
+    for path in paths:
+        for method in methods:
+            app.router.add_route(method, path, handle_embed)
+
+    async def _open_session(application: web.Application) -> None:
+        application["embed_http"] = ClientSession(
+            timeout=ClientTimeout(total=120, connect=5, sock_connect=5),
+        )
+
+    async def _close_session(application: web.Application) -> None:
+        sess = application.get("embed_http")
+        if sess is not None and not sess.closed:
+            await sess.close()
+
+    app.on_startup.append(_open_session)
+    app.on_cleanup.append(_close_session)
+
+
+# ── allowlist helpers (unit-tested) ─────────────────────────────────────
+
+def allowed_upstream_bases() -> frozenset[str]:
+    """Current configured (validated) upstream bases."""
+    t = embed_targets()
+    return frozenset(v["upstream"] for v in t.values())
+
+
+def upstream_allowed(url: str) -> bool:
+    """True if *url* targets a configured loopback embed upstream."""
+    try:
+        parts = urlsplit(url)
+        base = assert_loopback_upstream(
+            urlunsplit((parts.scheme, parts.netloc, "", "", ""))
+        )
+    except UpstreamNotLoopback:
+        return False
+    return base in allowed_upstream_bases()
diff --git a/src/switchbay/fileops.py b/src/switchbay/fileops.py
index 0a3de17..ef7deea 100644
--- a/src/switchbay/fileops.py
+++ b/src/switchbay/fileops.py
@@ -249,3 +249,65 @@ def inventory(workspace: Path) -> list[dict]:
             })
     out.sort(key=lambda d: d["path"])
     return out
+
+
+def vault_extracted_basename(rel: str) -> str | None:
+    """Return the vault/*.extracted.md basename for a workspace-relative
+    path (or cite), or None if it is not a vault extraction path."""
+    t = (rel or "").strip().replace("\\", "/")
+    if t.startswith("vault:"):
+        t = t[6:]
+    if t.startswith("./"):
+        t = t[2:]
+    if t.startswith("vault/"):
+        t = t[6:]
+    # Refuse traversal / absolute
+    if not t or t.startswith("/") or ".." in t.split("/") or "\x00" in t:
+        return None
+    # Only top-level vault extracts (no nested dirs in CE convention)
+    if "/" in t:
+        t = t.rsplit("/", 1)[-1]
+    if not t.endswith(".extracted.md"):
+        return None
+    return t
+
+
+def vault_db_read_body(workspace: Path, rel: str) -> str | None:
+    """Read extraction body from vault/vault.db FTS when the on-disk
+    file is missing.
+
+    CE indexes each `vault/*.extracted.md` into FTS5 `sources` keyed by
+    basename `path`. Some tip checkouts (wiki-only tarballs) ship an
+    empty or stub vault/ tree while still citing those basenames —
+    falling back to the FTS body lets Editor / /api/fs/raw open the
+    source without requiring a full file unpack.
+
+    Returns None when the DB is absent, empty, or has no matching row.
+    """
+    import sqlite3
+
+    name = vault_extracted_basename(rel)
+    if not name:
+        return None
+    db = workspace / "vault" / "vault.db"
+    if not db.is_file() or db.stat().st_size < 1000:
+        return None
+    try:
+        conn = sqlite3.connect(f"file:{db}?mode=ro", uri=True)
+    except sqlite3.Error:
+        return None
+    try:
+        # Prefer exact path match; also accept vault/-prefixed rows if
+        # an older indexer stored them that way.
+        row = conn.execute(
+            "SELECT body FROM sources WHERE path = ? OR path = ? LIMIT 1",
+            (name, f"vault/{name}"),
+        ).fetchone()
+        if not row or row[0] is None:
+            return None
+        body = str(row[0])
+        return body if body else None
+    except sqlite3.Error:
+        return None
+    finally:
+        conn.close()
diff --git a/src/switchbay/host_notify.py b/src/switchbay/host_notify.py
new file mode 100644
index 0000000..a3a5238
--- /dev/null
+++ b/src/switchbay/host_notify.py
@@ -0,0 +1,118 @@
+"""Map okstratr ``host_notify`` envelopes onto Switchbay rail notices.
+
+Contract C2: Switchbay sink is the **rail** only (path-native). okstratr
+emits ``okstratr.host_notify``; this host maps to ``protocol.notice`` and
+broadcasts on the agent chat stream.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from . import protocol
+
+ENVELOPE_TYPE = "okstratr.host_notify"
+ENVELOPE_V = 1
+
+_KIND_LABELS = {
+    "schedule.start": "Schedule started",
+    "schedule.progress": "Schedule progress",
+    "schedule.done": "Schedule done",
+    "schedule.failed": "Schedule failed",
+    "desk.progress": "Desk progress",
+    "desk.done": "Desk done",
+}
+
+
+def validate_envelope(body: Any) -> tuple[dict[str, Any] | None, str | None]:
+    """Return (envelope, error). error is set when invalid."""
+    if not isinstance(body, dict):
+        return None, "envelope must be a JSON object"
+    if body.get("type") != ENVELOPE_TYPE:
+        return None, f"type must be {ENVELOPE_TYPE!r}"
+    v = body.get("v", ENVELOPE_V)
+    try:
+        if int(v) != ENVELOPE_V:
+            return None, f"unsupported envelope v={v!r}"
+    except (TypeError, ValueError):
+        return None, f"unsupported envelope v={v!r}"
+    kind = body.get("kind")
+    if not isinstance(kind, str) or not kind.strip():
+        return None, "kind is required"
+    return body, None
+
+
+def format_rail_text(envelope: dict[str, Any]) -> str:
+    """Human rail line from a validated envelope."""
+    kind = str(envelope.get("kind") or "")
+    label = _KIND_LABELS.get(kind, kind)
+    title = (envelope.get("title") or "").strip()
+    body = (envelope.get("body") or "").strip()
+    desk = envelope.get("desk")
+    schedule_id = envelope.get("schedule_id")
+    progress = envelope.get("progress") if isinstance(envelope.get("progress"), dict) else None
+
+    parts: list[str] = [f"[okstratr] {label}"]
+    if title:
+        parts[0] = f"[okstratr] {label}: {title}"
+    meta: list[str] = []
+    if desk not in (None, "", "null"):
+        meta.append(f"desk={desk}")
+    if schedule_id:
+        meta.append(f"id={schedule_id}")
+    if progress:
+        pct = progress.get("pct")
+        phase = progress.get("phase")
+        detail = progress.get("detail")
+        bits: list[str] = []
+        if pct is not None:
+            bits.append(f"{pct}%")
+        if phase:
+            bits.append(str(phase))
+        if detail:
+            bits.append(str(detail))
+        if bits:
+            meta.append(" · ".join(bits))
+    lines = [parts[0]]
+    if meta:
+        lines.append("(" + ", ".join(meta) + ")")
+    if body:
+        lines.append(body)
+    return "\n".join(lines)
+
+
+def notice_from_envelope(envelope: dict[str, Any]) -> dict[str, Any]:
+    """Build a ``protocol.notice`` payload for rail broadcast."""
+    return protocol.notice(format_rail_text(envelope), kind="okstratr")
+
+
+def _notice_text(msg: dict[str, Any]) -> str | None:
+    """Extract human text from a protocol.notice CUSTOM envelope."""
+    if "text" in msg and isinstance(msg.get("text"), str):
+        return msg["text"]
+    val = msg.get("value")
+    if isinstance(val, dict) and isinstance(val.get("text"), str):
+        return val["text"]
+    return None
+
+
+async def apply_host_notify(app: Any, envelope: dict[str, Any]) -> dict[str, Any]:
+    """Validate + broadcast to rail. Returns result dict for HTTP handlers."""
+    env, err = validate_envelope(envelope)
+    if err or env is None:
+        return {"ok": False, "error": err or "invalid envelope"}
+    msg = notice_from_envelope(env)
+    # Daemon stores the bound helper as ``_broadcast_fn`` (same as CE).
+    bc = app.get("_broadcast_fn") if hasattr(app, "get") else None
+    if callable(bc):
+        await bc(app, msg)
+    else:
+        from . import daemon as _daemon
+
+        await _daemon._broadcast(app, msg)
+    return {
+        "ok": True,
+        "broadcast": True,
+        "text": _notice_text(msg) if isinstance(msg, dict) else None,
+        "notice": msg,
+    }
diff --git a/src/switchbay/ingest_run_drain.py b/src/switchbay/ingest_run_drain.py
new file mode 100644
index 0000000..de89dcc
--- /dev/null
+++ b/src/switchbay/ingest_run_drain.py
@@ -0,0 +1,517 @@
+"""Drain CE-queued ingest-runs into local_ingest (or Switchbay rail LLM).
+
+Curiosity Engine's drop-ingest
+(``POST /api/ingest/from-upload`` / ``from-path``) only stages under
+``vault/raw/`` and writes ``.workbench/ingest-runs/<run_id>.json`` with
+``status: "queued"`` — it does not run ``local_ingest`` or seat an LLM.
+Switchbay owns deterministic CE ingest + skill/LLM execution (same
+pattern as ``pack_run_drain`` / ADR-006).
+
+Default path: deterministic ``local_ingest`` (via ``ce_tools._ce_ingest``)
+for normal vault sources. Escalate to ``_dispatch_chat`` only when the
+run metadata opts in (``mode`` / ``drain`` ∈ {llm,rail,agent,dispatch}
+or ``prefer_rail`` / ``use_llm`` truthy).
+
+Both sides share the workspace, so Switchbay rewrites the same JSON
+status fields atomically — no CE PATCH required.
+"""
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+from pathlib import Path
+from typing import Any, Awaitable, Callable, Mapping
+
+from . import atomicio, ingest_prep
+
+log = logging.getLogger("switchbay.ingest_run_drain")
+
+RUNS_REL = Path(".workbench") / "ingest-runs"
+QUEUED_STATUSES = frozenset({"queued", "accepted"})
+POLL_INTERVAL_S = 4.0
+_RAIL_MODES = frozenset({"llm", "rail", "agent", "dispatch"})
+
+DispatchFn = Callable[..., Awaitable[Any]]
+LocalIngestFn = Callable[[Path, str, Mapping[str, Any]], dict[str, Any]]
+
+
+def runs_dir(workspace: Path) -> Path:
+    return Path(workspace).resolve() / RUNS_REL
+
+
+def run_path(workspace: Path, run_id: str) -> Path:
+    # Basename only — refuse path traversal via run_id.
+    safe = Path(str(run_id)).name
+    return runs_dir(workspace) / f"{safe}.json"
+
+
+def wants_rail(rec: Mapping[str, Any]) -> bool:
+    """True only when run metadata explicitly opts into LLM/rail drain."""
+    mode = str(rec.get("mode") or "").strip().lower()
+    if mode in _RAIL_MODES:
+        return True
+    drain = str(rec.get("drain") or "").strip().lower()
+    if drain in _RAIL_MODES:
+        return True
+    for key in ("prefer_rail", "use_llm", "llm"):
+        v = rec.get(key)
+        if v is True:
+            return True
+        if isinstance(v, str) and v.strip().lower() in {"1", "true", "yes"}:
+            return True
+    return False
+
+
+def build_ingest_prompt(vault_path: str, *, size: int | None = None) -> str:
+    """Same shape as ``handle_ingest_from_path`` in daemon.py."""
+    name = Path(vault_path).name
+    ext = Path(vault_path).suffix.lower().lstrip(".")
+    ext_hint = (
+        f"The file has extension `.{ext}`." if ext
+        else "The file has no extension."
+    )
+    size_hint = f" (size {size} bytes)" if size is not None else ""
+    return (
+        f"A file in this workspace at `{vault_path}` needs ingestion"
+        f"{size_hint}. {ext_hint} Ingest it as a CE-shaped wiki page:\n\n"
+        f"  1. Read the file (Read for text; for CSV/TSV produce a "
+        f"clean markdown table in the body; for PDFs try `pdftotext` "
+        f"first; for binaries you can't read, describe by filename + "
+        f"size).\n"
+        f"  2. Classify into a CE page type: `source` (PDFs, articles, "
+        f"citable artifacts), `table` (CSV/TSV data; the title prefix "
+        f"becomes `[tab]` and the body is the markdown table), "
+        f"`note` (plain prose), `figure` (images), `unclassified` "
+        f"as a last resort.\n"
+        f"  3. Slugify the filename's stem to kebab-case. Write the "
+        f"page with Write to `wiki/<type>s/<slug>.md` with frontmatter "
+        f"`type: <type>`, `title: \"[<typ>] <human title>\"`, "
+        f"`created` / `updated`, and `extracted_from: {vault_path}` so "
+        f"the round-trip target is recorded. Use the CE bracket-prefix "
+        f"convention (`[tab]`, `[src]`, `[note]`, `[fig]`).\n"
+        f"  4. Body: for tables, the full markdown table + a one-line "
+        f"caption above. For sources, 2-4 paragraphs of metadata + "
+        f"key takeaways. Don't write tools after Write — the graph "
+        f"rebuilds automatically on wiki/ changes.\n"
+        f"  5. If a wiki page with the same slug already exists "
+        f"because this file was ingested before, append `-2`, `-3` "
+        f"… so the new ingest doesn't clobber the previous one.\n"
+        f"(filename hint: `{name}`)"
+    )
+
+
+def list_queued_runs(workspace: Path) -> list[dict[str, Any]]:
+    """Read ``.workbench/ingest-runs/*.json`` with status queued/accepted."""
+    d = runs_dir(workspace)
+    if not d.is_dir():
+        return []
+    out: list[dict[str, Any]] = []
+    try:
+        paths = sorted(d.glob("*.json"))
+    except OSError:
+        return []
+    for p in paths:
+        try:
+            raw = json.loads(p.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError, UnicodeDecodeError):
+            continue
+        if not isinstance(raw, dict):
+            continue
+        status = str(raw.get("status") or "").strip()
+        if status not in QUEUED_STATUSES:
+            continue
+        rid = str(raw.get("run_id") or p.stem).strip()
+        if not rid:
+            continue
+        rec = dict(raw)
+        rec["run_id"] = rid
+        rec["_path"] = str(p)
+        out.append(rec)
+    return out
+
+
+def write_run_status(
+    workspace: Path,
+    run_id: str,
+    status: str,
+    **extra: Any,
+) -> dict[str, Any] | None:
+    """Atomically update an ingest-run JSON's status (+ optional fields)."""
+    path = run_path(workspace, run_id)
+    if not path.is_file():
+        return None
+    try:
+        rec = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError, UnicodeDecodeError):
+        return None
+    if not isinstance(rec, dict):
+        return None
+    rec["status"] = status
+    for k, v in extra.items():
+        if v is None:
+            rec.pop(k, None)
+        else:
+            rec[k] = v
+    path.parent.mkdir(parents=True, exist_ok=True)
+    atomicio.write_json_atomic(path, rec)
+    return rec
+
+
+def resolve_run_vault_path(
+    workspace: Path, rec: Mapping[str, Any],
+) -> tuple[str, Path] | str:
+    """Return ``(rel, resolved)`` or an error note (refuse escape)."""
+    raw = str(
+        rec.get("vault_path") or rec.get("path") or ""
+    ).strip()
+    if not raw:
+        return "vault_path is required on the ingest-run record"
+    if "\x00" in raw:
+        return "invalid vault_path"
+    # Refuse absolute paths and ``..`` components before resolve so
+    # ``vault/raw/../../etc/passwd`` cannot normalize into-workspace.
+    candidate = Path(raw)
+    if candidate.is_absolute():
+        return f"vault_path escapes workspace or is invalid: {raw}"
+    if any(part == ".." for part in candidate.parts):
+        return f"vault_path escapes workspace or is invalid: {raw}"
+    resolved = ingest_prep.resolve_workspace_path(workspace, raw)
+    if resolved is None:
+        return f"vault_path escapes workspace or is invalid: {raw}"
+    try:
+        rel = resolved.relative_to(Path(workspace).resolve()).as_posix()
+    except ValueError:
+        return f"vault_path escapes workspace: {raw}"
+    return rel, resolved
+
+
+def _inflight(app: Any) -> set[str]:
+    s = app.get("ingest_run_inflight")
+    if s is None:
+        s = set()
+        app["ingest_run_inflight"] = s
+    return s
+
+
+def _default_dispatch_fn() -> DispatchFn:
+    async def _dispatch(app: Any, **kwargs: Any) -> Any:
+        from . import daemon as _daemon
+
+        return await _daemon._dispatch_chat(
+            app,
+            ws=None,
+            text=kwargs["text"],
+            input_excerpt=kwargs.get("input_excerpt"),
+            run_id=kwargs.get("run_id"),
+            command=kwargs.get("command", "ingest"),
+        )
+
+    return _dispatch
+
+
+def _default_local_ingest_fn() -> LocalIngestFn:
+    def _local(
+        workspace: Path, vault_path: str, _rec: Mapping[str, Any],
+    ) -> dict[str, Any]:
+        from . import ce_tools
+
+        return ce_tools._ce_ingest(workspace, {"path": vault_path})
+
+    return _local
+
+
+def _error_surface(app: Any, run_id: str):
+    from . import daemon as _daemon
+
+    return _daemon._make_dispatch_error_surface(app, run_id)
+
+
+def _local_ok(result: Mapping[str, Any]) -> tuple[bool, str | None]:
+    """Interpret ce_tools / local_ingest JSON as success or failure note."""
+    if not isinstance(result, Mapping):
+        return False, "local_ingest returned non-object"
+    err = result.get("error")
+    if err:
+        return False, str(err)
+    # Summary shape from local_ingest.main: ok count + results list.
+    if "ok" in result and isinstance(result.get("ok"), int):
+        considered = int(result.get("considered") or 0)
+        ok_n = int(result["ok"])
+        if considered == 0:
+            return False, "local_ingest considered 0 files"
+        if ok_n <= 0:
+            return False, "local_ingest ok=0"
+        return True, None
+    # Tool / prep may return ok: True without counts.
+    if result.get("ok") is True:
+        return True, None
+    if result.get("ok") is False:
+        return False, str(result.get("reason") or "local_ingest ok=false")
+    # Unknown success-shaped payload — treat as done if no error.
+    return True, None
+
+
+async def drain_once(
+    app: Any,
+    *,
+    dispatch_fn: DispatchFn | None = None,
+    local_ingest_fn: LocalIngestFn | None = None,
+) -> dict[str, Any]:
+    """Process each queued ingest-run (local first, rail if metadata says).
+
+    Returns ``{drained, skipped, errors, …}``. Deduplicates via
+    ``app['ingest_run_inflight']``.
+    """
+    workspace = Path(app["workspace"])
+    dispatch = dispatch_fn or _default_dispatch_fn()
+    local_fn = local_ingest_fn or _default_local_ingest_fn()
+    inflight = _inflight(app)
+
+    drained: list[str] = []
+    skipped: list[str] = []
+    errors: list[dict[str, str]] = []
+
+    queued = await asyncio.to_thread(list_queued_runs, workspace)
+    for rec in queued:
+        run_id = str(rec["run_id"])
+        if run_id in inflight:
+            skipped.append(run_id)
+            continue
+
+        try:
+            path = run_path(workspace, run_id)
+            fresh = json.loads(path.read_text(encoding="utf-8"))
+            st = str(fresh.get("status") or "")
+            if st not in QUEUED_STATUSES:
+                skipped.append(run_id)
+                continue
+        except (OSError, json.JSONDecodeError, UnicodeDecodeError):
+            skipped.append(run_id)
+            continue
+
+        validated = resolve_run_vault_path(workspace, rec)
+        if isinstance(validated, str):
+            note = validated
+            await asyncio.to_thread(
+                write_run_status, workspace, run_id, "failed", note=note,
+            )
+            errors.append({"run_id": run_id, "error": note})
+            continue
+
+        rel, resolved = validated
+        if not resolved.is_file():
+            note = f"staged file not found: {rel}"
+            await asyncio.to_thread(
+                write_run_status, workspace, run_id, "failed", note=note,
+            )
+            errors.append({"run_id": run_id, "error": note})
+            continue
+
+        use_rail = wants_rail(rec)
+        size = rec.get("size")
+        try:
+            size_i = int(size) if size is not None else resolved.stat().st_size
+        except (TypeError, ValueError, OSError):
+            size_i = None
+
+        inflight.add(run_id)
+        try:
+            await asyncio.to_thread(
+                write_run_status,
+                workspace,
+                run_id,
+                "running",
+                drain_via="rail" if use_rail else "local_ingest",
+            )
+        except Exception as e:  # noqa: BLE001
+            inflight.discard(run_id)
+            note = f"failed to mark running: {e}"
+            errors.append({"run_id": run_id, "error": note})
+            continue
+
+        if use_rail:
+            prompt = build_ingest_prompt(rel, size=size_i)
+            excerpt = f"ingest {Path(rel).name}"
+
+            async def _runner(
+                rid: str = run_id,
+                text: str = prompt,
+                input_excerpt: str = excerpt,
+                vault: str = rel,
+            ) -> None:
+                async def _tag_run() -> None:
+                    await asyncio.sleep(0)
+                    runs = app.get("runs") or {}
+                    r = runs.get(rid)
+                    if r is not None:
+                        r["kind"] = "ingest-upload"
+                        r["vault_path"] = vault
+
+                asyncio.create_task(_tag_run())
+                try:
+                    await dispatch(
+                        app,
+                        text=text,
+                        input_excerpt=input_excerpt,
+                        run_id=rid,
+                        command="ingest",
+                    )
+                except Exception:  # noqa: BLE001
+                    log.exception("ingest-run rail drain %s crashed", rid)
+                    raise
+
+            def _on_done(task: asyncio.Task, rid: str = run_id) -> None:
+                inflight.discard(rid)
+                try:
+                    exc = task.exception()
+                except (asyncio.CancelledError, asyncio.InvalidStateError):
+                    try:
+                        write_run_status(
+                            workspace, rid, "failed",
+                            note="dispatch cancelled",
+                        )
+                    except Exception:  # noqa: BLE001
+                        pass
+                    return
+                try:
+                    if exc is None:
+                        write_run_status(workspace, rid, "done")
+                    else:
+                        write_run_status(
+                            workspace, rid, "failed",
+                            note=f"{type(exc).__name__}: {exc}",
+                        )
+                except Exception:  # noqa: BLE001
+                    log.exception(
+                        "ingest-run status update failed for %s", rid,
+                    )
+                try:
+                    _error_surface(app, rid)(task)
+                except Exception:  # noqa: BLE001
+                    pass
+
+            try:
+                task = asyncio.create_task(_runner())
+                task.add_done_callback(_on_done)
+                drained.append(run_id)
+            except Exception as e:  # noqa: BLE001
+                inflight.discard(run_id)
+                note = f"failed to start dispatch: {e}"
+                await asyncio.to_thread(
+                    write_run_status, workspace, run_id, "failed", note=note,
+                )
+                errors.append({"run_id": run_id, "error": note})
+            continue
+
+        # Deterministic local_ingest path.
+        async def _local_runner(
+            rid: str = run_id,
+            vault: str = rel,
+            record: Mapping[str, Any] = rec,
+        ) -> None:
+            try:
+                result = await asyncio.to_thread(
+                    local_fn, workspace, vault, record,
+                )
+            except Exception as e:  # noqa: BLE001
+                log.exception("ingest-run local drain %s crashed", rid)
+                raise RuntimeError(f"{type(e).__name__}: {e}") from e
+            ok, note = _local_ok(result if isinstance(result, dict) else {})
+            if not ok:
+                raise RuntimeError(note or "local_ingest failed")
+            # Stash a compact summary on the run record before done.
+            summary: dict[str, Any] = {}
+            if isinstance(result, dict):
+                for k in (
+                    "ok", "failed", "considered", "file", "mode",
+                    "multimodal_pending",
+                ):
+                    if k in result:
+                        summary[k] = result[k]
+            if summary:
+                await asyncio.to_thread(
+                    write_run_status,
+                    workspace,
+                    rid,
+                    "running",
+                    local_ingest=summary,
+                )
+
+        def _on_local_done(task: asyncio.Task, rid: str = run_id) -> None:
+            inflight.discard(rid)
+            try:
+                exc = task.exception()
+            except (asyncio.CancelledError, asyncio.InvalidStateError):
+                try:
+                    write_run_status(
+                        workspace, rid, "failed",
+                        note="local_ingest cancelled",
+                    )
+                except Exception:  # noqa: BLE001
+                    pass
+                return
+            try:
+                if exc is None:
+                    write_run_status(workspace, rid, "done")
+                else:
+                    write_run_status(
+                        workspace, rid, "failed",
+                        note=f"{type(exc).__name__}: {exc}",
+                    )
+            except Exception:  # noqa: BLE001
+                log.exception(
+                    "ingest-run status update failed for %s", rid,
+                )
+
+        try:
+            task = asyncio.create_task(_local_runner())
+            task.add_done_callback(_on_local_done)
+            drained.append(run_id)
+        except Exception as e:  # noqa: BLE001
+            inflight.discard(run_id)
+            note = f"failed to start local_ingest: {e}"
+            await asyncio.to_thread(
+                write_run_status, workspace, run_id, "failed", note=note,
+            )
+            errors.append({"run_id": run_id, "error": note})
+
+    return {
+        "drained": drained,
+        "skipped": skipped,
+        "errors": errors,
+        "drained_count": len(drained),
+        "skipped_count": len(skipped),
+        "error_count": len(errors),
+    }
+
+
+async def ingest_run_drain_loop(app: Any) -> None:
+    """Background: every ~4s, drain queued ingest-runs if the dir exists."""
+    while True:
+        try:
+            await asyncio.sleep(POLL_INTERVAL_S)
+            ws = Path(app["workspace"])
+            if not runs_dir(ws).is_dir():
+                continue
+            await drain_once(app)
+        except asyncio.CancelledError:
+            return
+        except Exception:  # noqa: BLE001
+            log.exception("ingest-run drain loop iteration failed")
+
+
+def kick_drain(app: Any) -> None:
+    """Schedule an immediate drain_once on the running loop (best-effort)."""
+    try:
+        loop = asyncio.get_running_loop()
+    except RuntimeError:
+        return
+
+    async def _go() -> None:
+        try:
+            await drain_once(app)
+        except Exception:  # noqa: BLE001
+            log.exception("kicked ingest-run drain failed")
+
+    loop.create_task(_go())
diff --git a/src/switchbay/okstratr_harness.py b/src/switchbay/okstratr_harness.py
new file mode 100644
index 0000000..1c38f1f
--- /dev/null
+++ b/src/switchbay/okstratr_harness.py
@@ -0,0 +1,284 @@
+"""Thin client over okstratr harness+model registry (SSOT).
+
+Ben lock: okstratr owns the harness allowlist and model pools
+(``harnesses.toml``). Switchbay Settings / shells configure that registry
+through HTTP — they must **not** invent a parallel Switchbay allowlist.
+
+Call paths
+----------
+* **Browser (preferred same-origin):** ``/embed/okstratr/api/harness…``
+  when the embed proxy is up (loopback rules + ``X-Okstratr-Host`` stay
+  intact).
+* **Daemon thin routes:** ``/api/okstratr/harness`` (and
+  ``…/enable|disable|set|reload``) so UI/shells need not know embed
+  paths. Server-side these call ``SWITCHBAY_OKSTRATR_UPSTREAM``
+  (default ``http://127.0.0.1:8767``), loopback-guarded via
+  :mod:`switchbay.embed_proxy`, with ``X-Okstratr-Host: switchbay``.
+
+okbay should mirror this thin-client pattern (see okbay
+``docs/HERDR-AND-REGISTRY.md`` and Switchbay ``/api/okstratr/host-notify``).
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Mapping
+
+from aiohttp import ClientSession, ClientTimeout, web
+
+from . import embed_proxy
+
+log = logging.getLogger("switchbay.okstratr_harness")
+
+# Upstream okstratr paths (also available under /api/config/harness…).
+_PATHS = {
+    "list": "/api/harness",
+    "enable": "/api/harness/enable",
+    "disable": "/api/harness/disable",
+    "set": "/api/harness/set",
+    "reload": "/api/harness/reload",
+}
+
+# Same-origin embed prefixes the browser can use directly.
+EMBED_LIST = "/embed/okstratr/api/harness"
+EMBED_ENABLE = "/embed/okstratr/api/harness/enable"
+EMBED_DISABLE = "/embed/okstratr/api/harness/disable"
+EMBED_SET = "/embed/okstratr/api/harness/set"
+EMBED_RELOAD = "/embed/okstratr/api/harness/reload"
+
+
+class OkstratrHarnessError(RuntimeError):
+    """Upstream unreachable, non-loopback, or bad response."""
+
+    def __init__(self, message: str, *, status: int = 502, detail: Any = None):
+        super().__init__(message)
+        self.status = status
+        self.detail = detail
+
+
+def embed_paths() -> dict[str, str]:
+    """Public same-origin paths (for docs / UI hints)."""
+    return {
+        "list": EMBED_LIST,
+        "enable": EMBED_ENABLE,
+        "disable": EMBED_DISABLE,
+        "set": EMBED_SET,
+        "reload": EMBED_RELOAD,
+    }
+
+
+def upstream_url(action: str = "list") -> str:
+    """Absolute loopback URL for a harness API action."""
+    path = _PATHS.get(action)
+    if path is None:
+        raise ValueError(f"unknown harness action: {action!r}")
+    try:
+        base = embed_proxy.assert_loopback_upstream(embed_proxy.okstratr_upstream())
+    except embed_proxy.UpstreamNotLoopback as e:
+        raise OkstratrHarnessError(str(e), status=502) from e
+    return f"{base}{path}"
+
+
+def normalize_registry(payload: Mapping[str, Any] | None) -> dict[str, Any]:
+    """Map okstratr ``list_for_api`` JSON into a stable Switchbay view.
+
+    Pass-through of the SSOT fields; never invents an allowlist. Missing
+    keys become empty defaults so the Settings UI can render safely.
+    """
+    raw = dict(payload or {})
+    harnesses_in = raw.get("harnesses")
+    rows: list[dict[str, Any]] = []
+    if isinstance(harnesses_in, list):
+        for item in harnesses_in:
+            if not isinstance(item, dict):
+                continue
+            hid = str(item.get("id") or "").strip().lower()
+            if not hid:
+                continue
+            models = item.get("models") or []
+            if not isinstance(models, list):
+                models = []
+            effort = item.get("effort") if isinstance(item.get("effort"), dict) else {}
+            settings = (
+                item.get("settings") if isinstance(item.get("settings"), dict) else {}
+            )
+            rows.append(
+                {
+                    "id": hid,
+                    "label": str(item.get("label") or hid),
+                    "enabled": bool(item.get("enabled")),
+                    "installed": bool(item.get("installed")),
+                    "default_model": item.get("default_model"),
+                    "models": [str(m) for m in models],
+                    "effort": dict(effort),
+                    "settings": dict(settings),
+                    "herdr_kind": item.get("herdr_kind"),
+                    "bin_names": list(item.get("bin_names") or []),
+                    "notes": str(item.get("notes") or ""),
+                }
+            )
+    enabled = raw.get("enabled")
+    if not isinstance(enabled, list):
+        enabled = [h["id"] for h in rows if h["enabled"]]
+    preference = raw.get("preference")
+    if not isinstance(preference, list):
+        preference = list(enabled)
+    defaults = raw.get("defaults") if isinstance(raw.get("defaults"), dict) else {}
+    blackboard = (
+        raw.get("blackboard") if isinstance(raw.get("blackboard"), dict) else {}
+    )
+    return {
+        "ok": bool(raw.get("ok", True)),
+        "ssot": "okstratr",
+        "path": raw.get("path"),
+        "enabled": [str(x).strip().lower() for x in enabled if str(x).strip()],
+        "preference": [str(x).strip().lower() for x in preference if str(x).strip()],
+        "defaults": dict(defaults),
+        "backend": str(raw.get("backend") or defaults.get("backend") or ""),
+        "harnesses": rows,
+        "blackboard": dict(blackboard),
+        "embed_paths": embed_paths(),
+    }
+
+
+def _hosted_headers() -> dict[str, str]:
+    return {
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+        embed_proxy.HOST_HEADER_OKSTRATR: embed_proxy.HOSTED_SHELL,
+    }
+
+
+async def _session_for(app: web.Application | None) -> tuple[ClientSession, bool]:
+    """Reuse embed_http session when available; else open a short-lived one."""
+    timeout = ClientTimeout(total=30, connect=5, sock_connect=5)
+    if app is not None:
+        sess = app.get("embed_http")
+        if sess is not None and not sess.closed:
+            return sess, False
+    return ClientSession(timeout=timeout), True
+
+
+async def call_harness(
+    action: str,
+    *,
+    method: str = "GET",
+    body: Mapping[str, Any] | None = None,
+    app: web.Application | None = None,
+) -> dict[str, Any]:
+    """HTTP call to okstratr harness API; return normalized registry (or error)."""
+    url = upstream_url(action)
+    session, owns = await _session_for(app)
+    try:
+        async with session.request(
+            method.upper(),
+            url,
+            headers=_hosted_headers(),
+            json=dict(body) if body is not None else None,
+            allow_redirects=False,
+        ) as resp:
+            try:
+                data = await resp.json(content_type=None)
+            except Exception:  # noqa: BLE001
+                text = await resp.text()
+                raise OkstratrHarnessError(
+                    f"okstratr harness returned non-JSON (HTTP {resp.status})",
+                    status=502 if resp.status >= 500 else resp.status,
+                    detail=text[:500],
+                )
+            if resp.status >= 400:
+                err = None
+                if isinstance(data, dict):
+                    err = data.get("error") or data.get("detail")
+                raise OkstratrHarnessError(
+                    str(err or f"okstratr harness HTTP {resp.status}"),
+                    status=resp.status,
+                    detail=data,
+                )
+            if not isinstance(data, dict):
+                raise OkstratrHarnessError(
+                    "okstratr harness response must be a JSON object",
+                    status=502,
+                    detail=data,
+                )
+            # Mutations return list_for_api; reload wraps under "config".
+            if action == "reload" and isinstance(data.get("config"), dict):
+                return normalize_registry(data["config"])
+            return normalize_registry(data)
+    except OkstratrHarnessError:
+        raise
+    except OSError as e:
+        log.warning("okstratr harness unreachable %s: %s", url, e)
+        raise OkstratrHarnessError(
+            "okstratr harness unreachable (is okstratr up on the embed upstream?)",
+            status=502,
+            detail=str(e),
+        ) from e
+    except Exception as e:  # noqa: BLE001
+        log.exception("okstratr harness call failed for %s", url)
+        raise OkstratrHarnessError(
+            f"okstratr harness call failed: {e}",
+            status=502,
+            detail=str(e),
+        ) from e
+    finally:
+        if owns:
+            await session.close()
+
+
+async def list_harnesses(app: web.Application | None = None) -> dict[str, Any]:
+    return await call_harness("list", method="GET", app=app)
+
+
+async def enable_harness(
+    harness_id: str, *, app: web.Application | None = None
+) -> dict[str, Any]:
+    hid = (harness_id or "").strip()
+    if not hid:
+        raise OkstratrHarnessError("id is required", status=400)
+    return await call_harness(
+        "enable", method="POST", body={"id": hid}, app=app
+    )
+
+
+async def disable_harness(
+    harness_id: str, *, app: web.Application | None = None
+) -> dict[str, Any]:
+    hid = (harness_id or "").strip()
+    if not hid:
+        raise OkstratrHarnessError("id is required", status=400)
+    return await call_harness(
+        "disable", method="POST", body={"id": hid}, app=app
+    )
+
+
+async def set_harness_value(
+    key: str,
+    value: str,
+    *,
+    app: web.Application | None = None,
+) -> dict[str, Any]:
+    k = (key or "").strip()
+    if not k:
+        raise OkstratrHarnessError("key is required", status=400)
+    return await call_harness(
+        "set",
+        method="POST",
+        body={"key": k, "value": "" if value is None else str(value)},
+        app=app,
+    )
+
+
+async def reload_harnesses(app: web.Application | None = None) -> dict[str, Any]:
+    return await call_harness("reload", method="POST", body={}, app=app)
+
+
+def error_response(exc: OkstratrHarnessError) -> web.Response:
+    payload: dict[str, Any] = {
+        "ok": False,
+        "ssot": "okstratr",
+        "error": str(exc),
+    }
+    if exc.detail is not None:
+        payload["detail"] = exc.detail
+    return web.json_response(payload, status=int(exc.status or 502))
diff --git a/src/switchbay/okstratr_supervisor.py b/src/switchbay/okstratr_supervisor.py
new file mode 100644
index 0000000..be87d18
--- /dev/null
+++ b/src/switchbay/okstratr_supervisor.py
@@ -0,0 +1,357 @@
+"""Keep okstratr desk kernel alive for Switchbay (core skill).
+
+Mirrors ``ce_viewer_supervisor``: start on loopback (default
+``http://127.0.0.1:8767``, override ``SWITCHBAY_OKSTRATR_UPSTREAM``),
+health-check ``/health``, restart on death. Pid/log under
+``~/.local/state/switchbay/``.
+
+Spawn: ``okstratr serve --host/--port`` on PATH (or
+``SWITCHBAY_OKSTRATR_BIN`` / ``python -m okstratr serve``). Uses the
+long-lived ``serve`` entry (same as okstratr ``lifecycle._spawn_serve``),
+not ``start`` which exits after detaching.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import os
+import shutil
+import signal
+import subprocess
+import sys
+import time
+from pathlib import Path
+from typing import Any
+from urllib.error import URLError
+from urllib.parse import urlparse
+from urllib.request import urlopen
+
+from . import embed_proxy
+
+log = logging.getLogger("switchbay.okstratr_supervisor")
+
+_PID_NAME = "okstratr.pid"
+_LOG_NAME = "okstratr.log"
+_HEALTH_PATH = "/health"
+_POLL_SEC = 5.0
+
+# Contract C1 state machine (shared with core_skills.status).
+_STATE: dict[str, Any] = {
+    "state": "stopped",  # starting|healthy|unhealthy|stopped
+    "detail": "",
+}
+
+
+def _state_dir() -> Path:
+    d = Path.home() / ".local" / "state" / "switchbay"
+    d.mkdir(parents=True, exist_ok=True)
+    return d
+
+
+def pid_path() -> Path:
+    return _state_dir() / _PID_NAME
+
+
+def log_path() -> Path:
+    return _state_dir() / _LOG_NAME
+
+
+def upstream_base() -> str:
+    return embed_proxy.okstratr_upstream()
+
+
+def upstream_port() -> int:
+    u = urlparse(upstream_base())
+    if u.port:
+        return int(u.port)
+    return 443 if u.scheme == "https" else 80
+
+
+def upstream_host() -> str:
+    u = urlparse(upstream_base())
+    return u.hostname or "127.0.0.1"
+
+
+def health_url() -> str:
+    return upstream_base().rstrip("/") + _HEALTH_PATH
+
+
+def is_healthy(*, timeout: float = 2.0) -> bool:
+    try:
+        with urlopen(health_url(), timeout=timeout) as resp:  # noqa: S310 — loopback
+            if not (200 <= int(getattr(resp, "status", 200)) < 500):
+                return False
+            # okstratr /health returns {"ok": true}; tolerate plain 200 too.
+            raw = resp.read().decode("utf-8", errors="replace")
+            if not raw.strip():
+                return True
+            import json
+
+            try:
+                data = json.loads(raw)
+            except json.JSONDecodeError:
+                return True
+            if isinstance(data, dict) and "ok" in data:
+                return bool(data.get("ok"))
+            return True
+    except (URLError, OSError, TimeoutError, ValueError):
+        return False
+
+
+def _read_pid() -> int | None:
+    p = pid_path()
+    if not p.is_file():
+        return None
+    try:
+        raw = p.read_text(encoding="utf-8").strip()
+        return int(raw) if raw else None
+    except (OSError, ValueError):
+        return None
+
+
+def _pid_alive(pid: int) -> bool:
+    if pid <= 0:
+        return False
+    try:
+        os.kill(pid, 0)
+        return True
+    except OSError:
+        return False
+
+
+def _public_base() -> str:
+    return (
+        os.environ.get("OKSTRATR_PUBLIC_BASE") or "/embed/okstratr"
+    ).rstrip("/") or "/embed/okstratr"
+
+
+def resolve_okstratr_argv() -> list[str]:
+    """Return argv prefix to invoke okstratr CLI (no subcommand yet)."""
+    override = (os.environ.get("SWITCHBAY_OKSTRATR_BIN") or "").strip()
+    if override:
+        return [override]
+    exe = shutil.which("okstratr")
+    if exe:
+        return [exe]
+    return [sys.executable or "python3", "-m", "okstratr"]
+
+
+def _set_state(state: str, detail: str = "") -> None:
+    _STATE["state"] = state
+    _STATE["detail"] = detail
+
+
+def contract_slice() -> dict[str, Any]:
+    """C1 status slice for okstratr."""
+    healthy = is_healthy()
+    pid = _read_pid()
+    if healthy:
+        state = "healthy"
+        detail = _STATE.get("detail") or "up"
+    elif _STATE.get("state") == "starting":
+        state = "starting"
+        detail = _STATE.get("detail") or "starting"
+    elif pid and _pid_alive(pid):
+        state = "unhealthy"
+        detail = _STATE.get("detail") or "process up but /health failing"
+    elif _STATE.get("state") == "unhealthy":
+        state = "unhealthy"
+        detail = _STATE.get("detail") or "unhealthy"
+    else:
+        state = "stopped"
+        detail = _STATE.get("detail") or "stopped"
+    return {
+        "state": state,
+        "url": upstream_base(),
+        "detail": detail,
+    }
+
+
+def start(workspace: Path | None = None) -> dict[str, Any]:
+    """Start okstratr serve if not healthy. Idempotent."""
+    if is_healthy():
+        _set_state("healthy", "already running")
+        return {
+            "ok": True,
+            "already_running": True,
+            "healthy": True,
+            "url": upstream_base(),
+            "port": upstream_port(),
+            "pid": _read_pid(),
+        }
+
+    _set_state("starting", "spawning okstratr serve")
+    old = _read_pid()
+    if old and not _pid_alive(old):
+        try:
+            pid_path().unlink(missing_ok=True)
+        except OSError:
+            pass
+
+    host = upstream_host()
+    port = upstream_port()
+    # Use `serve` (long-lived HTTP), not `start` (launcher that exits after
+    # detaching). Same command lifecycle._spawn_serve uses.
+    argv = resolve_okstratr_argv() + [
+        "serve",
+        "--host",
+        host,
+        "--port",
+        str(port),
+    ]
+
+    env = os.environ.copy()
+    env["OKSTRATR_PUBLIC_BASE"] = _public_base()
+    # Hosted mode: okstratr scrub/inject + conversation stub copy (parity with okbay).
+    env.setdefault("OKSTRATR_HOST", "switchbay")
+    env.setdefault("OKSTRATR_HOSTED", "switchbay")
+    # Prefer embed public base so hosted observer URLs match /embed/okstratr.
+    if workspace is not None:
+        env.setdefault("OKSTRATR_WORKSPACE", str(Path(workspace).expanduser()))
+
+    logf = log_path().open("a", encoding="utf-8")
+    try:
+        proc = subprocess.Popen(  # noqa: S603
+            argv,
+            cwd=str(Path(workspace).expanduser()) if workspace else None,
+            env=env,
+            stdout=logf,
+            stderr=subprocess.STDOUT,
+            start_new_session=True,
+        )
+    except OSError as e:
+        logf.close()
+        _set_state("unhealthy", f"failed to spawn: {e}")
+        return {"ok": False, "error": f"failed to spawn okstratr: {e}", "argv": argv}
+
+    try:
+        pid_path().write_text(str(proc.pid) + "\n", encoding="utf-8")
+    except OSError as e:
+        log.warning("could not write okstratr pid: %s", e)
+
+    deadline = time.time() + 15.0
+    while time.time() < deadline:
+        if is_healthy():
+            _set_state("healthy", "started")
+            return {
+                "ok": True,
+                "already_running": False,
+                "healthy": True,
+                "url": upstream_base(),
+                "port": port,
+                "pid": proc.pid,
+                "argv": argv,
+                "log": str(log_path()),
+            }
+        if proc.poll() is not None:
+            _set_state("unhealthy", f"serve exited code={proc.returncode}")
+            return {
+                "ok": False,
+                "error": f"okstratr serve exited early code={proc.returncode}",
+                "log": str(log_path()),
+                "argv": argv,
+            }
+        time.sleep(0.4)
+
+    if is_healthy():
+        _set_state("healthy", "started (late health)")
+        return {
+            "ok": True,
+            "already_running": False,
+            "healthy": True,
+            "url": upstream_base(),
+            "port": port,
+            "pid": proc.pid,
+            "argv": argv,
+            "log": str(log_path()),
+        }
+
+    _set_state("unhealthy", "health check timed out")
+    return {
+        "ok": False,
+        "error": "okstratr started but health check timed out",
+        "pid": proc.pid,
+        "log": str(log_path()),
+        "url": upstream_base(),
+        "argv": argv,
+    }
+
+
+def stop() -> dict[str, Any]:
+    """Stop the serve process we spawned (best-effort)."""
+    pid = _read_pid()
+    if not pid:
+        _set_state("stopped", "no pid file")
+        return {"ok": True, "stopped": False, "note": "no pid file"}
+    if not _pid_alive(pid):
+        try:
+            pid_path().unlink(missing_ok=True)
+        except OSError:
+            pass
+        _set_state("stopped", "pid gone")
+        return {"ok": True, "stopped": False, "note": "pid gone", "pid": pid}
+    try:
+        os.kill(pid, signal.SIGTERM)
+    except OSError as e:
+        try:
+            pid_path().unlink(missing_ok=True)
+        except OSError:
+            pass
+        _set_state("stopped", f"pid gone: {e}")
+        return {"ok": True, "stopped": False, "note": f"pid gone: {e}", "pid": pid}
+    deadline = time.time() + 5.0
+    while time.time() < deadline and _pid_alive(pid):
+        time.sleep(0.2)
+    if _pid_alive(pid):
+        try:
+            os.kill(pid, signal.SIGKILL)
+        except OSError:
+            pass
+    try:
+        pid_path().unlink(missing_ok=True)
+    except OSError:
+        pass
+    _set_state("stopped", "stopped")
+    return {"ok": True, "stopped": True, "pid": pid}
+
+
+def status(workspace: Path | None = None) -> dict[str, Any]:
+    pid = _read_pid()
+    return {
+        "ok": True,
+        "healthy": is_healthy(),
+        "url": upstream_base(),
+        "port": upstream_port(),
+        "pid": pid,
+        "pid_alive": _pid_alive(pid) if pid else False,
+        "public_base": _public_base(),
+        "argv_prefix": resolve_okstratr_argv(),
+        "workspace": str(workspace) if workspace else None,
+        "log": str(log_path()),
+        "contract": contract_slice(),
+    }
+
+
+async def run_supervisor(app: Any) -> None:
+    """Background task: always keep okstratr up (core experience)."""
+    while True:
+        try:
+            if not is_healthy():
+                ws = Path(app["workspace"])
+                log.info("okstratr unhealthy — starting for %s", ws)
+                _set_state("starting", "supervisor restart")
+                out = await asyncio.to_thread(start, ws)
+                if not out.get("ok"):
+                    _set_state("unhealthy", str(out.get("error") or "start failed"))
+                    log.warning("okstratr start failed: %s", out.get("error"))
+                else:
+                    _set_state("healthy", "supervisor")
+            else:
+                _set_state("healthy", "supervisor")
+        except asyncio.CancelledError:
+            raise
+        except Exception:  # noqa: BLE001
+            log.exception("okstratr supervisor loop error")
+            _set_state("unhealthy", "supervisor loop error")
+        await asyncio.sleep(_POLL_SEC)
diff --git a/src/switchbay/pack_run_drain.py b/src/switchbay/pack_run_drain.py
new file mode 100644
index 0000000..3c869d2
--- /dev/null
+++ b/src/switchbay/pack_run_drain.py
@@ -0,0 +1,336 @@
+"""Drain CE-queued pack-runs into Switchbay rail LLM dispatch.
+
+Curiosity Engine's filebrowser ``POST /api/packs/<pack>/action/<action>``
+only writes ``.workbench/pack-runs/<run_id>.json`` with
+``status: "queued"`` — it does not seat an LLM agent. Switchbay owns
+skill/LLM execution (same path as ``handle_pack_action``). This module
+lists those JSON files, validates pack+skill, and fires
+``_dispatch_chat`` (or an injectable ``dispatch_fn`` for tests).
+
+Both sides share the workspace, so Switchbay rewrites the same JSON
+status fields atomically — no CE PATCH required.
+"""
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+from pathlib import Path
+from typing import Any, Awaitable, Callable, Mapping
+
+from . import atomicio, packstore, skillkit
+
+log = logging.getLogger("switchbay.pack_run_drain")
+
+RUNS_REL = Path(".workbench") / "pack-runs"
+QUEUED_STATUSES = frozenset({"queued", "accepted"})
+# Poll cadence for the background drain loop (3–5s charter window).
+POLL_INTERVAL_S = 4.0
+
+DispatchFn = Callable[..., Awaitable[Any]]
+
+
+def runs_dir(workspace: Path) -> Path:
+    return Path(workspace).resolve() / RUNS_REL
+
+
+def run_path(workspace: Path, run_id: str) -> Path:
+    # Basename only — refuse path traversal via run_id.
+    safe = Path(str(run_id)).name
+    return runs_dir(workspace) / f"{safe}.json"
+
+
+def build_pack_prompt(pack: str, action: str, rel_path: str) -> str:
+    """Same prompt text as ``handle_pack_action`` in daemon.py."""
+    skill = f"{pack}-{action}"
+    return (
+        f"Load the `{skill}` skill with load_skill(\"{skill}\") and follow it "
+        f"exactly to handle the file `{rel_path}` in this workspace. The `{pack}` "
+        f"pack is active. Route every output to the workspace per the skill — "
+        f"`wiki/` pages, `figures/` PNGs, `data/` tables — and finish with a "
+        f"one-line summary naming what you wrote."
+    )
+
+
+def list_queued_runs(workspace: Path) -> list[dict[str, Any]]:
+    """Read ``.workbench/pack-runs/*.json`` with status queued/accepted."""
+    d = runs_dir(workspace)
+    if not d.is_dir():
+        return []
+    out: list[dict[str, Any]] = []
+    try:
+        paths = sorted(d.glob("*.json"))
+    except OSError:
+        return []
+    for p in paths:
+        try:
+            raw = json.loads(p.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError, UnicodeDecodeError):
+            continue
+        if not isinstance(raw, dict):
+            continue
+        status = str(raw.get("status") or "").strip()
+        if status not in QUEUED_STATUSES:
+            continue
+        rid = str(raw.get("run_id") or p.stem).strip()
+        if not rid:
+            continue
+        rec = dict(raw)
+        rec["run_id"] = rid
+        rec["_path"] = str(p)
+        out.append(rec)
+    return out
+
+
+def write_run_status(
+    workspace: Path,
+    run_id: str,
+    status: str,
+    **extra: Any,
+) -> dict[str, Any] | None:
+    """Atomically update a pack-run JSON's status (+ optional fields)."""
+    path = run_path(workspace, run_id)
+    if not path.is_file():
+        return None
+    try:
+        rec = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError, UnicodeDecodeError):
+        return None
+    if not isinstance(rec, dict):
+        return None
+    rec["status"] = status
+    for k, v in extra.items():
+        if v is None:
+            rec.pop(k, None)
+        else:
+            rec[k] = v
+    path.parent.mkdir(parents=True, exist_ok=True)
+    atomicio.write_json_atomic(path, rec)
+    return rec
+
+
+def _inflight(app: Any) -> set[str]:
+    s = app.get("pack_run_inflight")
+    if s is None:
+        s = set()
+        app["pack_run_inflight"] = s
+    return s
+
+
+def _default_dispatch_fn() -> DispatchFn:
+    """Lazy import — daemon imports this module at load time."""
+
+    async def _dispatch(app: Any, **kwargs: Any) -> Any:
+        from . import daemon as _daemon
+
+        return await _daemon._dispatch_chat(
+            app,
+            ws=None,
+            text=kwargs["text"],
+            input_excerpt=kwargs.get("input_excerpt"),
+            run_id=kwargs.get("run_id"),
+        )
+
+    return _dispatch
+
+
+def _error_surface(app: Any, run_id: str):
+    from . import daemon as _daemon
+
+    return _daemon._make_dispatch_error_surface(app, run_id)
+
+
+def _validate_run(
+    workspace: Path, rec: Mapping[str, Any],
+) -> tuple[str, str, str, str] | str:
+    """Return (pack, action, rel, skill) or an error note string."""
+    pack = str(rec.get("pack") or "").strip()
+    action = str(rec.get("action") or "").strip()
+    rel = str(rec.get("path") or "").strip()
+    if not pack or not action or not rel:
+        return "pack, action, and path are required on the run record"
+    pack_rec = packstore.get_pack(workspace, pack)
+    if pack_rec is None:
+        return f"pack not found: {pack}"
+    if not pack_rec.get("enabled"):
+        return (
+            f"pack '{pack}' is not active — activate it in Settings → Packs"
+        )
+    skill = f"{pack}-{action}"
+    if skillkit.get_skill(workspace, skill) is None:
+        return f"pack skill not found: {skill}"
+    return pack, action, rel, skill
+
+
+async def drain_once(
+    app: Any,
+    *,
+    dispatch_fn: DispatchFn | None = None,
+) -> dict[str, Any]:
+    """Seat each queued pack-run as a fire-and-forget rail chat.
+
+    Returns ``{drained, skipped, errors}`` summary lists/counts.
+    Deduplicates via ``app['pack_run_inflight']``. On validation failure
+    marks the JSON ``failed`` with a ``note``. On successful seat marks
+    ``running`` and spawns a background task; when the task finishes the
+    JSON becomes ``done`` or ``failed``.
+    """
+    workspace = Path(app["workspace"])
+    dispatch = dispatch_fn or _default_dispatch_fn()
+    inflight = _inflight(app)
+
+    drained: list[str] = []
+    skipped: list[str] = []
+    errors: list[dict[str, str]] = []
+
+    queued = await asyncio.to_thread(list_queued_runs, workspace)
+    for rec in queued:
+        run_id = str(rec["run_id"])
+        if run_id in inflight:
+            skipped.append(run_id)
+            continue
+
+        # Re-check disk status (another drain / race).
+        try:
+            path = run_path(workspace, run_id)
+            fresh = json.loads(path.read_text(encoding="utf-8"))
+            st = str(fresh.get("status") or "")
+            if st not in QUEUED_STATUSES:
+                skipped.append(run_id)
+                continue
+        except (OSError, json.JSONDecodeError, UnicodeDecodeError):
+            skipped.append(run_id)
+            continue
+
+        validated = _validate_run(workspace, rec)
+        if isinstance(validated, str):
+            note = validated
+            await asyncio.to_thread(
+                write_run_status, workspace, run_id, "failed", note=note,
+            )
+            errors.append({"run_id": run_id, "error": note})
+            continue
+
+        pack, action, rel, _skill = validated
+        prompt = build_pack_prompt(pack, action, rel)
+        excerpt = f"{pack}:{action} {Path(rel).name}"
+
+        inflight.add(run_id)
+        try:
+            await asyncio.to_thread(
+                write_run_status, workspace, run_id, "running",
+            )
+        except Exception as e:  # noqa: BLE001
+            inflight.discard(run_id)
+            note = f"failed to mark running: {e}"
+            errors.append({"run_id": run_id, "error": note})
+            continue
+
+        async def _runner(
+            rid: str = run_id,
+            text: str = prompt,
+            input_excerpt: str = excerpt,
+            p: str = pack,
+            a: str = action,
+            vault: str = rel,
+        ) -> None:
+            async def _tag_run() -> None:
+                await asyncio.sleep(0)
+                runs = app.get("runs") or {}
+                r = runs.get(rid)
+                if r is not None:
+                    r["kind"] = f"pack:{p}:{a}"
+                    r["vault_path"] = vault
+
+            asyncio.create_task(_tag_run())
+            try:
+                await dispatch(
+                    app,
+                    text=text,
+                    input_excerpt=input_excerpt,
+                    run_id=rid,
+                )
+            except Exception:  # noqa: BLE001
+                log.exception("pack-run drain %s crashed", rid)
+                raise
+
+        def _on_done(task: asyncio.Task, rid: str = run_id) -> None:
+            inflight.discard(rid)
+            try:
+                exc = task.exception()
+            except (asyncio.CancelledError, asyncio.InvalidStateError):
+                try:
+                    write_run_status(
+                        workspace, rid, "failed",
+                        note="dispatch cancelled",
+                    )
+                except Exception:  # noqa: BLE001
+                    pass
+                return
+            try:
+                if exc is None:
+                    write_run_status(workspace, rid, "done")
+                else:
+                    write_run_status(
+                        workspace, rid, "failed",
+                        note=f"{type(exc).__name__}: {exc}",
+                    )
+            except Exception:  # noqa: BLE001
+                log.exception("pack-run status update failed for %s", rid)
+            # Also surface to the rail (same as handle_pack_action).
+            try:
+                _error_surface(app, rid)(task)
+            except Exception:  # noqa: BLE001
+                pass
+
+        try:
+            task = asyncio.create_task(_runner())
+            task.add_done_callback(_on_done)
+            drained.append(run_id)
+        except Exception as e:  # noqa: BLE001
+            inflight.discard(run_id)
+            note = f"failed to start dispatch: {e}"
+            await asyncio.to_thread(
+                write_run_status, workspace, run_id, "failed", note=note,
+            )
+            errors.append({"run_id": run_id, "error": note})
+
+    return {
+        "drained": drained,
+        "skipped": skipped,
+        "errors": errors,
+        "drained_count": len(drained),
+        "skipped_count": len(skipped),
+        "error_count": len(errors),
+    }
+
+
+async def pack_run_drain_loop(app: Any) -> None:
+    """Background: every ~4s, drain queued pack-runs if the dir exists."""
+    while True:
+        try:
+            await asyncio.sleep(POLL_INTERVAL_S)
+            ws = Path(app["workspace"])
+            if not runs_dir(ws).is_dir():
+                continue
+            await drain_once(app)
+        except asyncio.CancelledError:
+            return
+        except Exception:  # noqa: BLE001
+            log.exception("pack-run drain loop iteration failed")
+
+
+def kick_drain(app: Any) -> None:
+    """Schedule an immediate drain_once on the running loop (best-effort)."""
+    try:
+        loop = asyncio.get_running_loop()
+    except RuntimeError:
+        return
+
+    async def _go() -> None:
+        try:
+            await drain_once(app)
+        except Exception:  # noqa: BLE001
+            log.exception("kicked pack-run drain failed")
+
+    loop.create_task(_go())
diff --git a/src/switchbay/protocol.py b/src/switchbay/protocol.py
index 460975f..0a88424 100644
--- a/src/switchbay/protocol.py
+++ b/src/switchbay/protocol.py
@@ -228,6 +228,37 @@ def files_changed() -> dict[str, Any]:
     return custom({"type": "files_changed"})
 
 
+def graph_progress(
+    stage: str,
+    message: str,
+    *,
+    workspace: str | None = None,
+    current: int | None = None,
+    total: int | None = None,
+    done: bool = False,
+) -> dict[str, Any]:
+    """Progress for a background graph cache sync.
+
+    Stages (advisory): ``cache`` → ``types`` → ``decks`` → ``pages``
+    → ``ready``. Frontend shows a non-blocking banner so large
+    workspaces never white-screen while enrich runs off the hot path.
+    ``done=True`` on the terminal ``ready`` (or error) frame.
+    """
+    payload: dict[str, Any] = {
+        "type": "graph_progress",
+        "stage": stage,
+        "message": message,
+        "done": bool(done),
+    }
+    if workspace:
+        payload["workspace"] = workspace
+    if current is not None:
+        payload["current"] = int(current)
+    if total is not None:
+        payload["total"] = int(total)
+    return custom(payload)
+
+
 def artifact(
     kind: str, label: str, selection: dict[str, Any] | None = None,
 ) -> dict[str, Any]:
diff --git a/src/switchbay/workspaces.py b/src/switchbay/workspaces.py
index e8022bd..ac5fc4e 100644
--- a/src/switchbay/workspaces.py
+++ b/src/switchbay/workspaces.py
@@ -63,28 +63,75 @@ def _path() -> Path:
     return config_dir() / "workspaces.json"
 
 
-# ── Home-directory sandbox (cross-platform) ──────────────────────────
-# Hardcoded safety net: workspaces are restricted to paths inside the
-# current user's home (`~`). On macOS that's /Users/<u>, on Linux
-# /home/<u>, on Windows C:\Users\<u>. The risk: cebridge, fileops, and
-# cebridge.setup() all run subprocesses with cwd=workspace and write
-# to it. A bad workspace value (`/etc`, `/`, `/Volumes/SystemDisk`,
-# etc.) would let the daemon's file-ops endpoints touch system files.
-# We refuse anywhere outside the user's home.
+# ── Workspace-path sandbox (cross-platform) ───────────────────────────
+# Stage-5 home rule: workspaces must live under a small set of allowed
+# roots so cebridge / fileops / setup never get a cwd of `/`, `/etc`,
+# etc. Default root is `$HOME` (macOS `/Users/<u>`, Linux `/home/<u>`,
+# Windows `C:\Users\<u>`). Extra roots:
+#   - `/workspace` when that directory exists (Grok Bot / agent-box
+#     scratch — corpora like `/workspace/ce-cb-biocure` live there;
+#     bind-mounting under `~/Workspaces` is no longer required).
+#   - `SWITCHBAY_WORKSPACE_ROOTS` (os.pathsep-separated, expanduser +
+#     resolve; missing / non-dir entries skipped).
+# Membership uses resolve() so `..` and symlink escapes still fail.
+
+def allowed_workspace_roots() -> list[Path]:
+    """Resolved directories a workspace path may live under.
+
+    Always includes ``Path.home()``. Adds ``/workspace`` when present,
+    then any existing directories from ``SWITCHBAY_WORKSPACE_ROOTS``.
+    """
+    roots: list[Path] = []
+    seen: set[str] = set()
+
+    def _add(raw: Path | str) -> None:
+        try:
+            p = Path(raw).expanduser().resolve()
+        except OSError:
+            return
+        if not p.is_dir():
+            return
+        key = str(p)
+        if key in seen:
+            return
+        seen.add(key)
+        roots.append(p)
+
+    _add(Path.home())
+    _add(Path("/workspace"))
+    extra = os.environ.get("SWITCHBAY_WORKSPACE_ROOTS") or ""
+    for part in extra.split(os.pathsep):
+        part = part.strip()
+        if part:
+            _add(part)
+    return roots
+
 
 def is_within_home(path: Path) -> bool:
+    """True if ``path`` resolves under any :func:`allowed_workspace_roots`.
+
+    Name kept for call-site compatibility (stage-5 "home" sandbox);
+    prefer thinking of it as "allowed workspace path".
+    """
     try:
         target = Path(path).expanduser().resolve()
-        home = Path.home().resolve()
-        target.relative_to(home)
-        return True
-    except (ValueError, OSError):
+    except OSError:
         return False
+    for root in allowed_workspace_roots():
+        try:
+            target.relative_to(root)
+            return True
+        except ValueError:
+            continue
+    return False
 
 
 def home_label() -> str:
-    """Human-readable home root, for error messages."""
-    return str(Path.home())
+    """Human-readable allowed roots for error messages ("a or b")."""
+    roots = allowed_workspace_roots()
+    if not roots:
+        return str(Path.home())
+    return " or ".join(str(r) for r in roots)
 
 
 def load() -> dict[str, Any]:
@@ -101,10 +148,11 @@ def load() -> dict[str, Any]:
     active = data.get("active")
     if not isinstance(raw_paths, list):
         raw_paths = []
-    # Defense in depth: silently drop registry entries that aren't
-    # inside $HOME — protects against an older binary having added
-    # something dangerous (e.g. /etc) before the guard existed, or
-    # against a hand-edited workspaces.json.
+    # Defense in depth: silently drop registry entries outside the
+    # allowed roots (home, optional /workspace, SWITCHBAY_WORKSPACE_ROOTS)
+    # — protects against an older binary having added something
+    # dangerous (e.g. /etc) before the guard existed, or against a
+    # hand-edited workspaces.json.
     safe_paths: list[str] = []
     for entry in raw_paths:
         s = str(entry)
@@ -114,7 +162,7 @@ def load() -> dict[str, Any]:
     # Permit `active` to be a path that's NOT in `paths` — the daemon
     # may be serving an unregistered workspace (the CLI-supplied
     # cwd) the user hasn't explicitly added to the dropdown. Only
-    # require that it lives inside $HOME for safety.
+    # require that it lives under an allowed root for safety.
     if safe_active and not is_within_home(Path(safe_active)):
         safe_active = safe_paths[0] if safe_paths else None
     cleaned = {"paths": safe_paths, "active": safe_active}
@@ -141,8 +189,9 @@ def resolve_path(
 ) -> Path:
     """Resolve a workspace path from HTTP/tool input.
 
-    Expands ``~``, requires the path under ``$HOME``, and optionally
-    that it is an existing directory. Raises ``OutsideHomeError`` or
+    Expands ``~``, requires the path under an allowed workspace root
+    (see :func:`allowed_workspace_roots`), and optionally that it is
+    an existing directory. Raises ``OutsideHomeError`` or
     ``ValueError`` on bad input.
     """
     raw = (path_str or "").strip()
@@ -167,7 +216,7 @@ class OutsideHomeError(ValueError):
 def register(path: Path, set_active: bool = True) -> dict[str, Any]:
     """Add path to registry (no-op if already present); optionally make active.
 
-    Raises `OutsideHomeError` if `path` resolves outside the user's home.
+    Raises `OutsideHomeError` if `path` resolves outside allowed roots.
     """
     if not is_within_home(path):
         raise OutsideHomeError(
@@ -395,9 +444,9 @@ def cleanup_migrated_source(old: Path, new: Path) -> str | dict[str, Any]:
 
 
 def set_active_only(path: Path) -> dict[str, Any]:
-    """Validate the CLI-supplied cwd lives inside $HOME, but DON'T
-    touch the registry's `active` field — that's reserved for the
-    user's explicit picks via the workspace switcher. The daemon
+    """Validate the CLI-supplied cwd lives under an allowed root, but
+    DON'T touch the registry's `active` field — that's reserved for
+    the user's explicit picks via the workspace switcher. The daemon
     keeps its own `app["workspace"]` for the path it actually
     serves; the registry stays a record of user intent only.
 
diff --git a/tests/unit/test_ce_viewer_supervisor.py b/tests/unit/test_ce_viewer_supervisor.py
new file mode 100644
index 0000000..62a229e
--- /dev/null
+++ b/tests/unit/test_ce_viewer_supervisor.py
@@ -0,0 +1,138 @@
+"""CE viewer supervisor: bind tracking + retarget-on-mistarget."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from switchbay import ce_viewer_supervisor as ce
+
+
+def test_bound_workspace_roundtrip(tmp_path, monkeypatch):
+    monkeypatch.setattr(ce, "_state_dir", lambda: tmp_path)
+    assert ce.bound_workspace() is None
+    ws = (tmp_path / "ws-a").resolve()
+    ws.mkdir()
+    ce._set_bound_workspace(ws)
+    assert ce.bound_workspace() == ws
+    ce._set_bound_workspace(None)
+    assert ce.bound_workspace() is None
+
+
+def test_start_idempotent_same_workspace(tmp_path, monkeypatch):
+    monkeypatch.setattr(ce, "_state_dir", lambda: tmp_path)
+    ws = (tmp_path / "ws-bio").resolve()
+    ws.mkdir()
+    (ws / "wiki").mkdir()
+    ce._set_bound_workspace(ws)
+    monkeypatch.setattr(ce, "is_healthy", lambda **_: True)
+    monkeypatch.setattr(ce, "_read_pid", lambda: 42)
+
+    out = ce.start(ws)
+    assert out["ok"] is True
+    assert out["already_running"] is True
+    assert out["retargeted"] is False
+    assert out["workspace"] == str(ws)
+
+
+def test_start_retargets_when_bound_differs(tmp_path, monkeypatch):
+    monkeypatch.setattr(ce, "_state_dir", lambda: tmp_path)
+    old = (tmp_path / "ws-old").resolve()
+    new = (tmp_path / "ws-new").resolve()
+    old.mkdir()
+    new.mkdir()
+    (new / "wiki").mkdir()
+    ce._set_bound_workspace(old)
+
+    calls: list[str] = []
+
+    monkeypatch.setattr(ce, "is_healthy", lambda **_: calls.count("stop") == 0)
+    monkeypatch.setattr(ce, "_read_pid", lambda: None)
+
+    def fake_stop():
+        calls.append("stop")
+        ce._set_bound_workspace(None)
+        return {"ok": True, "stopped": True, "pid": 1}
+
+    monkeypatch.setattr(ce, "stop", fake_stop)
+    # Avoid real spawn: stub Popen + health becoming true after stop.
+    class FakeProc:
+        pid = 99
+
+        def poll(self):
+            return None
+
+    spawned: list[list[str]] = []
+
+    def fake_popen(argv, **kwargs):
+        spawned.append(list(argv))
+        calls.append("spawn")
+        return FakeProc()
+
+    # After stop, is_healthy flips; after spawn, health loop should succeed.
+    health_checks = {"n": 0}
+
+    def health(**_):
+        # Before stop: True (triggers retarget). After stop: False until spawn.
+        if "stop" not in calls:
+            return True
+        if "spawn" not in calls:
+            return False
+        health_checks["n"] += 1
+        return health_checks["n"] >= 1
+
+    monkeypatch.setattr(ce, "is_healthy", health)
+    monkeypatch.setattr(ce.subprocess, "Popen", fake_popen)
+    monkeypatch.setattr(ce, "bundle_ready", lambda _w: True)
+    monkeypatch.setattr(
+        ce.cebridge,
+        "ce_root",
+        lambda: tmp_path / "ce-root",
+    )
+    (tmp_path / "ce-root" / "scripts").mkdir(parents=True)
+    (tmp_path / "ce-root" / "scripts" / "viewer.sh").write_text("#!/bin/bash\n")
+    (tmp_path / "ce-root" / "scripts" / "viewer_server.py").write_text("#x\n")
+    monkeypatch.setattr(ce.cebridge, "has_wiki", lambda _w: True)
+    monkeypatch.setattr(
+        ce.cebridge,
+        "output_dir",
+        lambda w: tmp_path / "cache" / Path(w).name,
+    )
+    cache = tmp_path / "cache" / new.name
+    cache.mkdir(parents=True)
+    (cache / "index.html").write_text("<html></html>")
+    (cache / "data.json").write_text("{}")
+
+    out = ce.start(new)
+    assert "stop" in calls
+    assert "spawn" in calls
+    assert out["ok"] is True
+    assert out["retargeted"] is True
+    assert out["already_running"] is False
+    assert out["mode"] == "serve_only"
+    assert out["workspace"] == str(new)
+    assert ce.bound_workspace() == new
+    # Serve-only argv must not invoke viewer.sh (no forced rebuild).
+    assert spawned and "viewer_server.py" in spawned[0][-4]
+    assert "viewer.sh" not in " ".join(spawned[0])
+
+
+def test_spawn_argv_build_when_cache_missing(tmp_path, monkeypatch):
+    monkeypatch.setattr(
+        ce.cebridge,
+        "ce_root",
+        lambda: tmp_path / "ce-root",
+    )
+    (tmp_path / "ce-root" / "scripts").mkdir(parents=True)
+    (tmp_path / "ce-root" / "scripts" / "viewer.sh").write_text("x")
+    (tmp_path / "ce-root" / "scripts" / "viewer_server.py").write_text("x")
+    monkeypatch.setattr(
+        ce.cebridge,
+        "output_dir",
+        lambda w: tmp_path / "cache" / Path(w).name,
+    )
+    ws = tmp_path / "ws"
+    ws.mkdir()
+    argv, mode = ce._spawn_argv(ws, 8766)
+    assert mode == "build_and_serve"
+    assert argv[0] == "bash"
+    assert argv[2] == "serve"
diff --git a/tests/unit/test_cebridge_ensure_venv.py b/tests/unit/test_cebridge_ensure_venv.py
index eca146a..8870e70 100644
--- a/tests/unit/test_cebridge_ensure_venv.py
+++ b/tests/unit/test_cebridge_ensure_venv.py
@@ -165,3 +165,66 @@ async def fake_exec(*_a, **_k):
     data = await cebridge.build(wiki_ws, ensure_env=False)
     assert data is not None
     ensure.assert_not_awaited()
+
+
+@pytest.mark.asyncio
+async def test_build_uses_workspace_venv_python_for_wiki_render(
+    wiki_ws: Path, monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """wiki_render must run under workspace .venv (kuzu), not sys.executable."""
+    py = wiki_ws / ".venv" / "bin" / "python"
+    py.parent.mkdir(parents=True)
+    py.write_text("#!/bin/sh\n", encoding="utf-8")
+    py.chmod(0o755)
+
+    scripts = wiki_ws / "fake-ce" / "scripts"
+    scripts.mkdir(parents=True)
+    render_py = scripts / "wiki_render.py"
+    render_py.write_text("# fake\n", encoding="utf-8")
+    monkeypatch.setattr(cebridge, "ce_root", lambda: wiki_ws / "fake-ce")
+
+    out_dir = wiki_ws / "cache-out"
+    out_dir.mkdir()
+    monkeypatch.setattr(cebridge, "output_dir", lambda _ws: out_dir)
+
+    captured: dict = {}
+
+    async def fake_exec(*argv, **kwargs):
+        captured["argv"] = argv
+        (out_dir / "data.json").write_text(
+            '{"nodes":[{"id":"a","type":"note"}],"edges":[{"source":"a","target":"a"}],'
+            '"pages":{},"palette":{}}',
+            encoding="utf-8",
+        )
+        proc = MagicMock()
+        proc.returncode = 0
+        proc.communicate = AsyncMock(return_value=(b"", b""))
+        return proc
+
+    monkeypatch.setattr(
+        __import__("asyncio"), "create_subprocess_exec", fake_exec,
+    )
+    monkeypatch.setattr(cebridge, "resync_types_from_disk", lambda *_a, **_k: None)
+    monkeypatch.setattr(cebridge, "inject_deck_nodes", lambda *_a, **_k: None)
+    monkeypatch.setattr(cebridge, "_override_palette", lambda *_a, **_k: None)
+    monkeypatch.setattr(cebridge, "_backfill_unclassified_types", lambda *_a, **_k: None)
+    monkeypatch.setattr("switchbay.wiki_sync.inject_on_disk_pages", lambda *_a, **_k: 0)
+
+    data = await cebridge.build(wiki_ws, ensure_env=False)
+    assert data is not None
+    argv = captured["argv"]
+    assert argv[0] == str(py), argv
+    assert argv[1] == str(render_py)
+    assert argv[2] == "build"
+    assert len(data.get("edges") or []) == 1
+
+
+def test_script_python_prefers_workspace_venv(wiki_ws: Path) -> None:
+    py = wiki_ws / ".venv" / "bin" / "python"
+    py.parent.mkdir(parents=True)
+    py.write_text("x", encoding="utf-8")
+    assert cebridge._script_python(wiki_ws) == [str(py)]
+
+
+def test_script_python_falls_back_to_uv_run(wiki_ws: Path) -> None:
+    assert cebridge._script_python(wiki_ws) == ["uv", "run", "python3"]
diff --git a/tests/unit/test_core_skills_status.py b/tests/unit/test_core_skills_status.py
new file mode 100644
index 0000000..cc5ba84
--- /dev/null
+++ b/tests/unit/test_core_skills_status.py
@@ -0,0 +1,39 @@
+"""C1 combined core-skills status shape."""
+
+from __future__ import annotations
+
+from switchbay import core_skills
+
+
+def test_status_shape(monkeypatch):
+    from switchbay import ce_viewer_supervisor as ce
+    from switchbay import okstratr_supervisor as oks
+
+    monkeypatch.setattr(
+        ce,
+        "contract_slice",
+        lambda _ws=None: {
+            "state": "stopped",
+            "url": "http://127.0.0.1:8766",
+            "detail": "x",
+        },
+    )
+    monkeypatch.setattr(
+        oks,
+        "contract_slice",
+        lambda: {
+            "state": "healthy",
+            "url": "http://127.0.0.1:8767",
+            "detail": "up",
+        },
+    )
+    monkeypatch.setattr(
+        ce,
+        "wiki_build_slice",
+        lambda: {"state": "idle", "pages": None, "detail": ""},
+    )
+    out = core_skills.status()
+    assert set(out) == {"ce", "okstratr", "wiki_build"}
+    assert out["ce"]["state"] == "stopped"
+    assert out["okstratr"]["state"] == "healthy"
+    assert out["wiki_build"]["state"] == "idle"
diff --git a/tests/unit/test_embed_proxy.py b/tests/unit/test_embed_proxy.py
new file mode 100644
index 0000000..37d3a46
--- /dev/null
+++ b/tests/unit/test_embed_proxy.py
@@ -0,0 +1,238 @@
+"""Phase 4a: same-origin embed reverse-proxy allowlist + routing."""
+
+from __future__ import annotations
+
+import pytest
+from aiohttp import web
+from aiohttp.test_utils import TestClient, TestServer
+
+from switchbay import embed_proxy
+
+
+def test_loopback_hosts_accepted():
+    assert embed_proxy.is_loopback_host("127.0.0.1")
+    assert embed_proxy.is_loopback_host("localhost")
+    assert embed_proxy.is_loopback_host("::1")
+    assert embed_proxy.is_loopback_host("[::1]")
+
+
+def test_non_loopback_hosts_rejected():
+    assert not embed_proxy.is_loopback_host("example.com")
+    assert not embed_proxy.is_loopback_host("8.8.8.8")
+    assert not embed_proxy.is_loopback_host("10.0.0.1")
+    assert not embed_proxy.is_loopback_host("")
+
+
+def test_assert_loopback_upstream_ok():
+    assert embed_proxy.assert_loopback_upstream("http://127.0.0.1:8766") == (
+        "http://127.0.0.1:8766"
+    )
+    assert embed_proxy.assert_loopback_upstream("http://localhost:8767/") == (
+        "http://localhost:8767"
+    )
+
+
+def test_assert_loopback_upstream_rejects_remote():
+    with pytest.raises(embed_proxy.UpstreamNotLoopback):
+        embed_proxy.assert_loopback_upstream("http://evil.example:8766")
+    with pytest.raises(embed_proxy.UpstreamNotLoopback):
+        embed_proxy.assert_loopback_upstream("http://192.168.1.5:8766")
+
+
+def test_match_embed_prefix():
+    assert embed_proxy.match_embed_prefix("/embed/ce") == ("/embed/ce", "/")
+    assert embed_proxy.match_embed_prefix("/embed/ce/") == ("/embed/ce", "/")
+    assert embed_proxy.match_embed_prefix("/embed/ce/api/health") == (
+        "/embed/ce",
+        "/api/health",
+    )
+    assert embed_proxy.match_embed_prefix("/embed/okstratr/observer/") == (
+        "/embed/okstratr",
+        "/observer/",
+    )
+    assert embed_proxy.match_embed_prefix("/api/health") is None
+    assert embed_proxy.match_embed_prefix("/embed/other") is None
+
+
+def test_build_upstream_url_defaults(monkeypatch):
+    monkeypatch.delenv("SWITCHBAY_CE_UPSTREAM", raising=False)
+    monkeypatch.delenv("SWITCHBAY_OKSTRATR_UPSTREAM", raising=False)
+    assert embed_proxy.build_upstream_url("/embed/ce", "/api/x", "") == (
+        "http://127.0.0.1:8766/api/x"
+    )
+    assert embed_proxy.build_upstream_url(
+        "/embed/okstratr", "/observer/", "host=x"
+    ) == "http://127.0.0.1:8767/observer/?host=x"
+
+
+def test_filter_request_headers_injects_host():
+    h = embed_proxy.filter_request_headers(
+        {"Accept": "application/json", "Host": "127.0.0.1:8765",
+         "X-CE-Host": "forged"},
+        host_header=embed_proxy.HOST_HEADER_CE,
+        host_value="switchbay",
+    )
+    assert h["X-CE-Host"] == "switchbay"
+    assert "Host" not in h
+    assert h["Accept"] == "application/json"
+
+
+def test_upstream_allowed_allowlist(monkeypatch):
+    monkeypatch.delenv("SWITCHBAY_CE_UPSTREAM", raising=False)
+    monkeypatch.delenv("SWITCHBAY_OKSTRATR_UPSTREAM", raising=False)
+    assert embed_proxy.upstream_allowed("http://127.0.0.1:8766/foo")
+    assert embed_proxy.upstream_allowed("http://127.0.0.1:8767/bar")
+    assert not embed_proxy.upstream_allowed("http://127.0.0.1:9999/x")
+    assert not embed_proxy.upstream_allowed("http://example.com/")
+
+
+def test_env_override_must_still_be_loopback(monkeypatch):
+    monkeypatch.setenv("SWITCHBAY_CE_UPSTREAM", "http://evil.example:8766")
+    with pytest.raises(embed_proxy.UpstreamNotLoopback):
+        embed_proxy.embed_targets()
+
+
+@pytest.mark.asyncio
+async def test_proxy_forwards_with_host_header(monkeypatch):
+    """End-to-end: embed proxy hits a loopback stub and injects X-*-Host."""
+    seen: dict[str, str] = {}
+
+    async def upstream_handler(request: web.Request) -> web.Response:
+        seen["path"] = request.path
+        seen["x_ce"] = request.headers.get("X-CE-Host", "")
+        seen["x_ok"] = request.headers.get("X-Okstratr-Host", "")
+        return web.json_response({"ok": True, "path": request.path})
+
+    up_app = web.Application()
+    up_app.router.add_get("/api/health", upstream_handler)
+    up_app.router.add_get("/observer/", upstream_handler)
+    up_server = TestServer(up_app)
+    await up_server.start_server()
+    try:
+        # Force loopback literal — TestServer may report 0.0.0.0.
+        base = f"http://127.0.0.1:{up_server.port}"
+        monkeypatch.setenv("SWITCHBAY_CE_UPSTREAM", base)
+        monkeypatch.setenv("SWITCHBAY_OKSTRATR_UPSTREAM", base)
+
+        app = web.Application()
+        embed_proxy.register_routes(app)
+        async with TestClient(TestServer(app)) as client:
+            r = await client.get("/embed/ce/api/health")
+            assert r.status == 200
+            body = await r.json()
+            assert body["ok"] is True
+            assert seen["path"] == "/api/health"
+            assert seen["x_ce"] == "switchbay"
+
+            seen.clear()
+            r2 = await client.get("/embed/okstratr/observer/")
+            assert r2.status == 200
+            assert seen["path"] == "/observer/"
+            assert seen["x_ok"] == "switchbay"
+    finally:
+        await up_server.close()
+
+
+@pytest.mark.asyncio
+async def test_proxy_rejects_if_upstream_env_not_loopback(monkeypatch):
+    monkeypatch.setenv("SWITCHBAY_CE_UPSTREAM", "http://203.0.113.1:8766")
+    app = web.Application()
+    embed_proxy.register_routes(app)
+    async with TestClient(TestServer(app)) as client:
+        r = await client.get("/embed/ce/api/health")
+        assert r.status == 502
+        data = await r.json()
+        assert "loopback" in data["error"].lower()
+
+def test_client_accepts_gzip():
+    assert embed_proxy.client_accepts_gzip({"Accept-Encoding": "gzip, deflate"})
+    assert embed_proxy.client_accepts_gzip({"Accept-Encoding": "br, gzip;q=1.0"})
+    assert not embed_proxy.client_accepts_gzip({"Accept-Encoding": "identity"})
+    assert not embed_proxy.client_accepts_gzip({"Accept-Encoding": "gzip;q=0"})
+    assert not embed_proxy.client_accepts_gzip({})
+
+
+def test_is_compressible_payload():
+    assert embed_proxy.is_compressible_payload(
+        "application/json", "/data.json", size=5000
+    )
+    assert embed_proxy.is_compressible_payload(
+        "application/json; charset=utf-8", "/x", size=5000
+    )
+    assert embed_proxy.is_compressible_payload(None, "/static/main.js", size=5000)
+    assert not embed_proxy.is_compressible_payload(
+        "application/json", "/data.json", size=100
+    )
+    assert not embed_proxy.is_compressible_payload(
+        "image/png", "/logo.png", size=500_000
+    )
+
+
+def test_maybe_gzip_body_compresses_json():
+    raw = (b'{"n":' + b'"' + b"x" * 4000 + b'"}')
+    headers = {"Content-Type": "application/json", "Cache-Control": "no-store"}
+    body, out = embed_proxy.maybe_gzip_body(
+        raw, headers, accept_gzip=True, path="/data.json"
+    )
+    assert out.get("Content-Encoding") == "gzip"
+    assert "Accept-Encoding" in out.get("Vary", "")
+    assert len(body) < len(raw)
+    import gzip as gz
+    assert gz.decompress(body) == raw
+
+
+def test_maybe_gzip_body_skips_when_client_rejects():
+    raw = b"{" + b"x" * 4000 + b"}"
+    headers = {"Content-Type": "application/json"}
+    body, out = embed_proxy.maybe_gzip_body(
+        raw, headers, accept_gzip=False, path="/data.json"
+    )
+    assert "Content-Encoding" not in out
+    assert body == raw
+
+
+@pytest.mark.asyncio
+async def test_proxy_gzips_large_json(monkeypatch):
+    """Browser Accept-Encoding: gzip → proxy compresses upstream plain JSON."""
+    raw = b'{"pages":' + (b"[" + b'"p",' * 2000 + b'null]') + b"}"
+
+    async def upstream_handler(request: web.Request) -> web.Response:
+        return web.Response(
+            status=200,
+            body=raw,
+            headers={"Content-Type": "application/json"},
+        )
+
+    up_app = web.Application()
+    up_app.router.add_get("/data.json", upstream_handler)
+    up_server = TestServer(up_app)
+    await up_server.start_server()
+    try:
+        base = f"http://127.0.0.1:{up_server.port}"
+        monkeypatch.setenv("SWITCHBAY_CE_UPSTREAM", base)
+        monkeypatch.setenv("SWITCHBAY_OKSTRATR_UPSTREAM", base)
+
+        app = web.Application()
+        embed_proxy.register_routes(app)
+        async with TestClient(TestServer(app)) as client:
+            r = await client.get(
+                "/embed/ce/data.json",
+                headers={"Accept-Encoding": "gzip"},
+            )
+            assert r.status == 200
+            assert r.headers.get("Content-Encoding") == "gzip"
+            import gzip as gz
+            buf = await r.read()
+            # aiohttp TestClient may auto-decompress; prefer raw if encoded.
+            if r.headers.get("Content-Encoding") == "gzip":
+                # TestClient keeps encoding header; body may already be raw.
+                try:
+                    decoded = gz.decompress(buf)
+                except OSError:
+                    decoded = buf  # already decompressed by client
+            else:
+                decoded = buf
+            assert decoded == raw
+            assert len(buf) < len(raw) or decoded == raw
+    finally:
+        await up_server.close()
diff --git a/tests/unit/test_graph_fast_path.py b/tests/unit/test_graph_fast_path.py
new file mode 100644
index 0000000..331609e
--- /dev/null
+++ b/tests/unit/test_graph_fast_path.py
@@ -0,0 +1,81 @@
+"""Fast /api/graph/data path: serve data.json without FS enrich."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from switchbay import cebridge, protocol
+
+
+def test_read_cached_default_skips_enrich(tmp_path: Path, monkeypatch) -> None:
+    wiki = tmp_path / "wiki"
+    wiki.mkdir()
+    (wiki / "a.md").write_text("---\ntitle: A\ntype: note\n---\n\nHi.\n", encoding="utf-8")
+    out = tmp_path / "cache-out"
+    out.mkdir()
+    (out / "data.json").write_text(
+        json.dumps({
+            "nodes": [{"id": "a", "type": "unclassified", "title": "A", "path": "a.md"}],
+            "edges": [],
+            "pages": {"a": {"id": "a", "type": "unclassified", "title": "A", "path": "a.md"}},
+            "palette": {"note": "#000"},
+        }),
+        encoding="utf-8",
+    )
+    monkeypatch.setattr(cebridge, "has_wiki", lambda _ws: True)
+    monkeypatch.setattr(cebridge, "output_dir", lambda _ws: out)
+
+    called: list[str] = []
+    monkeypatch.setattr(
+        cebridge, "resync_types_from_disk",
+        lambda *_a, **_k: called.append("types") or 0,
+    )
+    monkeypatch.setattr(
+        cebridge, "inject_deck_nodes",
+        lambda *_a, **_k: called.append("decks") or 0,
+    )
+    monkeypatch.setattr(
+        "switchbay.wiki_sync.inject_on_disk_pages",
+        lambda *_a, **_k: called.append("pages") or 0,
+    )
+
+    data = cebridge.read_cached(tmp_path)  # enrich=False default
+    assert data is not None
+    assert called == []
+    assert "a" in data["pages"]
+
+    data2 = cebridge.read_cached(tmp_path, enrich=True)
+    assert data2 is not None
+    assert called == ["types", "decks", "pages"]
+
+
+def test_enrich_from_disk_returns_counts(tmp_path: Path, monkeypatch) -> None:
+    monkeypatch.setattr(cebridge, "resync_types_from_disk", lambda *_a, **_k: 3)
+    monkeypatch.setattr(cebridge, "inject_deck_nodes", lambda *_a, **_k: 1)
+    monkeypatch.setattr(
+        "switchbay.wiki_sync.inject_on_disk_pages", lambda *_a, **_k: 5,
+    )
+    monkeypatch.setattr(cebridge, "_override_palette", lambda *_a, **_k: None)
+    counts = cebridge.enrich_from_disk(tmp_path, {"pages": {}, "nodes": [], "edges": []})
+    assert counts == {"types": 3, "decks": 1, "pages": 5}
+
+
+def test_graph_progress_payload_shape() -> None:
+    msg = protocol.graph_progress(
+        "types", "Syncing page types…",
+        workspace="/tmp/ws", current=2, total=10, done=False,
+    )
+    assert msg["type"] == "CUSTOM"
+    assert msg["name"] == "graph_progress"
+    val = msg["value"]
+    assert val["type"] == "graph_progress"
+    assert val["stage"] == "types"
+    assert val["message"] == "Syncing page types…"
+    assert val["workspace"] == "/tmp/ws"
+    assert val["current"] == 2
+    assert val["total"] == 10
+    assert val["done"] is False
+
+    done = protocol.graph_progress("ready", "Graph ready", done=True)
+    assert done["value"]["done"] is True
diff --git a/tests/unit/test_host_notify.py b/tests/unit/test_host_notify.py
new file mode 100644
index 0000000..46f2faf
--- /dev/null
+++ b/tests/unit/test_host_notify.py
@@ -0,0 +1,104 @@
+"""okstratr.host_notify → rail protocol.notice mapping."""
+
+from __future__ import annotations
+
+import pytest
+from aiohttp import web
+from aiohttp.test_utils import TestClient, TestServer
+
+from switchbay import host_notify
+
+
+def _env(**overrides):
+    base = {
+        "type": "okstratr.host_notify",
+        "v": 1,
+        "kind": "schedule.start",
+        "schedule_id": "sched-1",
+        "desk": "auto",
+        "title": "Morning digest",
+        "body": "Running hedge-fund desk.",
+        "progress": {"pct": None, "phase": "start", "detail": ""},
+        "ts": "2026-09-19T08:00:00Z",
+    }
+    base.update(overrides)
+    return base
+
+
+def test_validate_ok():
+    env, err = host_notify.validate_envelope(_env())
+    assert err is None
+    assert env is not None
+
+
+def test_validate_rejects_wrong_type():
+    env, err = host_notify.validate_envelope(_env(type="other"))
+    assert env is None
+    assert "type" in (err or "")
+
+
+def test_format_includes_title_and_meta():
+    text = host_notify.format_rail_text(_env())
+    assert "[okstratr]" in text
+    assert "Morning digest" in text
+    assert "desk=auto" in text
+    assert "id=sched-1" in text
+    assert "Running hedge-fund desk." in text
+
+
+def test_format_progress():
+    text = host_notify.format_rail_text(
+        _env(
+            kind="schedule.progress",
+            progress={"pct": 40, "phase": "fetch", "detail": "n=3"},
+        )
+    )
+    assert "40%" in text
+    assert "fetch" in text
+
+
+def test_notice_from_envelope_is_protocol_notice():
+    msg = host_notify.notice_from_envelope(_env())
+    text = host_notify._notice_text(msg)
+    assert text and "Morning digest" in text
+
+
+@pytest.mark.asyncio
+async def test_apply_broadcasts_via_app_helper():
+    seen: list[dict] = []
+
+    async def _bc(app, msg):
+        seen.append(msg)
+
+    app = {"_broadcast_fn": _bc}
+    result = await host_notify.apply_host_notify(app, _env())
+    assert result["ok"] is True
+    assert result["broadcast"] is True
+    assert len(seen) == 1
+    assert "Morning digest" in (result.get("text") or "")
+
+
+@pytest.mark.asyncio
+async def test_http_host_notify_endpoint_broadcasts():
+    """POST /api/okstratr/host-notify posts envelope → rail notice."""
+    from switchbay import daemon
+
+    seen: list[dict] = []
+
+    async def _bc(app, msg):
+        seen.append(msg)
+
+    app = web.Application()
+    app["workspace"] = "/tmp"
+    app["ws_clients"] = set()
+    app["_broadcast_fn"] = _bc
+    app.router.add_post("/api/okstratr/host-notify", daemon.handle_okstratr_host_notify)
+
+    async with TestClient(TestServer(app)) as client:
+        resp = await client.post("/api/okstratr/host-notify", json=_env())
+        assert resp.status == 200
+        data = await resp.json()
+        assert data["ok"] is True
+        assert data["broadcast"] is True
+        assert "Morning digest" in (data.get("text") or "")
+    assert len(seen) == 1
diff --git a/tests/unit/test_ingest_run_drain.py b/tests/unit/test_ingest_run_drain.py
new file mode 100644
index 0000000..f943afd
--- /dev/null
+++ b/tests/unit/test_ingest_run_drain.py
@@ -0,0 +1,302 @@
+"""CE ingest-queue → Switchbay local_ingest / rail drain (no real CE/LLM)."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+from pathlib import Path
+
+import pytest
+from aiohttp import web
+from aiohttp.test_utils import TestClient, TestServer
+
+from switchbay import ingest_run_drain
+
+
+def _stage_file(ws: Path, rel: str, data: bytes = b"# hello\n") -> str:
+    p = ws / rel
+    p.parent.mkdir(parents=True, exist_ok=True)
+    p.write_bytes(data)
+    return rel
+
+
+def _write_run(ws: Path, run_id: str, **fields) -> Path:
+    d = ws / ".workbench" / "ingest-runs"
+    d.mkdir(parents=True, exist_ok=True)
+    vault_path = fields.pop("vault_path", "vault/raw/note.md")
+    if "vault_path" not in fields and vault_path:
+        _stage_file(ws, vault_path)
+    rec = {
+        "run_id": run_id,
+        "status": "queued",
+        "kind": "ingest-upload",
+        "vault_path": vault_path,
+        "filename": Path(vault_path).name,
+        "size": 8,
+        "mode": "staged",
+    }
+    rec.update(fields)
+    p = d / f"{run_id}.json"
+    p.write_text(json.dumps(rec, indent=2) + "\n", encoding="utf-8")
+    return p
+
+
+async def _wait_inflight_clear(app, timeout: float = 2.0) -> None:
+    deadline = asyncio.get_running_loop().time() + timeout
+    while app.get("ingest_run_inflight"):
+        if asyncio.get_running_loop().time() > deadline:
+            app["ingest_run_inflight"].clear()
+            break
+        await asyncio.sleep(0.01)
+    await asyncio.sleep(0.05)
+
+
+def test_list_queued_and_write_status(tmp_path: Path):
+    ws = tmp_path / "ws"
+    ws.mkdir()
+    _write_run(ws, "run-aaa")
+    _write_run(ws, "run-bbb", status="running")
+    _write_run(ws, "run-ccc", status="accepted")
+    queued = ingest_run_drain.list_queued_runs(ws)
+    ids = {r["run_id"] for r in queued}
+    assert ids == {"run-aaa", "run-ccc"}
+
+    updated = ingest_run_drain.write_run_status(
+        ws, "run-aaa", "running", note="seated",
+    )
+    assert updated is not None
+    assert updated["status"] == "running"
+    assert updated["note"] == "seated"
+    disk = json.loads(
+        (ws / ".workbench" / "ingest-runs" / "run-aaa.json").read_text()
+    )
+    assert disk["status"] == "running"
+
+
+def test_run_path_refuses_escape(tmp_path: Path):
+    ws = tmp_path / "ws"
+    ws.mkdir()
+    p = ingest_run_drain.run_path(ws, "../../etc/passwd")
+    assert p.parent == ingest_run_drain.runs_dir(ws)
+    assert p.name == "passwd.json"
+
+
+def test_resolve_vault_path_refuses_escape(tmp_path: Path):
+    ws = tmp_path / "ws"
+    ws.mkdir()
+    (ws / "vault" / "raw").mkdir(parents=True)
+    err = ingest_run_drain.resolve_run_vault_path(
+        ws, {"vault_path": "../../etc/passwd"},
+    )
+    assert isinstance(err, str)
+    assert "escape" in err.lower() or "invalid" in err.lower()
+
+    err2 = ingest_run_drain.resolve_run_vault_path(
+        ws, {"vault_path": "vault/raw/../../etc/passwd"},
+    )
+    assert isinstance(err2, str)
+
+    err3 = ingest_run_drain.resolve_run_vault_path(
+        ws, {"vault_path": "bad\x00.md"},
+    )
+    assert isinstance(err3, str)
+
+    rel = _stage_file(ws, "vault/raw/ok.md")
+    ok = ingest_run_drain.resolve_run_vault_path(ws, {"vault_path": rel})
+    assert isinstance(ok, tuple)
+    assert ok[0] == "vault/raw/ok.md"
+
+
+def test_wants_rail_only_when_metadata_opts_in():
+    assert ingest_run_drain.wants_rail({"mode": "staged"}) is False
+    assert ingest_run_drain.wants_rail({}) is False
+    assert ingest_run_drain.wants_rail({"mode": "llm"}) is True
+    assert ingest_run_drain.wants_rail({"drain": "rail"}) is True
+    assert ingest_run_drain.wants_rail({"prefer_rail": True}) is True
+    assert ingest_run_drain.wants_rail({"use_llm": "yes"}) is True
+
+
+@pytest.mark.asyncio
+async def test_drain_once_local_ingest_happy(tmp_path: Path):
+    ws = tmp_path / "ws"
+    ws.mkdir()
+    _write_run(ws, "run-ok")
+
+    seen: list[str] = []
+
+    def fake_local(workspace, vault_path, rec):
+        seen.append(vault_path)
+        return {"ok": 1, "considered": 1, "failed": 0, "file": vault_path}
+
+    app = {"workspace": ws, "runs": {}, "ingest_run_inflight": set()}
+    summary = await ingest_run_drain.drain_once(
+        app, local_ingest_fn=fake_local,
+    )
+    assert summary["drained"] == ["run-ok"]
+    assert summary["errors"] == []
+
+    await _wait_inflight_clear(app)
+    assert seen == ["vault/raw/note.md"]
+    disk = json.loads(
+        (ws / ".workbench" / "ingest-runs" / "run-ok.json").read_text()
+    )
+    assert disk["status"] == "done"
+    assert disk.get("drain_via") == "local_ingest"
+
+
+@pytest.mark.asyncio
+async def test_drain_marks_failed_on_escape(tmp_path: Path):
+    ws = tmp_path / "ws"
+    ws.mkdir()
+    d = ws / ".workbench" / "ingest-runs"
+    d.mkdir(parents=True)
+    (d / "run-esc.json").write_text(
+        json.dumps({
+            "run_id": "run-esc",
+            "status": "queued",
+            "vault_path": "../../etc/passwd",
+            "mode": "staged",
+        })
+        + "\n",
+        encoding="utf-8",
+    )
+
+    called: list[str] = []
+
+    def fake_local(workspace, vault_path, rec):
+        called.append(vault_path)
+        return {"ok": 1, "considered": 1}
+
+    app = {"workspace": ws, "runs": {}, "ingest_run_inflight": set()}
+    summary = await ingest_run_drain.drain_once(
+        app, local_ingest_fn=fake_local,
+    )
+    assert called == []
+    assert any(e["run_id"] == "run-esc" for e in summary["errors"])
+    disk = json.loads((d / "run-esc.json").read_text())
+    assert disk["status"] == "failed"
+    assert "escape" in disk.get("note", "").lower() or "invalid" in disk.get(
+        "note", ""
+    ).lower()
+
+
+@pytest.mark.asyncio
+async def test_drain_rail_when_metadata_opts_in(tmp_path: Path, monkeypatch):
+    ws = tmp_path / "ws"
+    ws.mkdir()
+    _write_run(ws, "run-rail", mode="llm")
+
+    local_called: list[str] = []
+    rail_seen: list[dict] = []
+
+    def fake_local(workspace, vault_path, rec):
+        local_called.append(vault_path)
+        return {"ok": 1, "considered": 1}
+
+    async def fake_dispatch(app, **kwargs):
+        rail_seen.append(kwargs)
+        app.setdefault("runs", {})[kwargs["run_id"]] = {}
+
+    monkeypatch.setattr(
+        ingest_run_drain, "_error_surface", lambda _app, _rid: (lambda _t: None),
+    )
+
+    app = {"workspace": ws, "runs": {}, "ingest_run_inflight": set()}
+    summary = await ingest_run_drain.drain_once(
+        app,
+        dispatch_fn=fake_dispatch,
+        local_ingest_fn=fake_local,
+    )
+    assert summary["drained"] == ["run-rail"]
+    await _wait_inflight_clear(app)
+    assert local_called == []
+    assert len(rail_seen) == 1
+    assert rail_seen[0]["run_id"] == "run-rail"
+    assert "vault/raw/note.md" in rail_seen[0]["text"]
+    disk = json.loads(
+        (ws / ".workbench" / "ingest-runs" / "run-rail.json").read_text()
+    )
+    assert disk["status"] == "done"
+    assert disk.get("drain_via") == "rail"
+
+
+@pytest.mark.asyncio
+async def test_drain_local_failure_marks_failed(tmp_path: Path):
+    ws = tmp_path / "ws"
+    ws.mkdir()
+    _write_run(ws, "run-bad")
+
+    def fake_local(workspace, vault_path, rec):
+        return {"error": "pypdf_missing"}
+
+    app = {"workspace": ws, "runs": {}, "ingest_run_inflight": set()}
+    summary = await ingest_run_drain.drain_once(
+        app, local_ingest_fn=fake_local,
+    )
+    assert summary["drained"] == ["run-bad"]
+    await _wait_inflight_clear(app)
+    disk = json.loads(
+        (ws / ".workbench" / "ingest-runs" / "run-bad.json").read_text()
+    )
+    assert disk["status"] == "failed"
+    assert "pypdf_missing" in disk.get("note", "")
+
+
+@pytest.mark.asyncio
+async def test_drain_dedupes_inflight(tmp_path: Path):
+    ws = tmp_path / "ws"
+    ws.mkdir()
+    _write_run(ws, "run-dup")
+
+    called: list[str] = []
+
+    def fake_local(workspace, vault_path, rec):
+        called.append(vault_path)
+        return {"ok": 1, "considered": 1}
+
+    app = {
+        "workspace": ws,
+        "runs": {},
+        "ingest_run_inflight": {"run-dup"},
+    }
+    summary = await ingest_run_drain.drain_once(
+        app, local_ingest_fn=fake_local,
+    )
+    assert summary["skipped"] == ["run-dup"]
+    assert summary["drained"] == []
+    assert called == []
+
+
+@pytest.mark.asyncio
+async def test_http_ingest_drain_endpoint(tmp_path: Path):
+    from switchbay import daemon
+
+    ws = tmp_path / "ws"
+    ws.mkdir()
+    _write_run(ws, "run-http")
+
+    def fake_local(workspace, vault_path, rec):
+        return {"ok": 1, "considered": 1, "failed": 0}
+
+    async def drain_handler(request: web.Request) -> web.Response:
+        summary = await ingest_run_drain.drain_once(
+            request.app, local_ingest_fn=fake_local,
+        )
+        return web.json_response(summary)
+
+    app = web.Application()
+    app["workspace"] = ws
+    app["ingest_run_inflight"] = set()
+    app["runs"] = {}
+    app.router.add_post("/api/ingest/drain", drain_handler)
+
+    async with TestClient(TestServer(app)) as client:
+        resp = await client.post("/api/ingest/drain")
+        assert resp.status == 200
+        data = await resp.json()
+        assert data["drained"] == ["run-http"]
+        assert data["error_count"] == 0
+
+    await _wait_inflight_clear(app)
+    assert hasattr(daemon, "handle_ingest_drain")
+    assert callable(daemon.handle_ingest_drain)
diff --git a/tests/unit/test_okstratr_harness.py b/tests/unit/test_okstratr_harness.py
new file mode 100644
index 0000000..4f4f9ee
--- /dev/null
+++ b/tests/unit/test_okstratr_harness.py
@@ -0,0 +1,306 @@
+"""Thin client / mapper over okstratr harness registry (SSOT)."""
+
+from __future__ import annotations
+
+import json
+
+import pytest
+from aiohttp import web
+from aiohttp.test_utils import TestClient, TestServer
+
+from switchbay import okstratr_harness
+
+
+def _okstratr_list_payload(**overrides):
+    base = {
+        "ok": True,
+        "path": "/tmp/harnesses.toml",
+        "enabled": ["grok", "claude"],
+        "preference": ["grok", "claude"],
+        "defaults": {"adapter": "herdr", "backend": "herdr"},
+        "backend": "herdr",
+        "harnesses": [
+            {
+                "id": "grok",
+                "label": "Grok",
+                "herdr_kind": "grok",
+                "enabled": True,
+                "installed": True,
+                "bin_names": ["grok"],
+                "default_model": "grok-4.6",
+                "models": ["grok-4.6", "grok-4"],
+                "effort": {"trivial": "grok-4.6", "normal": "grok-4.6"},
+                "settings": {"reasoning": "low"},
+                "notes": "",
+            },
+            {
+                "id": "claude",
+                "label": "Claude",
+                "herdr_kind": "claude",
+                "enabled": True,
+                "installed": False,
+                "bin_names": ["claude"],
+                "default_model": "claude-haiku",
+                "models": ["claude-haiku"],
+                "effort": {},
+                "settings": {},
+                "notes": "install claude",
+            },
+            {
+                "id": "codex",
+                "label": "Codex",
+                "enabled": False,
+                "installed": False,
+                "default_model": "gpt-5",
+                "models": ["gpt-5"],
+                "effort": {},
+                "settings": {},
+                "notes": "",
+            },
+        ],
+        "blackboard": {"duration_days": 3.0, "chip": "bb: 3d"},
+    }
+    base.update(overrides)
+    return base
+
+
+def test_normalize_registry_maps_rows():
+    view = okstratr_harness.normalize_registry(_okstratr_list_payload())
+    assert view["ok"] is True
+    assert view["ssot"] == "okstratr"
+    assert view["enabled"] == ["grok", "claude"]
+    assert view["backend"] == "herdr"
+    assert len(view["harnesses"]) == 3
+    grok = view["harnesses"][0]
+    assert grok["id"] == "grok"
+    assert grok["enabled"] is True
+    assert grok["default_model"] == "grok-4.6"
+    assert "grok-4.6" in grok["models"]
+    assert view["embed_paths"]["list"] == "/embed/okstratr/api/harness"
+    assert view["blackboard"]["chip"] == "bb: 3d"
+
+
+def test_normalize_skips_bad_rows_and_fills_defaults():
+    view = okstratr_harness.normalize_registry(
+        {
+            "harnesses": [
+                "nope",
+                {"label": "missing id"},
+                {"id": "pi", "enabled": 1, "models": "bad"},
+            ]
+        }
+    )
+    assert view["ssot"] == "okstratr"
+    assert len(view["harnesses"]) == 1
+    assert view["harnesses"][0]["id"] == "pi"
+    assert view["harnesses"][0]["models"] == []
+    assert view["harnesses"][0]["enabled"] is True
+
+
+def test_normalize_none_is_empty_ssot_view():
+    view = okstratr_harness.normalize_registry(None)
+    assert view["ok"] is True
+    assert view["ssot"] == "okstratr"
+    assert view["harnesses"] == []
+    assert view["enabled"] == []
+
+
+def test_upstream_url_defaults(monkeypatch):
+    monkeypatch.delenv("SWITCHBAY_OKSTRATR_UPSTREAM", raising=False)
+    assert okstratr_harness.upstream_url("list") == "http://127.0.0.1:8767/api/harness"
+    assert (
+        okstratr_harness.upstream_url("enable")
+        == "http://127.0.0.1:8767/api/harness/enable"
+    )
+
+
+def test_upstream_url_rejects_non_loopback(monkeypatch):
+    monkeypatch.setenv("SWITCHBAY_OKSTRATR_UPSTREAM", "http://evil.example:8767")
+    with pytest.raises(okstratr_harness.OkstratrHarnessError):
+        okstratr_harness.upstream_url("list")
+
+
+@pytest.mark.asyncio
+async def test_call_harness_list_against_stub(monkeypatch):
+    """Server-side client hits loopback stub with X-Okstratr-Host."""
+    seen: dict[str, str] = {}
+
+    async def upstream(request: web.Request) -> web.Response:
+        seen["host"] = request.headers.get("X-Okstratr-Host", "")
+        seen["path"] = request.path
+        return web.json_response(_okstratr_list_payload())
+
+    up = web.Application()
+    up.router.add_get("/api/harness", upstream)
+    async with TestServer(up) as server:
+        base = f"http://127.0.0.1:{server.port}"
+        monkeypatch.setenv("SWITCHBAY_OKSTRATR_UPSTREAM", base)
+        view = await okstratr_harness.list_harnesses()
+    assert seen["host"] == "switchbay"
+    assert seen["path"] == "/api/harness"
+    assert view["ssot"] == "okstratr"
+    assert any(h["id"] == "grok" for h in view["harnesses"])
+
+
+@pytest.mark.asyncio
+async def test_call_harness_enable_posts_id(monkeypatch):
+    seen: dict = {}
+
+    async def upstream(request: web.Request) -> web.Response:
+        seen["path"] = request.path
+        seen["body"] = await request.json()
+        payload = _okstratr_list_payload()
+        # pretend enable flipped codex on
+        for h in payload["harnesses"]:
+            if h["id"] == "codex":
+                h["enabled"] = True
+        payload["enabled"] = ["grok", "claude", "codex"]
+        return web.json_response(payload)
+
+    up = web.Application()
+    up.router.add_post("/api/harness/enable", upstream)
+    async with TestServer(up) as server:
+        monkeypatch.setenv(
+            "SWITCHBAY_OKSTRATR_UPSTREAM", f"http://127.0.0.1:{server.port}"
+        )
+        view = await okstratr_harness.enable_harness("codex")
+    assert seen["path"] == "/api/harness/enable"
+    assert seen["body"]["id"] == "codex"
+    assert "codex" in view["enabled"]
+
+
+@pytest.mark.asyncio
+async def test_call_harness_set_posts_key_value(monkeypatch):
+    seen: dict = {}
+
+    async def upstream(request: web.Request) -> web.Response:
+        seen["body"] = await request.json()
+        return web.json_response(_okstratr_list_payload())
+
+    up = web.Application()
+    up.router.add_post("/api/harness/set", upstream)
+    async with TestServer(up) as server:
+        monkeypatch.setenv(
+            "SWITCHBAY_OKSTRATR_UPSTREAM", f"http://127.0.0.1:{server.port}"
+        )
+        await okstratr_harness.set_harness_value(
+            "harness.grok.default_model", "grok-4"
+        )
+    assert seen["body"] == {
+        "key": "harness.grok.default_model",
+        "value": "grok-4",
+    }
+
+
+@pytest.mark.asyncio
+async def test_daemon_routes_thin_client(monkeypatch):
+    """GET/POST /api/okstratr/harness* shell without embed path knowledge."""
+    from switchbay import daemon
+
+    state = {"enabled": ["grok"]}
+
+    async def list_h(request: web.Request) -> web.Response:
+        return web.json_response(
+            _okstratr_list_payload(enabled=list(state["enabled"]))
+        )
+
+    async def enable_h(request: web.Request) -> web.Response:
+        body = await request.json()
+        hid = body.get("id")
+        if hid and hid not in state["enabled"]:
+            state["enabled"].append(hid)
+        return web.json_response(
+            _okstratr_list_payload(enabled=list(state["enabled"]))
+        )
+
+    async def disable_h(request: web.Request) -> web.Response:
+        body = await request.json()
+        hid = body.get("id")
+        state["enabled"] = [x for x in state["enabled"] if x != hid] or ["grok"]
+        return web.json_response(
+            _okstratr_list_payload(enabled=list(state["enabled"]))
+        )
+
+    async def set_h(request: web.Request) -> web.Response:
+        await request.json()
+        return web.json_response(_okstratr_list_payload())
+
+    async def reload_h(request: web.Request) -> web.Response:
+        return web.json_response(
+            {"ok": True, "reloaded": True, "config": _okstratr_list_payload()}
+        )
+
+    up = web.Application()
+    up.router.add_get("/api/harness", list_h)
+    up.router.add_post("/api/harness/enable", enable_h)
+    up.router.add_post("/api/harness/disable", disable_h)
+    up.router.add_post("/api/harness/set", set_h)
+    up.router.add_post("/api/harness/reload", reload_h)
+
+    async with TestServer(up) as server:
+        monkeypatch.setenv(
+            "SWITCHBAY_OKSTRATR_UPSTREAM", f"http://127.0.0.1:{server.port}"
+        )
+        app = web.Application()
+        app.router.add_get(
+            "/api/okstratr/harness", daemon.handle_okstratr_harness_get
+        )
+        app.router.add_post(
+            "/api/okstratr/harness/enable", daemon.handle_okstratr_harness_enable
+        )
+        app.router.add_post(
+            "/api/okstratr/harness/disable", daemon.handle_okstratr_harness_disable
+        )
+        app.router.add_post(
+            "/api/okstratr/harness/set", daemon.handle_okstratr_harness_set
+        )
+        app.router.add_post(
+            "/api/okstratr/harness/reload", daemon.handle_okstratr_harness_reload
+        )
+        async with TestClient(TestServer(app)) as client:
+            r = await client.get("/api/okstratr/harness")
+            assert r.status == 200
+            data = await r.json()
+            assert data["ssot"] == "okstratr"
+            assert data["ok"] is True
+
+            r = await client.post(
+                "/api/okstratr/harness/enable", json={"id": "claude"}
+            )
+            assert r.status == 200
+            data = await r.json()
+            assert "claude" in data["enabled"]
+
+            r = await client.post(
+                "/api/okstratr/harness/disable", json={"id": "claude"}
+            )
+            assert r.status == 200
+            data = await r.json()
+            assert "claude" not in data["enabled"]
+
+            r = await client.post(
+                "/api/okstratr/harness/set",
+                json={"key": "backend", "value": "direct"},
+            )
+            assert r.status == 200
+            assert (await r.json())["ssot"] == "okstratr"
+
+            r = await client.post("/api/okstratr/harness/reload", json={})
+            assert r.status == 200
+            assert (await r.json())["ssot"] == "okstratr"
+
+
+@pytest.mark.asyncio
+async def test_daemon_route_502_when_upstream_down(monkeypatch):
+    from switchbay import daemon
+
+    # Bind nothing on a high port — connection refused.
+    monkeypatch.setenv("SWITCHBAY_OKSTRATR_UPSTREAM", "http://127.0.0.1:1")
+    app = web.Application()
+    app.router.add_get("/api/okstratr/harness", daemon.handle_okstratr_harness_get)
+    async with TestClient(TestServer(app)) as client:
+        r = await client.get("/api/okstratr/harness")
+        assert r.status == 502
+        data = await r.json()
+        assert data["ok"] is False
+        assert data["ssot"] == "okstratr"
diff --git a/tests/unit/test_okstratr_supervisor.py b/tests/unit/test_okstratr_supervisor.py
new file mode 100644
index 0000000..0814ba5
--- /dev/null
+++ b/tests/unit/test_okstratr_supervisor.py
@@ -0,0 +1,42 @@
+"""URL/port helpers + argv resolution for okstratr supervisor."""
+
+from __future__ import annotations
+
+from switchbay import okstratr_supervisor as oks
+
+
+def test_upstream_defaults(monkeypatch):
+    monkeypatch.delenv("SWITCHBAY_OKSTRATR_UPSTREAM", raising=False)
+    assert oks.upstream_base() == "http://127.0.0.1:8767"
+    assert oks.upstream_port() == 8767
+    assert oks.upstream_host() == "127.0.0.1"
+    assert oks.health_url().endswith("/health")
+
+
+def test_upstream_env_override(monkeypatch):
+    monkeypatch.setenv("SWITCHBAY_OKSTRATR_UPSTREAM", "http://127.0.0.1:9876")
+    assert oks.upstream_base() == "http://127.0.0.1:9876"
+    assert oks.upstream_port() == 9876
+
+
+def test_resolve_argv_prefers_bin_override(monkeypatch, tmp_path):
+    fake = tmp_path / "okstratr"
+    fake.write_text("#!/bin/sh\n", encoding="utf-8")
+    fake.chmod(0o755)
+    monkeypatch.setenv("SWITCHBAY_OKSTRATR_BIN", str(fake))
+    assert oks.resolve_okstratr_argv() == [str(fake)]
+
+
+def test_resolve_argv_falls_back_to_module(monkeypatch):
+    monkeypatch.delenv("SWITCHBAY_OKSTRATR_BIN", raising=False)
+    monkeypatch.setattr(oks.shutil, "which", lambda _n: None)
+    argv = oks.resolve_okstratr_argv()
+    assert argv[-2:] == ["-m", "okstratr"]
+
+
+def test_contract_slice_shape(monkeypatch):
+    monkeypatch.setattr(oks, "is_healthy", lambda **_: False)
+    monkeypatch.setattr(oks, "_read_pid", lambda: None)
+    slice_ = oks.contract_slice()
+    assert set(slice_) == {"state", "url", "detail"}
+    assert slice_["state"] in {"starting", "healthy", "unhealthy", "stopped"}
diff --git a/tests/unit/test_pack_run_drain.py b/tests/unit/test_pack_run_drain.py
new file mode 100644
index 0000000..f5e7c30
--- /dev/null
+++ b/tests/unit/test_pack_run_drain.py
@@ -0,0 +1,275 @@
+"""CE pack-queue → Switchbay rail drain (no real LLM seats)."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+from pathlib import Path
+from unittest.mock import MagicMock
+
+import pytest
+from aiohttp import web
+from aiohttp.test_utils import TestClient, TestServer
+
+from switchbay import pack_run_drain
+
+
+def _write_run(ws: Path, run_id: str, **fields) -> Path:
+    d = ws / ".workbench" / "pack-runs"
+    d.mkdir(parents=True, exist_ok=True)
+    rec = {
+        "run_id": run_id,
+        "pack": "demo",
+        "action": "open-deck",
+        "path": "vault/raw/deck.pptx",
+        "status": "queued",
+        "kind": "pack:demo:open-deck",
+    }
+    rec.update(fields)
+    p = d / f"{run_id}.json"
+    p.write_text(json.dumps(rec, indent=2) + "\n", encoding="utf-8")
+    return p
+
+
+async def _wait_inflight_clear(app, timeout: float = 2.0) -> None:
+    deadline = asyncio.get_running_loop().time() + timeout
+    while app.get("pack_run_inflight"):
+        if asyncio.get_running_loop().time() > deadline:
+            app["pack_run_inflight"].clear()
+            break
+        await asyncio.sleep(0.01)
+    await asyncio.sleep(0.05)
+
+
+def test_list_queued_and_write_status(tmp_path: Path):
+    ws = tmp_path / "ws"
+    ws.mkdir()
+    _write_run(ws, "run-aaa")
+    _write_run(ws, "run-bbb", status="running")
+    _write_run(ws, "run-ccc", status="accepted")
+    queued = pack_run_drain.list_queued_runs(ws)
+    ids = {r["run_id"] for r in queued}
+    assert ids == {"run-aaa", "run-ccc"}
+
+    updated = pack_run_drain.write_run_status(
+        ws, "run-aaa", "running", note="seated",
+    )
+    assert updated is not None
+    assert updated["status"] == "running"
+    assert updated["note"] == "seated"
+    disk = json.loads(
+        (ws / ".workbench" / "pack-runs" / "run-aaa.json").read_text()
+    )
+    assert disk["status"] == "running"
+    assert disk["note"] == "seated"
+
+
+def test_build_pack_prompt_matches_handle_pack_action():
+    prompt = pack_run_drain.build_pack_prompt(
+        "demo", "open-deck", "vault/raw/deck.pptx",
+    )
+    assert 'load_skill("demo-open-deck")' in prompt
+    assert "`vault/raw/deck.pptx`" in prompt
+    assert "`demo` pack is active" in prompt
+
+
+@pytest.mark.asyncio
+async def test_drain_once_with_mocked_dispatch(tmp_path: Path, monkeypatch):
+    ws = tmp_path / "ws"
+    ws.mkdir()
+    _write_run(ws, "run-ok")
+
+    monkeypatch.setattr(
+        pack_run_drain.packstore,
+        "get_pack",
+        lambda _ws, name: (
+            {"name": name, "enabled": True} if name == "demo" else None
+        ),
+    )
+    monkeypatch.setattr(
+        pack_run_drain.skillkit,
+        "get_skill",
+        lambda _ws, name: (
+            MagicMock(name=name) if name == "demo-open-deck" else None
+        ),
+    )
+
+    seen: list[dict] = []
+
+    async def fake_dispatch(app, **kwargs):
+        seen.append(kwargs)
+        app.setdefault("runs", {})[kwargs["run_id"]] = {}
+
+    # Avoid importing daemon's error-surface during unit drain.
+    monkeypatch.setattr(
+        pack_run_drain, "_error_surface", lambda _app, _rid: (lambda _t: None),
+    )
+
+    app = {"workspace": ws, "runs": {}, "pack_run_inflight": set()}
+    summary = await pack_run_drain.drain_once(app, dispatch_fn=fake_dispatch)
+    assert summary["drained"] == ["run-ok"]
+    assert summary["errors"] == []
+
+    await _wait_inflight_clear(app)
+    assert len(seen) == 1
+    assert seen[0]["run_id"] == "run-ok"
+    assert "demo-open-deck" in seen[0]["text"]
+    disk = json.loads(
+        (ws / ".workbench" / "pack-runs" / "run-ok.json").read_text()
+    )
+    assert disk["status"] == "done"
+
+
+@pytest.mark.asyncio
+async def test_drain_marks_failed_disabled_pack(tmp_path: Path, monkeypatch):
+    ws = tmp_path / "ws"
+    ws.mkdir()
+    _write_run(ws, "run-off", pack="demo", action="open-deck")
+
+    monkeypatch.setattr(
+        pack_run_drain.packstore,
+        "get_pack",
+        lambda *_a, **_k: {"name": "demo", "enabled": False},
+    )
+    monkeypatch.setattr(
+        pack_run_drain.skillkit,
+        "get_skill",
+        lambda *_a, **_k: MagicMock(),
+    )
+    monkeypatch.setattr(
+        pack_run_drain, "_error_surface", lambda _app, _rid: (lambda _t: None),
+    )
+
+    called: list[str] = []
+
+    async def fake_dispatch(app, **kwargs):
+        called.append(kwargs["run_id"])
+
+    app = {"workspace": ws, "runs": {}, "pack_run_inflight": set()}
+    summary = await pack_run_drain.drain_once(app, dispatch_fn=fake_dispatch)
+    assert called == []
+    assert any(e["run_id"] == "run-off" for e in summary["errors"])
+    disk = json.loads(
+        (ws / ".workbench" / "pack-runs" / "run-off.json").read_text()
+    )
+    assert disk["status"] == "failed"
+    assert "not active" in disk.get("note", "")
+
+
+@pytest.mark.asyncio
+async def test_drain_marks_failed_missing_skill(tmp_path: Path, monkeypatch):
+    ws = tmp_path / "ws"
+    ws.mkdir()
+    _write_run(ws, "run-noskill", pack="demo", action="nope")
+
+    monkeypatch.setattr(
+        pack_run_drain.packstore,
+        "get_pack",
+        lambda *_a, **_k: {"name": "demo", "enabled": True},
+    )
+    monkeypatch.setattr(
+        pack_run_drain.skillkit,
+        "get_skill",
+        lambda *_a, **_k: None,
+    )
+    monkeypatch.setattr(
+        pack_run_drain, "_error_surface", lambda _app, _rid: (lambda _t: None),
+    )
+
+    async def fake_dispatch(app, **kwargs):
+        raise AssertionError("should not dispatch")
+
+    app = {"workspace": ws, "runs": {}, "pack_run_inflight": set()}
+    summary = await pack_run_drain.drain_once(app, dispatch_fn=fake_dispatch)
+    assert summary["drained"] == []
+    assert any(e["run_id"] == "run-noskill" for e in summary["errors"])
+    disk = json.loads(
+        (ws / ".workbench" / "pack-runs" / "run-noskill.json").read_text()
+    )
+    assert disk["status"] == "failed"
+    assert "skill not found" in disk.get("note", "")
+
+
+@pytest.mark.asyncio
+async def test_drain_dedupes_inflight(tmp_path: Path, monkeypatch):
+    ws = tmp_path / "ws"
+    ws.mkdir()
+    _write_run(ws, "run-dup")
+    monkeypatch.setattr(
+        pack_run_drain.packstore,
+        "get_pack",
+        lambda *_a, **_k: {"name": "demo", "enabled": True},
+    )
+    monkeypatch.setattr(
+        pack_run_drain.skillkit,
+        "get_skill",
+        lambda *_a, **_k: MagicMock(),
+    )
+    monkeypatch.setattr(
+        pack_run_drain, "_error_surface", lambda _app, _rid: (lambda _t: None),
+    )
+
+    called: list[str] = []
+
+    async def fake_dispatch(app, **kwargs):
+        called.append(kwargs["run_id"])
+
+    # Still queued on disk, but already claimed in-memory.
+    app = {
+        "workspace": ws,
+        "runs": {},
+        "pack_run_inflight": {"run-dup"},
+    }
+    summary = await pack_run_drain.drain_once(app, dispatch_fn=fake_dispatch)
+    assert summary["skipped"] == ["run-dup"]
+    assert summary["drained"] == []
+    assert called == []
+
+
+@pytest.mark.asyncio
+async def test_http_packs_drain_endpoint(tmp_path: Path, monkeypatch):
+    from switchbay import daemon
+
+    ws = tmp_path / "ws"
+    ws.mkdir()
+    _write_run(ws, "run-http")
+
+    monkeypatch.setattr(
+        pack_run_drain.packstore,
+        "get_pack",
+        lambda *_a, **_k: {"name": "demo", "enabled": True},
+    )
+    monkeypatch.setattr(
+        pack_run_drain.skillkit,
+        "get_skill",
+        lambda *_a, **_k: MagicMock(),
+    )
+    monkeypatch.setattr(
+        pack_run_drain, "_error_surface", lambda _app, _rid: (lambda _t: None),
+    )
+
+    async def fake_dispatch(app, **kwargs):
+        return None
+
+    async def drain_handler(request: web.Request) -> web.Response:
+        summary = await pack_run_drain.drain_once(
+            request.app, dispatch_fn=fake_dispatch,
+        )
+        return web.json_response(summary)
+
+    app = web.Application()
+    app["workspace"] = ws
+    app["pack_run_inflight"] = set()
+    app["runs"] = {}
+    app.router.add_post("/api/packs/drain", drain_handler)
+
+    async with TestClient(TestServer(app)) as client:
+        resp = await client.post("/api/packs/drain")
+        assert resp.status == 200
+        data = await resp.json()
+        assert data["drained"] == ["run-http"]
+        assert data["error_count"] == 0
+
+    await _wait_inflight_clear(app)
+    assert hasattr(daemon, "handle_packs_drain")
+    assert callable(daemon.handle_packs_drain)
diff --git a/tests/unit/test_vault_db_fallback.py b/tests/unit/test_vault_db_fallback.py
new file mode 100644
index 0000000..b745b5c
--- /dev/null
+++ b/tests/unit/test_vault_db_fallback.py
@@ -0,0 +1,75 @@
+"""vault.db fallback for missing vault/*.extracted.md files."""
+
+from __future__ import annotations
+
+import sqlite3
+from pathlib import Path
+
+from switchbay import fileops
+
+
+def _init_fts(db: Path) -> None:
+    conn = sqlite3.connect(db)
+    conn.execute(
+        """
+        CREATE VIRTUAL TABLE sources USING fts5(
+            path, title, body, date, source_path,
+            tokenize='porter unicode61'
+        )
+        """
+    )
+    conn.execute(
+        "INSERT INTO sources(path, title, body, date, source_path) "
+        "VALUES(?,?,?,?,?)",
+        (
+            "20260101-000000-local-demo.txt.extracted.md",
+            "demo",
+            "---\ntitle: demo\n---\nhello from fts\n",
+            "2026-01-01",
+            "/tmp/demo.txt",
+        ),
+    )
+    conn.commit()
+    conn.close()
+
+
+def test_vault_extracted_basename():
+    assert fileops.vault_extracted_basename(
+        "vault/foo.txt.extracted.md"
+    ) == "foo.txt.extracted.md"
+    assert fileops.vault_extracted_basename(
+        "vault:bar.md.extracted.md"
+    ) == "bar.md.extracted.md"
+    assert fileops.vault_extracted_basename("wiki/page.md") is None
+    assert fileops.vault_extracted_basename("../escape.extracted.md") is None
+
+
+def test_vault_db_read_body_hits_fts(tmp_path: Path):
+    vault = tmp_path / "vault"
+    vault.mkdir()
+    db = vault / "vault.db"
+    _init_fts(db)
+    # No on-disk extract — body still available via FTS
+    body = fileops.vault_db_read_body(
+        tmp_path, "vault/20260101-000000-local-demo.txt.extracted.md",
+    )
+    assert body is not None
+    assert "hello from fts" in body
+
+
+def test_vault_db_read_body_missing_row(tmp_path: Path):
+    vault = tmp_path / "vault"
+    vault.mkdir()
+    _init_fts(vault / "vault.db")
+    assert fileops.vault_db_read_body(
+        tmp_path, "vault/nope.txt.extracted.md",
+    ) is None
+
+
+def test_vault_db_read_body_empty_stub_db(tmp_path: Path):
+    vault = tmp_path / "vault"
+    vault.mkdir()
+    (vault / "vault.db").write_bytes(b"x" * 100)  # tiny stub
+    assert fileops.vault_db_read_body(
+        tmp_path, "vault/foo.txt.extracted.md",
+    ) is None
diff --git a/tests/unit/test_workspaces_resolve.py b/tests/unit/test_workspaces_resolve.py
index 6170aef..2b31b21 100644
--- a/tests/unit/test_workspaces_resolve.py
+++ b/tests/unit/test_workspaces_resolve.py
@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import os
 from pathlib import Path
 
 import pytest
@@ -28,3 +29,99 @@ def test_resolve_path_must_exist(tmp_path: Path, monkeypatch):
     d = tmp_path / "ws"
     d.mkdir()
     assert workspaces.resolve_path(str(d)) == d.resolve()
+
+
+def test_allowed_roots_always_include_home(tmp_path: Path, monkeypatch):
+    fake_home = tmp_path / "home"
+    fake_home.mkdir()
+    monkeypatch.setattr(Path, "home", classmethod(lambda cls: fake_home))
+    monkeypatch.delenv("SWITCHBAY_WORKSPACE_ROOTS", raising=False)
+    roots = workspaces.allowed_workspace_roots()
+    assert fake_home.resolve() in roots
+
+
+def test_is_within_home_allows_under_fake_home(tmp_path: Path, monkeypatch):
+    fake_home = tmp_path / "home"
+    ws = fake_home / "Workspaces" / "proj"
+    ws.mkdir(parents=True)
+    monkeypatch.setattr(
+        workspaces, "allowed_workspace_roots", lambda: [fake_home.resolve()]
+    )
+    assert workspaces.is_within_home(ws) is True
+    assert workspaces.is_within_home(fake_home) is True
+
+
+def test_is_within_home_refuses_etc(tmp_path: Path, monkeypatch):
+    fake_home = tmp_path / "home"
+    fake_home.mkdir()
+    monkeypatch.setattr(
+        workspaces, "allowed_workspace_roots", lambda: [fake_home.resolve()]
+    )
+    assert workspaces.is_within_home(Path("/etc")) is False
+    assert workspaces.is_within_home(Path("/")) is False
+    assert workspaces.is_within_home(Path("/tmp")) is False
+
+
+def test_is_within_home_allows_workspace_root_when_present(tmp_path: Path, monkeypatch):
+    """Stand-in for box `/workspace/...` corpora (tmpdir monkeypatch of roots)."""
+    box_root = tmp_path / "workspace"
+    corpus = box_root / "ce-cb-biocure"
+    corpus.mkdir(parents=True)
+    fake_home = tmp_path / "home"
+    fake_home.mkdir()
+    monkeypatch.setattr(
+        workspaces,
+        "allowed_workspace_roots",
+        lambda: [fake_home.resolve(), box_root.resolve()],
+    )
+    assert workspaces.is_within_home(corpus) is True
+    assert workspaces.is_within_home(Path("/etc")) is False
+
+
+def test_switchbay_workspace_roots_env_honored(tmp_path: Path, monkeypatch):
+    fake_home = tmp_path / "home"
+    fake_home.mkdir()
+    extra = tmp_path / "extra-root"
+    extra.mkdir()
+    missing = tmp_path / "missing-root"
+    a_file = tmp_path / "not-a-dir"
+    a_file.write_text("x", encoding="utf-8")
+    monkeypatch.setattr(Path, "home", classmethod(lambda cls: fake_home))
+    monkeypatch.setenv(
+        "SWITCHBAY_WORKSPACE_ROOTS",
+        os.pathsep.join([str(extra), str(missing), str(a_file)]),
+    )
+    roots = workspaces.allowed_workspace_roots()
+    assert fake_home.resolve() in roots
+    assert extra.resolve() in roots
+    assert all(r != missing.resolve() for r in roots)
+    assert all(r != a_file.resolve() for r in roots)
+    assert workspaces.is_within_home(extra / "proj") is True
+
+
+def test_outside_home_error_names_allowed_roots(tmp_path: Path, monkeypatch):
+    fake_home = tmp_path / "home"
+    box = tmp_path / "workspace"
+    fake_home.mkdir()
+    box.mkdir()
+    monkeypatch.setattr(
+        workspaces,
+        "allowed_workspace_roots",
+        lambda: [fake_home.resolve(), box.resolve()],
+    )
+    label = workspaces.home_label()
+    assert str(fake_home.resolve()) in label
+    assert str(box.resolve()) in label
+    assert " or " in label
+    with pytest.raises(workspaces.OutsideHomeError, match="must live inside") as ei:
+        workspaces.resolve_path("/etc")
+    assert str(fake_home.resolve()) in str(ei.value)
+
+
+def test_real_workspace_root_accepted_when_present():
+    """On the Grok Bot box, `/workspace/foo` must pass without bind-mount."""
+    ws = Path("/workspace")
+    if not ws.is_dir():
+        pytest.skip("/workspace not present on this host")
+    assert ws.resolve() in workspaces.allowed_workspace_roots()
+    assert workspaces.is_within_home(ws / "ce-cb-biocure") is True