diff --git a/CHANGELOG.md b/CHANGELOG.md
index dacc44f..5795d1b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,27 @@ All notable user-facing changes to **omp-spt** (the Spacetime adapter for oh-my-
 
 > Each release below is keyed to the **adapter version of truth** (the version `spt adapter list` reports and the GitHub release tag). omp-spt starts its own version line at 0.1.0; the sections from [0.17.3] down are the inherited **claude-spt** lineage this project forked from, retained for history.
 
+## [0.2.0] - 2026-07-14
+
+> Native OMP cutover. Requires spt-core **v0.29.0 or newer** and an installed Oh My Pi CLI. Update with `spt adapter update omp-spt`, then restart each endpoint so it loads the packaged extension and helper from this release.
+
+### Added
+- **Every endpoint now remains a real, attachable OMP session.** Ready and live endpoints use the same native OMP launch path, so an unattended endpoint can still be attached later without losing OMP's normal terminal interface.
+- **Inbound peer messages now arrive as ordinary OMP turns with full SPT context.** The visible prompt is a safe sender stub, while the complete event envelope is supplied to that turn as context; peer text cannot accidentally invoke a slash command.
+- **OMP profile-aware session tools.** History, digest, echo-commune, and Psyche session lookup now follow OMP's profile and configuration precedence, including deterministic exact-id and prefix handling.
+
+### Changed
+- **The adapter is now OMP-native only.** The inherited Claude Code plugin, hooks, CCS profiles, worker topology, headless RPC bridge, and message-idle translation path are removed. `omp-spt` advertises ReadyAgent and LiveAgent only; Worker remains an intentional capability opt-out.
+- **Fresh, resumed, and daemon-driven turns validate the real Oh My Pi executable before launch.** Explicit overrides, known install paths, and PATH candidates all receive the same identity probe, so an unrelated `omp` command cannot become the hosted terminal.
+- **One endpoint stays bound to one OMP session for its lifetime.** In-TUI new, resume, fork, handoff, and branch actions are blocked; stop and relaunch the endpoint to select another native session.
+- **Commune and signoff drops now live under the project-local `.spt/` directory.** The old harness-specific continuity path is no longer used.
+
+### Fixed
+- **Accepted messages cannot disappear after an outbound reply failure.** Correlated outcomes retry within a finite budget; exhaustion shuts the endpoint down loudly instead of marking undelivered custody as settled.
+- **Bind, activity, and shutdown races no longer advertise the wrong endpoint state or leak a late listener.** Busy-before-bind is preserved, shutdown-before-bind tears down immediately, and concurrent fatal and lifecycle shutdowns share one bounded session-end sequence.
+- **Listener recovery now distinguishes crash loops from isolated failures.** Immediate repeated exits still fail closed, while a listener that remains stable resets its consecutive-failure budget.
+- **Echo-commune handles Unicode transcript boundaries safely.** A byte cap that lands inside a multi-byte character no longer crashes the summarizer.
+
 ## [0.1.3] - 2026-07-13
 
 ### Fixed
diff --git a/CONTEXT.md b/CONTEXT.md
index 454e30a..957801a 100644
--- a/CONTEXT.md
+++ b/CONTEXT.md
@@ -1,119 +1,61 @@
-# spt-claude-code — glossary
+# omp-spt — glossary
 
 > Authoritative for meaning (grill-with-docs convention). Glossary only — no
-> implementation detail. Decisions/rationale live in `SCOPE.md` and `docs/adr/`.
+> implementation detail. Decisions and rationale live in `SCOPE.md` and `docs/adr/`.
+
+## Product and topologies
+
+**omp-spt** — the OMP-native harness adapter for spt-core. The repository,
+registered adapter, and consolidated adapter executable share this identity.
+_Avoid_: spt-claude-code, claude-spt, omps
+
+**OMP** — the Oh My Pi terminal coding agent that omp-spt integrates with.
+Use **OMP** for the product or UI and `omp` for its executable.
+_Avoid_: Claude Code, CC
+
+**native OMP endpoint** — an spt-hosted endpoint where `omp` owns a broker-held
+terminal and loads the **OMP SPT extension**. It may run unattended, but its
+native TUI remains attachable whenever an operator needs to observe or control it.
+_Avoid_: RPC bridge endpoint, non-interactive endpoint
+
+**OMP SPT extension** — the OMP runtime extension that binds a native OMP
+session to an SPT endpoint and owns message delivery, activity, replies, and
+lifecycle integration. It does not render or proxy the terminal.
+_Avoid_: Claude hook, RPC host, terminal bridge
+
+**ready OMP endpoint** — a native OMP endpoint that receives SPT messages
+without a Psyche.
+_Avoid_: OMP Worker
+
+**live OMP endpoint** — a native OMP endpoint whose SPT lifecycle includes a
+Psyche and durable mind continuity.
+_Avoid_: OMP Worker, treating every ready endpoint as live
+
+**delivery custody** — the interval after an OMP SPT extension accepts an
+inbound SPT message and before it either returns a correlated answer or reports
+an explicit failure to that sender. A message in custody is never silently
+dropped.
+_Avoid_: fire-and-forget delivery
+
+**message stub** — the short turn-opening prompt `<msg from="…"/>` used for
+an inbound peer message while the full SPT event envelope enters the same model
+turn as extension-provided context. The peer body is never interpreted as an
+OMP slash command.
+_Avoid_: typing the peer body directly into the OMP editor
+
+**bound OMP session** — the single OMP session owned by a native OMP endpoint
+for that endpoint's lifetime. Switching or resuming to another OMP session
+requires stopping and relaunching the endpoint rather than mutating the binding
+inside the TUI.
+_Avoid_: treating the endpoint id as a movable session selector
+
+**continuity drop** — a project-local commune or signoff file written under
+`.spt/` for spt-core to ingest into an endpoint's durable mind. The directory is
+harness-neutral; the filename identifies the endpoint and drop kind.
+_Avoid_: OMP config, `.claude` state
+
+**claude-spt** — the sister Claude Code adapter from which omp-spt was forked.
+Its plugin, hooks, ccs profiles, and Claude-specific lifecycle are lineage, not
+supported omp-spt surfaces.
+_Avoid_: treating claude-spt behavior as omp-spt capability
 
-**spt-claude-code** — the rebuilt Claude Code harness adapter. The `claude-spt`
-adapter in spt-core terms. Simultaneously spt-core's v1 acceptance proof (legacy
-parity), its first casual-end-user entrypoint (a CC plugin), and an invisible spt-core
-installer. Built by maintainer perri from the public spt-releases surface only.
-(Repo being renamed `spt-claude-code` → `claude-spt` per the naming-domain rule; see
-[[naming-domains]].)
-
-**claude-spt** — the adapter_name spt-claude-code registers under (rides every `api`
-invocation + the manifest). The CC adapter's identity inside spt-core. The
-**spt-core-facing** token (repo + adapter + consolidated binary). See [[naming-domains]].
-
-**naming-domains** — the two-token naming rule (ADR-0005): **`claude-spt`** is the
-spt-core-facing identity (repo, adapter, binary — `spt adapter … claude-spt`), and
-**`spt`** is the Claude-Code-facing identity (plugin + skills, `/spt:*`, via the
-`sptc`→`spt` succession). One token can't cover both because the adapter cannot be named
-`spt` (spt-core's own identity) while the skill prefix wants `/spt:*`. The `cc` launcher
-shortcut (`cc-<id>`) is decoupled from both.
-
-**legacy spt / `claude_skill_owl`** — the sister project; today's shipped CC integration
-(owl.exe + `spt` plugin, v1.11.25). The parity *target* (user-facing features), not a
-1:1 port — most of its machinery now lives in spt.exe.
-
-**skeleton plugin** — the thin marketplace artifact on `SaberMage/cplugs`: namespaced
-`/spt:*` skill stubs + hooks + a SessionStart bootstrap that installs spt-core. Low-churn;
-the volatile bulk (binary + manifest) is spt-core-conducted, not in the plugin.
-
-**fetch-stub skill** — a `/spt:X` SKILL.md that is a 2-line stub fetching its real
-instructions at runtime from the adapter `[strings]` (`spt adapter get-string`/`skill-help`).
-Keeps skill files static while instructions update via spt-core. Distinct from a `[hints]`
-entry (proactive, keyword-triggered, UPS-hook-delivered).
-
-**identity brief** — the agent-facing text the adapter injects at SessionStart into a session
-that already owns a perch (the `bind` + `boundary` topologies). Tells the agent who it is, that
-its perch is already live (so it must not re-arm), and how to message (send + reply + the endpoint
-roster). Adapter-string-backed (`[strings.briefs]`), composed from an `{id}`-templated identity
-piece plus shared messaging pieces. Liveness-agnostic: it does not distinguish live-vs-ready (that
-flavor is deferred until spt-core publishes a machine-readable liveness query). Distinct from the
-**ring brief** (the no-perch sibling).
-
-**ring brief** — the SessionStart counterpart for a session with **no** perch (the `seed`
-topology): a node-local agent that hasn't readied still learns how to reach other agents via
-`spt ring` (the no-id messaging path). Peer-gated — emitted only when the node actually
-participates in a subnet (has reachable peers), so a solo casual end user is never told how to
-ring agents that don't exist.
-
-**ccs profile** — a profile under spt-claude-code (`claude-spt:glm`, `claude-spt:kimi`)
-that leaf-replaces the launch command + history/digest log dir to use the `ccs` backend.
-NOT its own adapter — ccs is structurally Claude Code.
-
-**`cc` launcher (capsule-style)** — a generated `cc`/`cc <id>` script at project root that
-spawns-or-attaches a CC endpoint via spt-core's spt-hosted topology (broker PTY + inject +
-attach). The spt-core realization of legacy's unbuilt "Capsule" milestone. _Avoid_: equating
-it with psmux/sendkeys — spt-core's broker is the terminal host.
-
-**Psyche** — a LiveAgent's detached *companion* process. When a session goes live
-(`/sptc:live`), spt-core's daemon hosts a Psyche alongside it: the Psyche owns its own
-perch (`<parent>-psyche`), is woken by daemon *pulses*, and on each pulse authors a
-*commune*. It never replies or notifies (that is the echo-commune, a different actor) and
-exits at session end. A *ready* agent has no Psyche — live-vs-ready is the command, not a
-profile. (Realized here by the `claude-spt-psyche` runner.)
-
-**commune** — the context-delta a Psyche writes on each pulse: a brief that lets the
-parent agent resume coherently after a context wipe (`/clear` / compact). A file-drop the
-daemon ingests, not an `api` verb.
-
-**checkpoint** — a live agent's *self-initiated* context reset: the agent flags a commune to
-request that its own working context be wiped and rebuilt from that latest commune, so it
-continues coherently without the operator manually running `/clear`. The agent-driven sibling
-of the operator's manual clear; only meaningful for a live agent (which has a Psyche + a
-commune to rebuild from). See [[commune]].
-
-**checkpoint trigger** — the marker a live agent embeds in a commune to request a
-[[checkpoint]] (the request signal; distinct from the wire payload that carries it to the
-delivery layer, which is an implementation concern).
-
-**session name** — the operator-facing display name an spt-hosted endpoint carries in the
-harness TUI (prompt box / resume picker): the visual anchor tying a terminal to its agent.
-Shape: `<id> @ <node> (<project>/)`, degrading to bare `<id>` when the node is unknown.
-Distinct from the remote-control name (a character-safe token) and the endpoint id (spt-core's
-identity — attach/inject key by it, never by this name).
-
-**boundary rename** — re-asserting the [[session name]] on a `/clear` boundary. The harness
-drops the display name when a clear rotates the session, leaving the operator no rendered
-anchor; the adapter re-applies the same name to the fresh session, before any [[checkpoint]]
-wake lands. `/compact` retains the name, so it has no rename.
-
-**psyche sandbox** — the constrained surface a Psyche's `claude` turns run under:
-Read/Edit/Write tools only, slash-commands disabled, permissions auto-approved, cheap
-pinned model. Deliberately narrower than the parent agent (which is unconstrained). Mirrors
-legacy owl's psyche box; see `docs/adr/0003-*`.
-
-**casual end user** — a user who *uses* an spt-powered system mostly-invisibly, vs the
-adapter/shell *developer* who is spt-core's nominal target. spt-claude-code serves casual
-users: install the plugin, get spt-core for free.
-
-**experimplate** — the standalone reusable project-workflow template (its own sibling repo)
-extracted from spt-core's working style. spt-claude-code is its first consumer. Carries
-traceable-reqs gating, JIT plans, grill-with-docs scaffolding, release/changelog, and
-same-repo published-docs. Defined in its own folder, not here.
-
-**tagged-input round-trip** — the harness pattern where the translation binary types
-namespaced-XML-tagged content into the operator's *input box* without submitting, the operator
-edits the payload between the tags, and the UserPromptSubmit hook recognizes the tags on the
-resulting submit to consume the edited result. The binary-inject leg and the UPS leg are
-decoupled and *rendezvous on the tags*, not on a shared channel. Backs `/sptc:role`'s no-directive
-edit. Distinct from message injection (which auto-submits) and from an [[identity brief]]'s
-additionalContext (which the operator never edits).
-
-**interrupt marker** — the digest-visible signal that the operator pressed Esc to interrupt a
-turn: the session digest records a turn whose input is the literal `[Request interrupted by
-user]` (the normalized form of the TUI's "Interrupted · What should Claude do instead?"). The
-sole reliable idle-after-interrupt signal, since an Esc fires no `Stop` and no `idle_prompt`
-hook; the receive-heal keys off it to re-assert idle. Surfaced only on a digest pull (the
-fetcher re-reads the transcript), never daemon-pushed.
diff --git a/OMP-ADAPTER-PLAN.md b/OMP-ADAPTER-PLAN.md
index ed00bf7..23f6650 100644
--- a/OMP-ADAPTER-PLAN.md
+++ b/OMP-ADAPTER-PLAN.md
@@ -1,186 +1,192 @@
-# OMP-ADAPTER-PLAN — port claude-spt to oh-my-pi (omp)
-
-> Turn this fork of `claude-spt` into **omp-spt**: an SPT harness adapter for
-> **oh-my-pi (omp)** — the terminal coding agent at
-> [github.com/can1357/oh-my-pi](https://github.com/can1357/oh-my-pi), docs at
-> [omp.sh/docs](https://omp.sh/docs) / `docs/` in that repo. Local binary here:
-> `omp v16.3.11` (`C:\Users\Admin\AppData\Local\omp\omp.exe`, config `~/.omp`).
->
-> **Why:** the interim engine for the Athenaeum **Librarian** (Athenaeum
-> DESIGN.md D10) — a persistent, SPT-addressable agent — while spt-core does not
-> yet speak ACP. When/if spt-core gains an ACP client, an ACP bridge supersedes
-> this (omp's RPC mode is already ACP-shaped, so this is a stepping stone, not a
-> dead end).
-
-## The decisive finding: drive omp over its RPC mode, not by scraping hooks
-
-claude-spt exists because Claude Code has **no control protocol** — the adapter
-reverse-engineers CC's lifecycle through eight hooks (`SessionStart`,
-`UserPromptSubmit`, `PreToolUse`, `Stop`, …), scrapes the transcript for a
-digest, and pushes received messages back via `additionalContext`. Most of its
-version history (0.6→0.17, the `SPT_HARNESS_ADAPTER_TIPS.md` hazards, the
-echo-gate, force-native decay, truncation spills) is fighting that indirect,
-injection-based coupling.
-
-**omp has a native host-drives-agent surface that removes all of that:**
-`omp --mode rpc` (per `docs/rpc.md`) is a newline-delimited JSON protocol over
-stdio —
-
-| Direction | Frame |
-|---|---|
-| omp → host (on start) | `{ "type": "ready" }` |
-| host → omp (drive a turn) | `{ "type": "prompt", "message": "…" }` (acked immediately, `data.agentInvoked`) |
-| host → omp (mid-turn) | `{ "type": "steer", … }` (interrupt) · `{ "type": "follow_up", … }` (post-turn) |
-| omp → host (turn stream) | `agent_start` → `message_update`… → `agent_end` |
-| host → omp (introspect) | `{ "type": "get_state" }` → `sessionId`, `sessionFile`, model, tools |
-
-This maps **directly** onto what SPT needs from a driven agent:
-
-- **ready-agent** = a resident `omp --mode rpc`; each inbound SPT message →
-  `{type:"prompt"}`; `agent_end` → `spt api state idle`, `agent_start` →
-  `state busy`.
-- **live/psyche resume-turn** = the daemon (or bridge) sends one `{type:"prompt"}`
-  per event against the held session; continuity is omp's own session file + id.
-- **mid-turn delivery** = `steer` / `follow_up` — no `additionalContext`, no
-  truncation/echo-gate class at all.
-
-### Architecture decision: native TUI for hosted endpoints; RPC for headless callers
-
-**Style A — RPC bridge as a headless harness (RETAINED, NOT INTERACTIVE).** It
-spawns a small **bridge binary** (Rust, replacing `tools/claude-spt/`). The bridge
-runs `omp --mode rpc` as a child, and translates in both directions:
-
-```
-SPT daemon ──spawn──▶ omp-spt-bridge ──stdio JSON──▶ omp --mode rpc
-                          │  spt api seed/bind/poll/state/worker-*   (to spt-core)
-                          └  prompt/steer/follow_up/get_state        (to omp)
+# OMP adapter plan
+
+Status: **ratified clean cutover** (2026-07-14)
+
+`omp-spt` is the SPT harness adapter for
+[Oh My Pi](https://github.com/can1357/oh-my-pi). The supported product is a
+native OMP terminal session with SPT messaging and lifecycle behavior supplied
+by an OMP extension. The inherited alternate-harness plugin, hook/injection
+stack, RPC bridge, launcher aliases, and provider-wrapper profiles are not
+compatibility surfaces. ADRs
+[0008](docs/adr/0008-omp-native-product-boundary.md) through
+[0013](docs/adr/0013-release-gate-stops-at-the-adapter-boundary.md) are the
+ratified boundary.
+
+## Product architecture
+
+```text
+spt-core broker PTY
+        │
+        └── omp-spt launch-omp
+                 │ validates and execs/spawns
+                 ▼
+          native OMP TUI
+                 │ loads
+                 ▼
+       packaged omp-spt extension
+                 │
+                 ├── bind/listen/state/session-end
+                 ├── serialized delivery custody
+                 └── correlated reply or explicit failure
 ```
 
-This remains useful when no operator terminal is expected. It cannot satisfy an
-attached endpoint because `omp --mode rpc` creates no native TUI.
-
-**Style B — native omp loads an SPT extension (CHOSEN for `[session.self]`).** omp
-*does* have a hook system (`docs/hooks.md`): a TS factory `export default function
-hook(pi){ pi.on("session_start"|"turn_start"|"turn_end"|"tool_call"|"context"|
-"session_shutdown", …) }`, and the `context` event can inject via
-`return { messages }`. The delivered extension instead uses the public
-`sendUserMessage` action, so OMP handles the prompt normally while remaining the
-PTY leader. It binds/listens through SPT and routes the final assistant response
-to the sender.
-
-Rationale, in one line: **the process whose UI the operator must see must own the
-PTY.** See ADR-0007. <!-- [doc->REQ-OMP-NATIVE-TUI] -->
-
-## Seam map — claude-spt value → omp-spt target
-
-| Seam (manifest `adapter/claude-spt.toml` → `adapter/omp-spt.toml`) | claude-spt | omp-spt |
-|---|---|---|
-| `[adapter].name` / plugin ns | `claude-spt` / `sptc` | `omp-spt` / `omps` (or keep `sptc`? decide) |
-| `[adapter].host_binaries` | `["claude"]` | `["omp"]` (+ the bridge basename) |
-| `[adapter].shortcut_basename` | `cc` | `omp` |
-| `[adapter].kind` | `harness` | `harness` (unchanged) |
-| `[update].repo` / `avenue` | `SaberMage/claude-spt` / `gh_release` | `BigscreenVR/omp-spt` / `gh_release` |
-| `[session.self].command` (bringup) | `claude …` launcher | native `omp --extension …/omp-spt.mjs` |
-| `[identity].parent_ancestor_name` | `claude` | `omp` (or the bridge) |
-| `[digest]` source/extractor | CC `<root>/<cwd-slug>/<sid>.jsonl` | omp `~/.omp/agent/sessions/<dir-enc>/<ts>_<sid>.jsonl` |
-| `[session.psyche_resume].command` | `claude --continue -p` | bridge per-pulse `{type:"prompt"}` (or `omp -r <id> -p`) |
-| hook plugin `plugin/sptc/` | 8 CC hooks → `dispatch.sh` → binary | **removed** (RPC bridge owns lifecycle); optional omp-hook fallback |
-| provider/billing (#3) | n/a (CC key) | `~/.omp/agent/models.yml` OpenRouter provider (config artifact, below) |
-
-### Session/transcript (for the `[digest]` extractor)
-
-Per `docs/session.md`: omp writes **JSONL** at
-`~/.omp/agent/sessions/<dir-encoded>/<timestamp>_<sessionId>.jsonl`
-(`<dir-encoded>` = home-relative path, `/ \ :` → `-`; `--session-dir` overrides).
-Line 1 = header `{type:"session", id, timestamp, cwd, version}`; rest = entries
-`{type, id, parentId, timestamp}`, message entries carrying an `AgentMessage`
-(`role`, `provider`, `model`, `content`). `sessionId` = 8-hex; resume by id
-prefix / filename prefix. **This is close to CC's JSONL** — the extractor rework
-is: resolve the dir-encoding, parse header+entries, emit the neutral
-`{role∈input|agent|tool, text?, tool?, ts?}` NDJSON spt-core expects (UTF-8
-stdout — the Windows cp1252 trap from the tips doc applies).
-
-### Identity binding (no native endpoint-id flag)
-
-omp has no "inject an endpoint id" flag, but the bridge is the hosted process and
-can call `get_state` → `sessionId`, then `spt api bind <id> --set-session-id
-<sessionId>` (broker-spawned auth is intrinsic — tips doc §Bringup). Pass the SPT
-endpoint id into the bridge via `[env.SPT_ENDPOINT_ID]` (`direction="inject"`,
-`value="{id}"`).
-
-## Slices (ready-first, then live — mirroring how claude-spt itself grew)
-
-- **S0 — Rebrand.** `claude-spt`→`omp-spt` across manifest, `[update].repo`,
-  `host_binaries`, `shortcut_basename`, strings/labels, CI, docs headers. Keep the
-  version history but reset to a `0.1.0` omp-spt line (note the claude-spt lineage).
-- **S1 — Manifest skeleton + capability.** Fill `[adapter]`, `[session.self]`
-  (bridge command), `[identity]`. Prove with
-  `spt api --adapter omp-spt --manifest adapter/omp-spt.toml capability` (advertises
-  the hostable types) and a clean `spt adapter add` (manifest-first validation).
-- **S2 — RPC bridge (ready-agent).** New Rust bin (replaces `tools/claude-spt/`):
-  spawn `omp --mode rpc`, `ready`/`prompt`/`agent_end`↔`spt api seed/poll/state`.
-  Acceptance: from another node, message the perch → get an omp answer; assert
-  `spt` state transitions (isolated CI identity per tips doc §Testing).
-- **S3 — digest/history extractor.** omp-JSONL → neutral NDJSON; validate with
-  `spt adapter digest-proof omp-spt --sample <session.jsonl>`.
-- **S4 — live/psyche.** `[session.psyche_init]` gate + the bridge as the
-  per-event resume-turn runner; verify daemon-driven turns don't starve.
-- **S5 — OpenRouter provider (#3).** Ship a documented `models.yml` fragment +
-  `.env` convention; **no adapter code** (see below). Role routing
-  (default/smol/slow/plan) + fallback chains are native.
-
-## #3 OpenRouter billing — it's omp config, not adapter code
-
-Per `docs/providers.md`, `~/.omp/agent/models.yml` takes custom
-openai-completions providers; OpenRouter is:
-
-```yaml
-providers:
-  openrouter:
-    baseUrl: https://openrouter.ai/api/v1
-    api: openai-completions
-    apiKey: OPENROUTER_API_KEY   # env-var-name-or-literal
-    models:
-      - id: anthropic/claude-sonnet-5
-        name: Claude Sonnet 5 (OpenRouter)
-        contextWindow: 200000
-        maxTokens: 8192
+The process whose interface the operator sees owns the PTY. The launch shim may
+resolve and validate the real OMP executable, but it must not become a second
+terminal application. Every hosted endpoint is therefore attachable as the
+same native OMP TUI whether it is currently attended or unattended.
+<!-- [doc->REQ-OMP-NATIVE-TUI] -->
+
+Bare `omp` lookup is not trusted: another executable may own that basename.
+Resolution must identify a genuine Oh My Pi binary, fail loudly on ambiguity or
+collision, and preserve OMP's terminal ownership after launch.
+<!-- [doc->REQ-OMP-EXECUTABLE-RESOLUTION] -->
+
+## Public SPT contract
+
+The adapter uses only the two seams in the published
+[SPT integration checklist](https://sabermage.github.io/spt-releases/harness-contract/integration-checklist.html):
+the declarative manifest and imperative `spt api` commands. No private
+spt-core source, SDK, state schema, or transport implementation is an adapter
+dependency.
+
+### Register
+
+- `[adapter]` identifies `omp-spt`, declares `kind = "harness"`, and advertises
+  only `ReadyAgent` and `LiveAgent`.
+- `host_binaries = ["omp"]` is the bind-time harness match. The adapter helper
+  binary is intentionally absent so it cannot collide with or impersonate the
+  hosted TUI.
+- `shortcut_basename = "omp"` brands picker-generated launchers.
+- The manifest validates against the published schema and then passes the
+  public `spt adapter add` cross-field validation.
+<!-- [doc->REQ-DIST-MANIFEST-SCHEMA] -->
+
+### Start and resume
+
+- `[session.self]` starts `launch-omp` with the packaged extension.
+- `[session.resume]` uses the same path plus OMP's native resume argument.
+- `SPT_ENDPOINT_ID` is broker-injected. Once OMP reports its actual session id,
+  the extension performs the public `api bind <id> --set-session-id <sid>`
+  startup half.
+- The endpoint/session association is immutable while the endpoint is alive.
+  In-TUI switch, branch, new-session, and resume actions are blocked. Changing
+  sessions requires stopping and relaunching the endpoint with an explicit
+  native-resume target.
+<!-- [doc->REQ-OMP-SESSION-IMMUTABLE] -->
+
+### Run
+
+The extension owns a delivery from receipt until exactly one terminal outcome:
+a correlated reply to the sender or an explicit failure reply. Deliveries are
+serialized so sender and reply custody cannot cross. Submission rejection
+advances the queue only after the sender has been told what failed.
+<!-- [doc->REQ-OMP-EXTENSION-CUSTODY] -->
+
+Each accepted peer message opens an ordinary OMP turn with a short
+`<msg from="…"/>` user-visible stub. The complete SPT `<EVENT …>…</EVENT>`
+envelope is supplied as context for that same turn. Peer text remains opaque
+content; a message beginning with an OMP slash command cannot become local
+operator input.
+<!-- [doc->REQ-OMP-MESSAGE-CONTEXT] -->
+
+OMP lifecycle events drive honest `busy`/`idle` state. If the listener exits,
+the extension retries with a finite backoff schedule. Exhausting the schedule
+ends the SPT session and shuts down the hosted OMP process loudly; a dead
+delivery path must never remain advertised as healthy.
+<!-- [doc->REQ-OMP-LISTENER-FAIL-CLOSED] -->
+
+### End
+
+Normal OMP shutdown causes the extension to release the listener and call the
+public session-end seam. Listener exhaustion uses the same teardown path before
+closing OMP. SPT retains spool and history according to its published lifecycle
+contract.
+
+## ReadyAgent and LiveAgent
+
+`omp-spt` supports exactly two endpoint types:
+
+- **ReadyAgent** — native OMP plus extension-owned messaging, without a Psyche.
+- **LiveAgent** — the same native endpoint with the manifest's go-live gate and
+  bounded `[session.psyche_resume]` turns.
+
+The Psyche is not a resident second endpoint. Each invocation is one bounded
+headless OMP turn using the core-written context file and its own private OMP
+session directory, then exits. OMP subagents are not advertised as independent
+SPT Workers.
+<!-- [doc->REQ-OMP-READY-LIVE] -->
+<!-- [doc->REQ-PSYCHE-EPHEMERAL-SHIM] -->
+
+## History, digest, and continuity
+
+OMP session JSONL is authoritative:
+
+```text
+~/.omp/agent/sessions/<encoded-cwd>/<timestamp>_<session-id>.jsonl
 ```
 
-Key precedence (first wins): CLI `--api-key` → `models.yml apiKey` → stored cred →
-OAuth → provider env/`.env` → fallback resolver. `.env` layering:
-`cwd/.env` → `~/.omp/agent/.env` → `~/.omp/.env` → `~/.env`. So the adapter's job
-for #3 is only to (a) ship/document this fragment and (b) select roles to the
-OpenRouter models at Librarian bringup — the billing routing itself is omp's.
-
-## Open questions — verify against the live `omp` + `spt` binaries
-
-Per the tips doc discipline (JSON-schema validity ≠ runtime; validate on the live
-binary), confirm before/while building:
-
-1. **RPC session lifecycle across turns** — does a resident `omp --mode rpc` hold
-   one session for many `prompt`s (ready-agent), and can the bridge start it on a
-   *resumed* session id for the live path? (`get_state` + `switch_session`/
-   `new_session`/`branch` in `docs/rpc.md`; test locally.)
-2. **Daemon hosting a resident bridge** — spt-core's broker spawns
-   `[session.self].command` into a PTY; confirm a bridge that itself holds a child
-   `omp --mode rpc` survives as the hosted process (vs the ephemeral per-event
-   psyche model). Decide ready-resident vs live-ephemeral per role.
-3. **dir-encoding exactness** — reproduce omp's `<dir-encoded>` rule precisely for
-   the digest locate (home-relative, `/ \ :`→`-`); handle `--session-dir` override.
-4. **Hook fallback need** — anything the RPC stream doesn't expose that we still
-   want (e.g. `tool_call` gating, `session_shutdown` cleanup) → a thin omp hook
-   extension (Style B, `docs/hooks.md`).
-5. **min spt-core floor** — which `spt api` verbs the bridge uses, and the honest
-   `min_spt_core_version` (claude-spt is at 0.27.0; omp-spt only needs the verbs S2
-   actually calls).
-
-## Validation harness (all on the public surface, no live model needed)
-
-- `spt api --adapter omp-spt --manifest <file> capability` — hostable-types check.
-- `spt adapter add adapter/` → `spt adapter list` (adapter + profiles resolve) →
-  `spt adapter get-string` (base + overlay diffs) → `spt adapter remove`.
-- `spt adapter digest-proof omp-spt --sample <omp-session.jsonl>` — extractor E2E.
-- Acceptance: spawn a real `omp --mode rpc` as SUT under a **disposable identity**
-  (never the operator's — perches are name-keyed, last-establish-wins); assert on a
-  hook/state side-effect, not model output.
+- `[history] strategy = "fetcher"` locates the session by id and streams its
+  OMP JSONL for the bounded summarizer.
+  <!-- [doc->REQ-HISTORY-FETCHER] -->
+- `[digest] strategy = "fetcher"` maps OMP records to SPT's neutral
+  `{role,text,tool,ts}` NDJSON contract. Delivered user-facing messages remain
+  turn-opening input records so digest cursors retain turn granularity.
+  <!-- [doc->REQ-DIST-DIGEST-EXTRACTOR] -->
+- `[session.echo_commune]` self-locates history and prints one bounded context
+  delta on stdout; spt-core owns the file drop, ingest, and deletion.
+  <!-- [doc->REQ-SESSION-ECHO-COMMUNE] -->
+
+Commune and signoff drops live under project-local `.spt/`. The published
+v0.29.0 echo-commune contract resolves a relative watched directory against the
+endpoint's recorded working directory, never the daemon cwd, and warns rather
+than guessing when no endpoint cwd exists. This behavior is why the honest
+`min_spt_core_version` is **0.29.0**.
+<!-- [doc->REQ-OMP-CONTINUITY-DROPS] -->
+
+## Distribution and update
+
+The adapter id, binary, and repository are all `omp-spt` /
+`BigscreenVR/omp-spt`. A multi-platform `adapter.spt` contains the shared
+manifest and extension plus the platform tool binary. `[update]` uses the
+published `gh_release` avenue. There is no secondary plugin reconciliation or
+reload step.
+<!-- [doc->REQ-DIST-ADAPTER-RELEASE] -->
+
+## Skill delivery gap
+
+No OMP-native command/skill distribution path has been proven for this
+adapter. Consequently, no command skills are shipped or advertised. Generic
+SPT operations remain available through the public `spt` CLI. Adding OMP
+commands later requires an explicit OMP extension registration and packaging
+contract plus focused tests; a foreign plugin mechanism is not an acceptable
+substitute.
+
+## Release verification
+
+Deterministic checks cover the extension, launch resolver, manifest/schema,
+Psyche, history, digest, echo-commune, and archive shape. The release gate then
+uses one disposable **same-node** endpoint to prove:
+
+1. fresh native bringup and attachable TUI;
+2. message → ordinary OMP turn → correlated reply;
+3. honest busy/idle state and graceful shutdown;
+4. native resume and immutable in-TUI binding;
+5. bounded listener recovery and fail-closed teardown;
+6. both ReadyAgent and LiveAgent behavior.
+
+Cross-node transport is not an adapter gate. Once same-node delivery has crossed
+the public SPT message seam, subnet transport belongs entirely to spt-core and
+adds no OMP harness contract.
+
+## Completion status
+
+| Slice | Status |
+|---|---|
+| OMP-native product boundary | Accepted — ADR-0008 |
+| Native TUI for every endpoint | Accepted — ADR-0009 |
+| Custody and bounded listener recovery | Accepted — ADR-0010 |
+| Immutable endpoint/session binding | Accepted — ADR-0011 |
+| Project-local `.spt/` continuity | Accepted — ADR-0012 |
+| Same-node adapter release gate | Accepted — ADR-0013 |
+| Foreign plugin/hooks, RPC bridge, compatibility profiles | Removed from supported scope |
+| OMP-native skill distribution | Public-contract gap; not shipped |
diff --git a/README.md b/README.md
index 688a9e8..4e64937 100644
--- a/README.md
+++ b/README.md
@@ -1,81 +1,103 @@
-<!-- Install UX — every command real and copy-paste-correct per OS (DOCS-STRATEGY #1/#3).
-     Repo slug SaberMage/claude-spt (renamed from spt-claude-code, U3). [doc->REQ-DIST-INSTALL-UX] -->
-# claude-spt
+<!-- Install UX: every command is real and copy-paste-correct per OS (DOCS-STRATEGY #1/#3).
+     Release repository: BigscreenVR/omp-spt. -->
+# omp-spt
 
-SpT's official adapter for Claude Code. Run your own named "live agents" to gain agent-to-agent messaging, durable context lifecycles, and more.
+`omp-spt` is the native [Oh My Pi](https://github.com/can1357/oh-my-pi) adapter for
+[Spacetime (`spt-core`)](https://sabermage.github.io/spt-releases). It lets `spt-core` host named
+`ReadyAgent` and `LiveAgent` endpoints in OMP's own terminal interface, with agent-to-agent
+messaging, session continuity, history, digests, and live-agent context lifecycles.
 
-This Claude Code plugin is built atop `spt-core` for its resource interop and lifecycle management layers. SpT helps devs pave a path for their preferred LLM(s) + harness(es) to interact with and remember a variety of tools and role-bound agents. Its construction draws only from `spt-core`'s public surfaces: [`SaberMage/spt-releases`](https://github.com/SaberMage/spt-releases) + [its official docs](https://sabermage.github.io/spt-releases). Hence it serves to be the exemplary harness adapter for future adapters to follow.
+Native OMP owns the attachable TUI and its broker PTY. The packaged OMP extension handles endpoint
+binding, message delivery, busy/idle state, replies, and shutdown from inside that native session.
+The release is one fat `adapter.spt` archive containing the supported adapter binaries and
+`adapter/strings/omp-spt.mjs`.
 
-For Claude Code, this adapter installs an `sptc` plugin. All skills reside under the `/sptc:*` namespace.
+## Prerequisites
 
-## Install
+- [Oh My Pi](https://github.com/can1357/oh-my-pi), providing the `omp` command.
+- [`spt-core`](https://sabermage.github.io/spt-releases), version 0.29.0 or newer, providing the
+  `spt` command.
+
+There is no plugin installation step. Install OMP and `spt-core`, then add the adapter release.
 
-### Method A: Terminal installation
+## Install
 
-Claude Code must already be installed. Pick your shell:
+Pick your shell. These commands install either prerequisite only when it is missing, then install
+`omp-spt` from `BigscreenVR/omp-spt`.
 
 **PowerShell (Windows)**
 
 ```powershell
+if (-not (Get-Command omp -ErrorAction SilentlyContinue)) { irm https://omp.sh/install.ps1 | iex }
 if (-not (Get-Command spt -ErrorAction SilentlyContinue)) { irm https://sabermage.github.io/spt-releases/install.ps1 | iex }
-spt adapter add --release SaberMage/claude-spt
+spt adapter add --release BigscreenVR/omp-spt
 ```
 
 **cmd (Windows)**
 
 ```bat
+where omp >nul 2>nul || powershell -NoProfile -Command "irm https://omp.sh/install.ps1 | iex"
 where spt >nul 2>nul || powershell -NoProfile -Command "irm https://sabermage.github.io/spt-releases/install.ps1 | iex"
-spt adapter add --release SaberMage/claude-spt
+spt adapter add --release BigscreenVR/omp-spt
 ```
 
 **bash (macOS / Linux / Git Bash on Windows)**
 
 ```bash
+command -v omp >/dev/null 2>&1 || curl -fsSL https://omp.sh/install | sh
 command -v spt >/dev/null 2>&1 || curl -fsSL https://sabermage.github.io/spt-releases/install.sh | sh
-spt adapter add --release SaberMage/claude-spt
+spt adapter add --release BigscreenVR/omp-spt
 ```
 
-To get `spt` to pick up as a command in your terminal after the install script, open a fresh shell.
+If an install script adds a command that the current terminal cannot see yet, open a fresh shell
+before continuing.
 
-### Method B: Copy-paste agent prompt
+## Quickstart
 
-Hand this to a coding agent (Claude Code, etc.) to install everything in one go:
+Create a named endpoint and attach to its native OMP TUI:
 
-```text
-Install claude-spt from SaberMage on GitHub.
+```bash
+spt endpoint run --adapter omp-spt --id librarian --create
 ```
 
-**Agents start here:**
-> Ensure Claude Code is installed as it is a prerequisite. Then, run this in one bash call, in order:
-> `spt adapter list` line for `claude-spt`:
->
-> ```bash
-> command -v spt >/dev/null 2>&1 || curl -fsSL https://sabermage.github.io/spt-releases/install.sh | sh
-> spt adapter add --release SaberMage/claude-spt
-> spt adapter list | grep claude-spt
-> ```
-> Report the outcome to your operator. Advise them to create their first live agent by opening a fresh terminal and entering the `spt` command.
-
-## Usage
+`librarian` is an example endpoint id. The canonical form is
+`spt endpoint run --adapter omp-spt --id <id> --create`.
 
-After installation, get started by opening a fresh terminal. Run the `spt` command to create your first endpoint - a home for your live agent.
+The command creates the endpoint when needed, launches OMP with the packaged extension, and
+attaches the terminal to OMP's native interface. Native attach is the default, so do not add a
+separate start flag. `omp-spt` can host both `ReadyAgent` and `LiveAgent` endpoint roles.
 
-SpT is great for a single agent who builds a long-running project... The SpT magic *really* begins when you have more than one endpoint (live agent) operating on either one node (device), or multiple nodes in an SpT subnet (mesh network). Learn more here: https://github.com/SaberMage/spt-releases. I highly recommend pointing your agent to these repositories and asking it to explain whatever you want to understand!
+Start with the [full quickstart](docs-site/src/quickstart.md) for the launch lifecycle and update
+flow.
 
 ## Updating
 
-One lever keeps the adapter current — symmetric with install:
+Update the installed adapter:
+
+```bash
+spt adapter update omp-spt
+```
+
+OMP loads the packaged extension on each endpoint bring-up. A running endpoint keeps its current
+version until restarted:
 
 ```bash
-spt adapter update claude-spt
+spt endpoint stop librarian
+spt endpoint run --adapter omp-spt --id librarian
 ```
 
-After a version update, spt-core prints the next step. Run **`/reload-plugins`** in Claude Code to pick up refreshed skills/hooks.
+Replace `librarian` with your endpoint id.
 
-## Deeper docs (warning: outdated)
+## Documentation
 
-- [Quickstart](docs-site/src/quickstart.md) — install → bring-up → reachable, under ten minutes.
-- [Harness contract](docs-site/src/reference/harness-contract.md) — how Claude Code hook events map onto `spt`.
-- [`SCOPE.md`](SCOPE.md) · [`CONTEXT.md`](CONTEXT.md) · [`docs/adr/`](docs/adr/) — decisions and the domain model.
+- [Introduction](docs-site/src/introduction.md): what `omp-spt` owns and how it fits OMP and
+  `spt-core`.
+- [Quickstart](docs-site/src/quickstart.md): install, create, attach, and update.
+- [Native integration contract](docs-site/src/reference/harness-contract.md): launch, binding,
+  delivery, replies, role behavior, and shutdown.
+- [`spt-core` documentation](https://sabermage.github.io/spt-releases): endpoints, messaging,
+  subnets, lifecycle management, and the public adapter contract.
+- [Oh My Pi](https://github.com/can1357/oh-my-pi): OMP installation and native TUI usage.
 
-The `claude-spt` project is an intentional dogfeeding of the `spt-core` developer ecosystem and experience. While building this project, capabilities found to be defunct or missing from `spt-core`'s docs or API are used to improve the public-facing `spt-core` dev experience.
+The adapter is built against `spt-core`'s published release, manifest, and CLI surfaces. That keeps
+`omp-spt` independently installable while preserving the standard Spacetime endpoint model.
diff --git a/SCOPE.md b/SCOPE.md
index 55d84e3..2232373 100644
--- a/SCOPE.md
+++ b/SCOPE.md
@@ -1,215 +1,87 @@
-# spt-claude-code — scoping decision ledger
-
-> Running source of truth for the scoping session (started 2026-06-13, doyle).
-> Decisions marked **LOCKED** are user-ratified; **OPEN** are still in grill.
-> This project will be re-homed onto the `experimplate` template structure once
-> that template is authored — until then this ledger is the interim record.
-
-## What this project is
-
-**LOCKED.** `spt-claude-code` is the rebuilt Claude Code harness adapter (the
-`claude-spt` adapter) — simultaneously:
-1. spt-core's **v1 acceptance proof** (feature parity with legacy `claude_skill_owl`,
-   delegating all core to `spt.exe`).
-2. spt-core's **first casual-end-user entrypoint** — published as a CC plugin on
-   `SaberMage/cplugs`, like legacy spt today.
-3. Invisibly an **spt-core installer** for users who don't have it. This is the
-   intended pattern for *all* casual-facing harness/shell adapters.
-
-Parity is **user-facing feature parity, NOT 1:1** — most legacy machinery moved
-INTO spt.exe/daemon; the adapter is the CC-specific shell only. Dead/rare legacy
-concepts get dropped (parity-trim → REQ seed, OPEN). Built by maintainer **perri**
-from `SaberMage/spt-releases` + GH Pages docs ONLY (public surface), never the
-spt-core source tree.
-
-Legacy parity inventory: captured in this session (claude_skill_owl v1.11.25 —
-7 hooks, 12 `/spt:*` skills, owl.exe, cplugs marketplace; messaging / live-agent /
-working-perches / binary-handoff / psyche-sync / doctor).
-
-## Distribution architecture
-
-**LOCKED.** Split by volatility (Claude Code has NO plugin-file integrity check —
-in-place edits don't orphan; only old version dirs orphan on update, GC'd 7d):
-
-| Layer | Contents | Home | Update path | Churn |
-|---|---|---|---|---|
-| Plugin (marketplace) | namespaced `/spt:*` skill *skeletons*, `hooks.json` (call `spt api`), SessionStart bootstrap (installs spt-core if absent), `plugin.json` | `SaberMage/cplugs` | `claude plugin update` (rare structural changes only) | low |
-| spt binary | all logic | spt-core domain | spt-core's own framework (signed, peer-propagated) | high |
-| CC adapter manifest | `[digest]` extractor, profiles, strings, hints | spt-core adapter registry (NOT plugin files) | spt-core adapter-update (file-pull) | medium |
-
-- Skills stay **plugin-provided** → keep `/spt:` namespace (user-scope skills can't
-  namespace: `~/.claude/skills` → bare `/live`, collision-prone). Rejected global-skills.
-- The "bulk" spt-core installs/updates = **manifest + binary**, not the skills.
-- Plugin is a true thin skeleton (wrappers + bootstrap) → rarely needs a marketplace bump.
-- → ADR-0001 (to write).
-
-### Skill-instruction delivery — **LOCKED: UPS-injection** (fetch-stub VETOED)
-
-A `UserPromptSubmit` hook detects `/spt:X` in the prompt and injects X's real
-instructions as additionalContext. SKILL.md files stay skeletons; instruction churn
-lives in spt-core-conducted `[strings]` (file-backed — see M12 dep).
-- **fetch-stub VETOED** (operator): adds terminal noise + latency + an extra tool call.
-- UPS-injection chosen on operator's empirical confidence from legacy: UPS *does* pick up
-  slash-commands (CC highlights slash-commands anywhere in the entry field and isn't strict
-  about trailing text). My fact-check called this undocumented/uncertain — **must confirm
-  empirically at build time**, but design on it.
-- Long instruction bodies → **file-backed adapter strings** (M12 spt-core dep #1) so the
-  manifest doesn't bloat.
-- `[hints]` channel (same UPS hook, keyword-triggered) kept as-is — legacy proves it works.
-
-### Update notification — **LOCKED**
-
-spt-core conducts updates seamlessly → users don't check. Version-of-truth =
-manifest/binary version spt-core tracks (`spt adapter list` / `/spt:version`), NOT the
-~static marketplace skeleton version. On update applied: spt-core announces via one-time
-SessionStart additionalContext (changelog) + optional `notify`. Update path = file-pull
-(real channel) + cautionary `claude plugin update` (skeleton sync) — dual, kept in sync.
-
-## ccs integration
-
-**LOCKED.** ccs = **profile(s) under spt-claude-code** (`claude-spt:glm`,
-`claude-spt:kimi`, …), NOT its own adapter. It's structurally CC — only launch command +
-model/billing backend differ, which is exactly the profile seam (leaf-replace
-spawn/psyche/echo command templates). Per-profile `~/.ccs` log dir → profile also
-leaf-replaces the history/`[digest]` locate-template. **Hybrid** delivery: ship the
-profile *templates* (ccs-invoking command structure), user supplies own ccs config/keys.
-Reconcile spt-core CONTEXT.md: cross-adapter fallback must target `<adapter>:<profile>`,
-not only bare adapter_name (profile model already supports composite addressing).
-
-## `/spt:setup` skill
-
-Needed because most users install the plugin **mid-session** (no SessionStart fire).
-Proposed paths:
-1. Generate `cc`/`cc <id>` launcher (capsule-style) at project root
-2. Offer `.gitignore` the launchers
-3. Offer create first subnet — surfaces a **QR code** of the TOTP seed → spawns a window
-   (self-elevating; see elevation + M12 dep #2)
-4. If spt-core already installed → branch: new subnet / **join subnet (= add this machine)** /
-   show join-code / just-add-endpoint  *(join == add-this-machine — collapsed)*
-5. Legacy migration — detect claude_skill_owl/owl → migrate identity+agents+psyche
-   (spt-core CONTEXT.md first-class commitment)
-6. OS-service registration (always-on daemon)
-7. ccs profile wiring — if `~/.ccs` present; **also offer to install ccs** (+1-sentence value
-   prop) if absent
-8. Psyche cross-machine sync — **in-subnet sync is AUTOMATIC** (confirmed, M4-D6c); only the
-   optional off-subnet/hub-mode backup remains, retired-as-default → near-zero v1 surface
-9. Doctor/verify at end
-
-**LOCKED:** v1 = {1,2,3,4,5,6,7}, defer {8,9}. Item #1 (`cc` launcher) IS in v1 — depends on
-full-fat M12 (gating prerequisite, todlando-built before perri starts). `cc` wraps
-`spt endpoint run` defaulted to claude-spt. _Operator "9. agree" then "except 9" — deferred 9;
-flag if verify should fold inline._
-
-### `cc` launcher (capsule-style) — **LOCKED (design)**
-
-= thin wrapper over spt-core's **spt-hosted topology** (broker PTY + inject + attach),
-NOT a reimplemented psmux. `cc <id>` → `spt` spawns-or-attaches a CC endpoint in a broker
-PTY. Reattach-if-exists / `--live` / `--resume` = spt-core spawn/resume seam semantics.
-No-id picker = reuse spt-core's built-in id-resolution (don't reimplement legacy SEED-001).
-Sendkeys hazards = spt-core's inject concern, not the adapter's.
-**OPEN gap:** confirm spt-core "remote attach" covers *local user interactive attach* to a
-hosted CC session (not just headless PTY).
-
-### Elevation (subnet create/join/show-totp) — **LOCKED (design)**
-
-Detect (interactive? elevated? desktop?) → least-friction path:
-Windows = self-elevating UAC window; Linux+desktop = pkexec/polkit or x-terminal-emulator;
-Linux+TTY = inline sudo; headless/no-TTY = print exact command, agent relays to user.
-Question the premise: scope elevation to only steps that need it (service-install /
-firewall / privileged-port) — subnet-create itself likely unprivileged.
-
-## CI model
-
-**LOCKED.** Wholly **agent-driven, autonomous, no LLM-in-the-loop**, on the existing
-Win+Linux fleet (hfenduleam + kitsubito). GH runners DROPPED.
-- Gates (build, unit, `traceable-reqs check`, manifest-schema) = deterministic scripts.
-- Acceptance = scripted orchestration spawning real `claude`/headless sessions as the
-  **system-under-test** (LLM is SUT, never the runner); assert spt-state/digest output.
-- **Reporting bus = legacy spt** (`$OWL send` CI progress to responsible agent) — dogfoods
-  the product as its own CI nervous system.
-- Rationale: a stock GH runner physically can't run Claude Code (auth/interactivity);
-  only a real harness on the fleet reaches the acceptance bar. spt-core's GH-runner
-  justification (heavy multi-platform Rust + signed releases + two-host net) doesn't carry
-  — the adapter binary is thin glue and delegates releases/signing to spt.exe.
-- **Trigger (LOCKED):** git post-push hook → `$OWL send` pings a fleet runner-agent → runs
-  gates → reports over spt. Manual "run gates" = fallback. (Polling rejected: latency + waste.)
-  - **NOTE:** the `$OWL send` (legacy spt) binary location must be discovered flexibly — it
-    lives in a per-version `~/.claude/` or `~/.ccs/` plugins folder whose path changes each
-    version. No further legacy-spt changes anticipated, but the CI bus must locate it robustly.
-- This CI pattern → reusable, goes in `experimplate`.
-
-## Parity-trim (→ REQ seed / acceptance bar)
-
-**DROP** (LOCKED): Spine & Touch; binary-handoff/owl.exe trampoline; TCP transport + SQLite
-spool + registry + listener internals; localhost-only networking. (all spt.exe/daemon now)
-
-**TRANSFORM** (LOCKED): Capsule→spt-hosted + `cc`; echo-commune Haiku JSONL→`[digest]`
-extractor (M10); psyche-sync→subnet/`/spt:setup`; `doctor`→`spt doctor`/setup-verify;
-working-perches→`api worker-start/stop`.
-
-**ADD** (LOCKED): `/spt:setup`, `/spt:version`, subnet skills (create/join/show-code),
-profiles + strings + hints wiring, ccs profiles.
-
-**DECIDE** (LOCKED): DROP `/spt:fork` + `amend-signoff`. (fork near-unused & only meaningful
-harness-hosted; amend-signoff deprecated, folds into a follow-up commune)
-
-**KEEP — FINALIZED** (post-investigation 2026-06-14):
-- `/live`, `/commune`, `/ready`, `/send`, `/new-alarm`, `/list-agents` — KEEP. (`/list-agents`
-  → `spt endpoint list`.)
-- `/signoff` — KEEP. v1 = harness-hosted semantics (writes file; consumed at teardown). The
-  spt-hosted "drop user from PTY" UX only applies once `cc`/local-attach lands (fast-follow).
-- `/force-stop` — KEEP, topology-aware. spt-hosted routing already has CLI: `spt endpoint
-  shutdown` (graceful) + `spt endpoint stop` (soft), both exist.
-- `/revive` — **DROP.** Daemon owns psyche-loop + liveness (no orphan/dead-listener states to
-  recover); restart = re-`ready`/re-`listen` or `endpoint stop`+bringup. Confirm.
-- `/clear-psyche` — **DROP.** Equivalent = delete + recreate endpoint. Confirm.
-- `/whoami` — **DROP skill**. Core `spt whoami` STAYS in hot-path but → **becomes an alias for
-  `spt endpoint list`** (M12), whose SELF-pin output gains the Self `endpoint description`.
-
-### v1 topology scope — **LOCKED** (operator vetoed harness-hosted-only)
-v1 acceptance = legacy parity **AND** cross-subnet/PTY proof (spt-core's central value prop is
-networking + PTY ownership). So **spt-hosted mode + local PTY attach + `spt endpoint run`
-picker are MANDATORY v1.** → `cc` launcher is IN v1; `/spt:setup` #1 back in v1.
-**Gating prerequisite: full-fat M12 (todlando builds it after this grill, BEFORE perri starts
-spt-claude-code).** M12 deliverables incl. `spt endpoint run` (picker — see
-`../spt-core/M12-ENDPOINT-RUN-PICKER.md`) + `spt rc` (cross-node PTY connect) + whoami→alias.
-
-## spt-core upstream deps
-Recorded in `../spt-core/M12-CANDIDATES.md` (1: file-backed strings · 2: subnet QR +
-self-elevating window · 3: spt-hosted bringup + PTY attach · 4: fallback targets
-adapter:profile · 5: whoami obsolescence). spt-claude-code blocks on these.
-
-## experimplate (template) — resolved content
-- **Release procedure = generic shape + placeholders** (CHANGELOG · version bump · tag · GH
-  Release on same repo); project fills publish specifics. spt-claude-code's publish = cplugs
-  marketplace + spt-core adapter-registry; **release is light — signing delegated to spt.exe**
-  (not spt-core's two-key/counter runbook).
-- **Docs = same-repo `docs-site/` → GH Pages, mdBook, CI-gated against drift.** Reuse
-  **spt-core's docs CSS / page-layout / styling as a shared transferable theme** (it's strong;
-  carry it across all consumer projects). DOCS-STRATEGY reframed separate-repo→same-repo.
-- AGENTS.md = source of truth + thin `CLAUDE.md`=`@AGENTS.md` stub.
-- Must teach acquisition of `traceable-reqs` + the grill-with-docs skill (toml/INSTANTIATE).
-
-## Decisions — 2026-06-18
-
-- **`claude-spt:deep` profile REMOVED — LOCKED.** It was a placeholder (digest `window_turns=20`
-  + a label leaf) that forked nothing real; it existed only to demonstrate overlay-observability,
-  which `:ccs` already proves. `:ccs` is now the **sole shipped overlay**. Reversible (re-add a
-  profile any time) — recorded so the absence reads as intent, not omission.
-- **Non-interactive spt-spawned CC carries `--dangerously-skip-permissions` — LOCKED.** Both
-  `[session.self]` bringup commands (base `claude`, the `ccs` profile) pass it: the broker spawns CC
-  into a PTY with no operator, so the permission gate would deadlock the launch. Same root cause as
-  the Psyche (below); cross-cutting invariant in `docs/KNOWN-HAZARDS.md` §2.2.
-- **Psyche runs sandboxed at legacy-owl parity — LOCKED (→ `docs/adr/0003-*`).** Every
-  `claude-spt-psyche` turn (seed + each pulse): `--tools Read,Edit,Write --disable-slash-commands
-  --dangerously-skip-permissions --model sonnet --fallback-model opus --effort medium`. Bounded
-  blast radius + no detached-deadlock; mirrors `claude_skill_owl`. Closes a parity gap (psyche was
-  previously bare `claude`).
-
-## Open threads (grill queue)
-
-- [ ] CI trigger mechanism (git-hook signal vs polling routine)
-- [ ] Handoff framing to perri (package presentation + public-surface-only constraint)
-- [ ] Docs split: what lands in experimplate vs spt-claude-code
-- [ ] experimplate authoring: finalize skeleton + write INSTANTIATE.md
-- [ ] (downstream) confirm `/spt:setup` #9 verify fold-inline vs deferred
+# omp-spt scope
+
+Status: **locked** (2026-07-14)
+
+## Product
+
+`omp-spt` is the OMP-native SPT harness adapter. It starts or resumes a native
+Oh My Pi TUI inside an spt-core broker PTY and loads a packaged OMP extension
+that owns messaging and lifecycle integration.
+
+The public surface is deliberately narrow:
+
+- adapter id and binary: `omp-spt`;
+- release repository: `BigscreenVR/omp-spt`;
+- host application: Oh My Pi (`omp`);
+- endpoint types: `ReadyAgent` and `LiveAgent`;
+- distribution: one multi-platform `adapter.spt`;
+- updates: the manifest's `gh_release` avenue.
+
+## In scope
+
+1. **Native hosted sessions**
+   - Fresh and native-resume launch through a validating shim.
+   - OMP remains the terminal owner and renders the attachable TUI.
+   - The extension binds the real OMP session id to the requested endpoint.
+
+2. **Extension-owned delivery**
+   - One serialized custody queue.
+   - Message stub plus the full SPT event context in the same OMP turn.
+   - Correlated reply or explicit failure for every accepted delivery.
+   - Honest busy/idle state.
+   - Bounded listener restart followed by loud session teardown and OMP
+     shutdown if delivery cannot recover.
+
+3. **Immutable identity**
+   - One OMP session per endpoint lifetime.
+   - In-TUI session switching, branching, creation, and resume are blocked.
+   - A different session requires endpoint stop plus explicit relaunch.
+
+4. **Live continuity**
+   - ReadyAgent and LiveAgent only.
+   - Bounded, per-event OMP Psyche turns; no resident adapter-side Psyche loop.
+   - OMP history, digest, and echo-commune implementations.
+   - Commune and signoff drops under project-local `.spt/`.
+
+5. **Public-contract verification**
+   - Published manifest schema and public `spt api`/CLI surface only.
+   - Minimum spt-core version `0.29.0`, required for endpoint-cwd resolution of
+     relative continuity directories.
+   - Deterministic unit/integration checks plus a same-node native endpoint
+     release gate.
+
+## Out of scope
+
+- A headless RPC bridge or any second endpoint topology.
+- Any foreign-harness plugin, hook, context-injection, command launcher, update
+  reconciliation, or model-wrapper compatibility layer.
+- Worker endpoint advertisement for OMP subagents.
+- Migration of inherited `.spt` predecessor continuity.
+- Switching the bound OMP session inside a running endpoint.
+- Cross-node adapter tests; subnet transport is an spt-core responsibility.
+- An adapter-owned copy of spt-core state, transport, spool, or auth logic.
+
+## Skill policy
+
+No OMP-native skill delivery/distribution route is currently proven. The
+adapter therefore ships no command skills. The public `spt` CLI remains
+available directly. Skills enter scope only after an OMP extension registration
+and release-packaging path is specified and tested.
+
+## Release boundary
+
+A release must prove fresh launch, attachability, local delivery and correlated
+reply, lifecycle state, native resume, blocked in-TUI switching, graceful
+shutdown, listener fail-closed behavior, and both endpoint types. It does not
+re-prove spt-core's subnet transport.
+
+## Decision index
+
+| Decision | Record | Status |
+|---|---|---|
+| OMP-only clean cutover | ADR-0008 | Locked |
+| Native OMP for every endpoint | ADR-0009 | Locked |
+| Delivery self-heals or closes | ADR-0010 | Locked |
+| Endpoint/session binding is immutable | ADR-0011 | Locked |
+| Continuity lives under `.spt/` | ADR-0012 | Locked |
+| Release gate stops at adapter boundary | ADR-0013 | Locked |
diff --git a/adapter/omp-spt.toml b/adapter/omp-spt.toml
index b6ca497..16d2183 100644
--- a/adapter/omp-spt.toml
+++ b/adapter/omp-spt.toml
@@ -1,479 +1,25 @@
-# omp-spt — oh-my-pi (omp) adapter manifest for spt-core.  [fork of SaberMage/claude-spt]
+# omp-spt — Oh My Pi harness adapter for spt-core.
 #
-# Forked from claude-spt (the Claude Code adapter) and retargeted to oh-my-pi
-# (https://github.com/can1357/oh-my-pi). Unlike Claude Code, omp exposes a native
-# host-drives-agent control surface (`omp --mode rpc`), so the omp integration is an RPC
-# bridge, NOT a hook-scraping plugin — see OMP-ADAPTER-PLAN.md (architecture decision: Style A).
-#
-# This is the spt-core-conducted layer of the distribution split (ADR-0001): the volatile
-# `[digest]` extractor / profiles / strings / hints ride here, NOT in the thin plugin skeleton.
-# Registered with `spt adapter add <path>`; the version-of-truth is `spt adapter list`, not the
-# marketplace `plugin.json` version. The per-version changelog below is INHERITED claude-spt
-# lineage (retained for seam provenance); omp-spt's own history starts at version 0.1.0.
-#
-# Authored against spt-core's PUBLISHED v0.7.0 surface ONLY (spt-releases + sabermage.github.io/
-# spt-releases) — `manifest.schema.json` is vendored beside this file (adapter/manifest.schema.json,
-# provenance: https://sabermage.github.io/spt-releases/manifest.schema.json). Validated by the
-# manifest-schema CI gate (ci/manifest/). NEVER copy spt-core internals (AGENTS.md).
-#
-# Deferred to later parity slices (not in this slice; each declares an adapter seam we have not
-# yet built, or needs a capability not on the public surface — see notes inline):
-#   * [session.<role>] for signoff/notif — still-deferred live-agent roles (no field forcing yet).
-#     psyche_init/psyche_resume authored at v0.14.0 (F-030 ephemeral shim); echo_commune + [history]
-#     authored at v0.15.2 (field-forced: core 0.27/0.28 spawns the summarizer and 3-strikes the
-#     psyche host when the role is missing — flynn 2026-07-07). [session.self] IS authored below
-#     (the endpoint-run/bind bringup that hosts a fresh CC session — the M12 `cc` launcher target).
-#   * [update]                      — DECLARED below via the `gh_release` avenue (the published
-#     `--release` machinery, operative on the current min_spt_core floor): spt-core auto-updates the
-#     adapter from THIS repo's GitHub releases on `spt adapter update`, with NO Ed25519 signing infra
-#     (closes the F-005 parked `file_pull`/`delegated` legs). The COMPOSITE `[update.post]` step (the
-#     delegated plugin-reconcile) lands in spt-core v0.16.0 (ADR-0029) — wired at the adapter v0.8.0
-#     cut. (NB: "v0.8.0" everywhere in THIS arc = the claude-spt ADAPTER version, NOT an spt-core
-#     version — spt-core's next is v0.16.0; doyle 2026-06-25.)
-#
-# [impl->REQ-DIST-MANIFEST-SCHEMA]
+# Native OMP owns every hosted terminal. The adapter binary is a launch,
+# digest/history, Psyche, and echo-commune helper; OMP's packaged extension owns
+# bind, delivery, activity state, reply, and shutdown inside the native TUI.
+# This manifest is authored only against the published spt-core manifest and
+# CLI contracts. See OMP-ADAPTER-PLAN.md and ADRs 0008-0013.
 
 [adapter]
 name = "omp-spt"
 kind = "harness"
-# 0.6.1 (2026-06-22): PACKAGING modernization — the release now ships a single MULTI-PLATFORM fat
-# .spt (per-triple subdirs, ADR-0024 W1) which only spt-core >= 0.13.2 can extract, so the floor moves
-# to 0.13.2 (see below) and /omps:setup drops its now-redundant os-detection (`adapter add --release`
-# is host-agnostic). The seam surface is unchanged from 0.6.0 (the v0.13.0 RUN-group seams
-# [session.resume] + [message-idle-translation-binary], added in 0.6.0). Fresh tag, not an in-place
-# v0.6.0 re-cut (a re-cut asset on the same tag is ambiguous — operator + doyle call).
-# 0.6.2 (2026-06-23): FIX — idle message delivery now submits with a discrete Enter keypress instead of
-# a trailing carriage return in the injected text. A `\r` byte does NOT trigger Claude Code's message
-# submission (newly discovered), so idle-delivered messages typed into the input box but never sent;
-# the [message-idle-translation-binary] choreography now ends with {key:enter} after the text. Binary
-# rebuild only — manifest seams + floor unchanged.
-# 0.7.0 (2026-06-24): the CHECKPOINT-COMMUNE WAVE — three operator-requested deliverables. (T1) the
-# idle-translation binary now FRAMES each inbound <EVENT> across multiple lines (a raw \n after the
-# opening tag and before </EVENT>) for visual distinction — CC soft-newlines a bare \n, empirically
-# gated. (T2) AGENT-DRIVEN CHECKPOINT: a NEW [hooks.PostToolUse] (Write matcher) detects a `!!checkpoint!!`
-# trigger in a live agent's own `.claude/<id>-commune.md` and self-sends `spt send --json-payload
-# '{"checkpoint":"v1","wake":…}'`; the signal loops back through the endpoint's own translation binary,
-# which parses the structured json envelope-attr and fires a /clear + wake macro — the agent clearing +
-# rebuilding its own context from its freshest commune. (T3) RESUME parity: SessionStart now pulls
-# `spt api psyche-download <id>` and injects the durable role/live/project + pending commune/signoff as
-# additionalContext (closes F-020). These REQUIRE spt-core v0.15.0 (the `--json-payload` send axis + the
-# `psyche-download` verb), so the floor BUMPS to 0.15.0 below.
-# 0.8.0 (2026-06-26): the UNIFY-CONSOLIDATE cut — name unification + one-command update + binary
-# consolidation (ADR-0005/0006), consuming spt-core v0.16.0 (counter 35). U1 [update].message + U6
-# {id} display/RC parity on both bringup paths + U2 the consolidated claude-spt binary
-# (digest/psyche/post-update). D2: [update.post]={command,self_verifies} composite update — one lever
-# `spt adapter update claude-spt` pulls the .spt AND reconciles the cplugs plugin (post-update emits
-# the `!!update-message!!` sentinel → [update].message). D3: the idle filter folded into
-# `claude-spt translate` ([message-idle-translation-binary].command, path deprecated) → ONE tool binary
-# per triple. Also F-021 reachability (PreToolUse mid-turn poll + honest busy/idle turn-state) + U4
-# reactive-skill thinning (commune/signoff prose → the live-ops brief). REQUIRES spt-core v0.16.0 (the
-# update.post + idle command + {adapter_dir} seams), so the floor BUMPS to 0.16.0 below.
-# 0.9.0 (2026-06-28): D1 — HOOK LOGIC FOLDED INTO THE BINARY. All eight CC hook wrappers + their shared
-# _common.sh moved out of the cplugs plugin shell into `claude-spt hook <event>` (the binary's new
-# subcommand), so hook behaviour now rides `spt adapter update` instead of forcing a cplugs republish.
-# The plugin ships only a STATIC-FOREVER hooks.json + a thin dispatch.sh that resolves the binary via
-# the lazily-substituted [strings].hook_cmd = "{adapter_dir}/claude-spt hook" (ADR-0006 ask #1 →
-# resolve-not-execute; both the {adapter_dir} subst + lazy [strings] read-time subst are spt-core
-# v0.16.0 primitives, already on the current floor). Behaviour-preserving refactor — same `api …`
-# command lines, same per-event additionalContext contract. min_spt_core stays 0.16.0 (no new seam).
-# 0.9.1 (2026-06-28): bugfix patch — see the version-history note below for the three fixes.
-# 0.9.2 (2026-06-30): brief-prose fix only (adapter strings, no binary/plugin change) — the v0.9.1
-# "replies arrive automatically; never arm a Monitor" wording was spt-hosted-only; for a HARNESS-hosted
-# live agent the agent's OWN `spt api listen` relay IS the delivery pipe. messaging-perch.md now
-# distinguishes the hosting modes and says "do not arm an EXTRA Monitor" (preserving the primary relay).
-# 0.10.0 (2026-07-01): the DIGEST-FETCHER cut — consumes spt-core v0.19.0 (counter 38, #17). [digest]
-# flips to strategy="fetcher": the extractor now LOCATES + reads + emits itself (spt-core runs it
-# bounded, no pre-read, no `source` pre-resolve), fed only harness-NEUTRAL fills ({session_id} + the
-# captured {CLAUDE_CONFIG_DIR} read-var). The NEW [env.CLAUDE_CONFIG_DIR] direction="read" seam
-# (capture-at-bind → info.json.read_env → fill → ~expand) finally delivers the ccs-relocated tree to
-# the on-demand extractor in the DAEMON'S context — the gap that made the old env-preference branch
-# session-context-only. `source` dropped (ignored under fetcher). Floor BUMPS to 0.19.0 below.
-# 0.10.1 (2026-07-01): BUGFIX — perch-id mis-parse (doyle report, REQ-DIST-WHOAMI-JSON). The hook's
-# self_id took the FIRST LINE of `spt whoami` HUMAN output; the current human view is a grouped
-# roster ("SUBNET <name>" header first on any subnet-member node, "SELF: <id> …" when perched), so
-# SessionStart crowned an agent "SUBNET SPT_DEV" and the brief's don't-run-whoami instruction made
-# the wrong identity self-reinforce. Fix: `spt whoami --json` → .self.id (null ⇒ no-perch; parse
-# failure ⇒ empty, NEVER a roster line). --json is a v0.16.0 global flag, under the 0.19.0 floor —
-# no new seam, floor unchanged.
-# 0.10.2 (2026-07-01): EMERGENCY BUGFIX — the hook binary now DEGRADES instead of BRICKING on the
-# dispatch×hook_cmd LOCKSTEP skew (REQ-HAZARD-HOOKCMD-DISPATCH-LOCKSTEP). A stale plugin dispatch.sh
-# (old 0.1.8 shape) execs `claude-spt <CCEvent>` WITHOUT the `hook` token against a bare-path hook_cmd
-# → `claude-spt UserPromptSubmit` → old main.rs exited nonzero on EVERY hook → CC blocked all tools +
-# looped the Stop hook, zero self-repair. Fix: `claude-spt <CCEvent>` (a recognised CC hook event as a
-# bare subcommand) is now handled AS a hook (perch keeps working) with a non-blocking stderr note that
-# the plugin is stale (advise /reload-plugins); a genuine typo still exits loud. Rides `spt adapter
-# update` (binary channel) so it reaches even a node with the stale plugin. Binary-only, floor unchanged.
-# 0.10.3 (2026-07-01): NODE-NAMED SESSIONS — the REQ-DIST-RC-STARTUP stretch (doyle ask #4), shipped
-# adapter-side. All FOUR CC spawn commands ([session.self]+[session.resume], base + ccs profile) now
-# route through `{adapter_dir}/claude-spt launch`, which computes the node name ON-NODE and spawns the
-# harness CLI with -n "<id> @ <node>" (display) + --remote-control <id>--<node> (RC names are tokeny;
-# space-safety unverifiable from the public surface). Shim needed twice over: the published fill
-# catalog (v0.19.1) has NO {node} key (reported gap), and tokenize-then-fill can't produce a
-# space-carrying argv element anyway. Unknown node ⇒ both names degrade to bare <id> (the pre-0.10.3
-# shape). `spt rc <id>` unaffected (broker attaches by ENDPOINT id, not CC's RC name). No new
-# spt-core seam ({adapter_dir} subst is pre-0.16.0 for command templates) → floor unchanged.
-# 0.10.4 (2026-07-02): the /clear SESSION-PIN-WEDGE fix (F-024 correction; doyle ruling
-# F024D-BOUNDARY-RULING). The SessionStart boundary rotation now (1) resolves the endpoint id from
-# $SPT_ENDPOINT_ID FIRST (whoami-by-NEW-sid was a catch-22 → self:null → SILENT skip → perch pinned
-# to the dead sid, AUTH_REFUSED on every later id-scoped call, no self-heal — the ENLYZEAM wedge),
-# (2) persists the current sid at EVERY SessionStart to the adapter-owned
-# state/session/<endpoint_id>.sid and presents it as the `--session-id` rotation proof (the departed
-# session's env file is gone; per doyle: adapter-owned state is the contract-clean carrier, NOT
-# CLAUDE_ENV_FILE), and (3) is LOUD on stderr for a skipped/refused rotation. Binary-only change; no
-# new spt-core seam → floor unchanged.
-# 0.11.0 (2026-07-02): {node} FILL ADOPTED (spt-core v0.20.0 closed the reported gap — the doyle-ask-#4
-# key). All four launch commands now pass `--node {node}`: the daemon's ADVERTISED node label names the
-# session, so `<id> @ <node>` / `<id>--<node>` match what the rest of the spt surface calls the node
-# (an operator-set label ≠ raw hostname). The shim STAYS (space-carrying display name remains
-# untemplatable manifest-side — single-token fills; doyle caveat) and its hostname detection becomes
-# the FALLBACK: a blank or literally-unsubstituted `{node}` (the F-013 gap class) collapses to
-# detection, then to bare-<id> degrade. Floor → 0.20.0 (the {node} fill is the new seam).
-# 0.12.0 (2026-07-03): TWO binary changes, no manifest command/floor change. (1) CHECKPOINT CLEAR/WAKE
-# RACE FIX (REQ-HAZARD-CHECKPOINT-CLEAR-RACE): the `!!checkpoint!!` macro no longer submits the wake in
-# the same inject sequence as `/clear` (a single sequence cannot straddle the async clear within the 5s
-# commit deadline → the wake raced ahead and landed in the OLD session). Split: the translation binary
-# ARMS the wake in memory + emits clear-only; the SessionStart hook self-sends `{"checkpoint_fire":"v1"}`
-# on the `clear` boundary and the binary emits the wake THEN — after the clear completes. Both self-sends
-# now use `--force-native` (deliver through the translation binary, never spool to active-poll = plain
-# text). (2) SESSION NAMES gain the PROJECT FOLDER: display `-n "<id> @ <node> (<project>/)"`, RC
-# `--remote-control <id>--<node>--<project-token>` (character-safe token). Binary-only; floor stays 0.20.0.
-# 0.13.1 (2026-07-04): EMPTY-RESPONSE {commit} TERMINATOR (REQ-HAZARD-EMPTY-RESPONSE-COMMIT). A delivery
-# the translation binary deliberately answers with no keystrokes (a checkpoint_fire with nothing armed —
-# fired by SessionStart on EVERY clear; an event without an envelope) now answers a bare {"commit":true}
-# instead of zero records: an unterminated inject sequence hits the broker's 5s INJECT_COMMIT_DEADLINE →
-# TRANSLATION_FAULT terminates the binary — so every non-checkpoint /clear was killing idle delivery at
-# the boundary (the deterministic half of the "force-native decay" ghost). init/input stdin lines stay
-# silent (commit belongs to a sequence). Binary-only; floor stays 0.23.0. Joint contract gap (the
-# empty-response rule is documented nowhere public); core-side docs + miss!=fault deadline semantics ride
-# spt-core's C-1.
-# 0.13.2 (2026-07-04): WAKE/CLEAR SUBMIT SETTLE (REQ-HAZARD-CHECKPOINT-CLEAR-RACE choreography fix).
-# The checkpoint clear-half and wake-half sequences gain the same 50ms text→enter settle the normal
-# idle-delivery choreography always had: without it the discrete enter's \r coalesces into the
-# still-landing text and registers as a SOFT NEWLINE instead of a submit — field-observed on the
-# first working post-clear wake (spt-core v0.24.0 box): wake rendered with a trailing newline,
-# unsubmitted. Short "/clear" usually won the race; a paragraph-length wake reliably lost it.
-# Binary-only; floor stays 0.23.0.
-# 0.13.3 (2026-07-04): RE-CUT of 0.13.2 minus an accidental passenger. The 0.13.2 tag was cut from a
-# HEAD that carried the PARKED ephemeral-psyche redesign (publish was gated on the future F-030 core
-# wave): its [session.psyche_resume] + run-to-completion psyche shim shipped early, and on cores
-# without the F-030 driver the shim's by-design exit trips the daemon's residency machinery — field
-# evidence: a fresh live endpoint's ready stamp appears then VANISHES seconds later and force-native
-# gates forever (leg=cli-gate-not-hosted). 0.13.3 = the v0.13.2 submit-settle fix on the RESIDENT
-# psyche runner (the 0.13.1 model), ephemeral redesign reverted to its parked branch. Floor 0.23.0.
-# 0.13.4 (2026-07-04): PSYCHE POLL LOUD-FAIL (KH §2.6 second leg, doyle GO). The resident runner's
-# per-pulse `spt ready <id> --once` misread a CONFIG refusal (canonically the multi-subnet home
-# guard's READY_FAIL — the daemon fills carry no subnet, core seam/F-017 sibling, folds into F-030)
-# as "perch gone" and exited 0 SILENTLY → the daemon rehosted it ~every 5s forever (hall-bf field
-# case, ordinal 6491, invisible). A READY_FAIL-marked poll failure now dies LOUD + NONZERO
-# (PSYCHE_POLL_FAIL, exit 4) so psyche_host_error stamps a real fault; normal perch-close stays the
-# quiet lifecycle exit. Residency on multi-subnet homes stays broken until the core seam — this
-# makes it VISIBLE, not fixed. Binary-only; floor stays 0.23.0.
-# 0.14.0 (2026-07-04): the PSYCHE EPHEMERAL redesign — adapter half of the joint F-030 wave
-# (PSYCHE-EPHEMERAL-PLAN.md; doyle W1/W2 psyche-turn contract FREEZE 944a74b0 + evidence answers).
-# The resident `claude-spt psyche` wrapper (seed turn + perch-poll pulse loop + thrash guard) is
-# REPLACED by a run-to-completion shim: the daemon drives every turn via [session.psyche_resume]
-# (NEW table below) — one headless `claude` turn per invocation, then exit. Continuity is the CC
-# transcript + the core-minted psyche-own session id, not a process. ONE spawned role, two key
-# shapes (discriminated on the mind FILE's content emptiness): a FreshWithPreload turn's mind file is
-# NON-EMPTY + adopts the minted {session_id}; a ContinueExisting turn's mind file is EMPTY + resumes the
-# stored sid. The per-turn event rides the shim's STDIN; the mind rides a core-written FILE the shim
-# reads ({psyche_context_file}, W4 — kills the win32 cmdline cap); the psyche's reply rides
-# the shim's captured STDOUT. Reseed is signalled by the reserved EXIT CODE 95 (session-gone). This
-# retires the resident poll (v0.13.4's PSYCHE_POLL_FAIL leg is subsumed — no loop to guard) and
-# dissolves the multi-subnet residency-churn class BY DESIGN. [session.psyche_init] survives ONLY as
-# the live-capability GATE (never spawned). FLOOR BUMPS to the F-030 core release (min_spt_core
-# below): no current core drives per-event psyche_resume, so this release TRAILS F-030 — PUBLISH
-# HOLDS until that core lands + a live-verify window (do NOT tag from a HEAD carrying this until the
-# floor is set to the F-030 sha; RELEASE-RUNBOOK parked-work exclusion check).
-# 0.14.1 (2026-07-05): BOUNDARY RENAME (REQ-DIST-BOUNDARY-RENAME, operator ask). CC drops the
-# `-n "<id> @ <node> (<project>/)"` display name when a /clear rotates the session — the operator
-# loses the rendered TUI anchor (the whole point of node-named sessions). Now every clear boundary
-# re-asserts it: the launch shim threads the computed display name into the spawned CC env as
-# SPT_SESSION_NAME (same string that feeds -n — one computation site, parity by construction); the
-# SessionStart hook on a `clear` boundary self-sends {"rename":"v1","name":…} --force-native BEFORE
-# the checkpoint_fire; the translation binary answers with its own inject sequence typing
-# `/rename <name>` (local no-turn CC command, empirically confirmed: inline arg, current session,
-# no agent turn) — so an armed checkpoint wake still lands on an idle box AFTER the name is back.
-# Rename handling is STATELESS (pending_wake untouched — the delivery lands between arm and fire).
-# Missing SPT_SESSION_NAME (pre-0.14.1 spawn) skips LOUDLY (RENAME_SKIP:no-name), heals on respawn.
-# /compact retains the name (confirmed) — compact stays send-nothing. Binary-only; floor unchanged.
-# 0.14.2 (2026-07-06): PSYCHE CWD FIX (doyle P-1 verdict — URGENT). Both psyche tables carried
-# `cwd = "{psyche_dir}"` over from the RETIRED resident-era shape, but the F-030 per-event fill
-# catalog never included psyche_dir (freeze fills {id, session_id, parent_session_id,
-# psyche_context_file, node, subnet}; core runtime.rs:65 "a catalog key must have a real fill") —
-# so EVERY psyche turn on a 0.25.0 driver faulted at substitution before spawn (flynn: psyche dead,
-# "no value for substitution key {psyche_dir}", 3x consecutive, psyche_host_error stamped). Fix:
-# cwd templates + psyche_dir keys REMOVED from psyche_init + psyche_resume; the SHIM now chdirs to
-# the {psyche_context_file} parent dir (the psyche's nested perch dir — the same location the old
-# fill pointed at, observed owlery/<id>/nested/<id>-psyche/psyche-context.txt) before spawning
-# claude, keeping the sid+cwd transcript pair stable across turns. Manifest + binary; floor unchanged.
-# 0.15.0 (2026-07-06): WORKER-TRUTH wave-1 migration (REQ-DIST-WORKER-LIFECYCLE; doyle frozen shape,
-# core v0.27.0). Grew out of the 2026-07-06 six-worker leak diagnosis: the old worker verbs were
-# token-gated (start's stdout token was discarded, stop's sid was never stored core-side) so EVERY
-# worker-stop was AUTH_REFUSED and silently swallowed — every subagent leaked an OFFLINE worker
-# perch. New contract consumed: worker-start is ID-LESS (core hard-mints {parent}-w{N}, answered on
-# BARE STDOUT; empty = refusal), agent_id/agent_type ride as correlation metadata, ZERO tokens
-# (operator ruling: sid-symmetric auth — stop accepts the stored registration sid OR the parent's
-# current sid, so a /clear between start and stop is covered). The hook persists the agent_id→
-# minted-id mapping in adapter state (state/worker/<agent_id>.wid — SubagentStop only carries the
-# CC agent_id) and stops by the MINTED id. Every skip/refusal on both hooks is now LOUD
-# (WORKER_START_REFUSED / WORKER_STOP_SKIP / WORKER_STOP_REFUSED breadcrumbs) — the silent-swallow
-# class is dead. FLOOR BUMPS to 0.27.0 (the new verbs ship there; older cores clap-reject the
-# id-less worker-start — accepted skew, doyle-banked; core's registration-time floor enforcement
-# (0.26.0+) guards the reverse). Binary + manifest.
-# 0.15.1 (2026-07-06): BOUNDARY FOLD — rename + wake ride ONE post-clear inject sequence
-# (REQ-DIST-BOUNDARY-RENAME revision; KH second leg). Field-paid same day (flynn): the v0.14.1
-# design emitted rename and wake as two back-to-back inject sequences, which raced at the
-# just-rebuilt post-clear boundary — the rename's enter registered as a soft newline, the next
-# sequence's ctrl+s failed to stash the residue, and the wake text submitted INSIDE the /rename
-# argument (session titled with the wake, NO wake turn, agent dormant ~9.5h; ~33% observed, 1 of 3
-# checkpoints). Fix: the rename delivery now only STASHES (bare {commit}); the fire emits the ONE
-# combined sequence — rename half . 150ms enter→ctrl+s bridge . wake half . one commit
-# (commands_for_boundary/BOUNDARY_BRIDGE_MS). No inter-sequence boundary exists to race.
-# Binary-only; floor unchanged. Also cut as v0.14.3 on the 0.25.0-floor line (same patch off the
-# v0.14.2 tag) so pre-0.27.0 boxes can take the fix immediately.
-# 0.15.2 (2026-07-07): ECHO-COMMUNE + HISTORY — field-forced by flynn's psyche host dying on core
-# 0.28.0 ("commune-sync: echo-commune spawn failed: manifest declares no [session.echo_commune]
-# role", 3-strike psyche_host_error → checkpoints dead; ECHO-COMMUNE-PLAN.md). Two deferred parity
-# seams authored: [history] strategy=fetcher (`claude-spt history` — locate via the digest fetcher
-# machinery, stream the CC JSONL VERBATIM; opaque, feeds the echo-commune per the published
-# contract) and [session.echo_commune] (`claude-spt echo-commune` — stdin-fed history (self-locate
-# fallback: the core-side history→stdin wiring is unpublished, docs-gap filed), bounded whole-line
-# ~48KB tail, ONE headless `claude -p` turn in the psyche-parity sandbox narrowed to Read-only
-# tools, delta on stdout, loud ECHO_COMMUNE_FAIL on any failure). recursion_guard_env =
-# "SPT_ECHO_COMMUNE" + the hook binary BAILS (exit 0, zero api calls) when that env is set, so the
-# summarizer's inner claude can never seed/bind/stomp a perch. Floor unchanged (0.27.0).
-# 0.15.3 (2026-07-07): SPT REACHABILITY NOTICE — legacy-owl port (operator ask; owl's
-# <owl_reachability_notice>, spt-renamed). Perched sessions were running subagents/long tasks in the
-# FOREGROUND, unreachable for the task's duration. Every perched UserPromptSubmit now closes its
-# additionalContext with <spt_reachability_notice> (use run_in_background: true), and PreToolUse
-# adds a targeted nudge when the tool is a subagent spawn (Agent/Task), messages first, nudge last,
-# emitting even on an empty drain. Perch-gated both sites. Binary-only; floor unchanged (0.27.0).
-# 0.15.4 (2026-07-07): URGENT — two field regressions, doyle node-wide RCA. (1) MESSAGE BLACK HOLE
-# (KH §2.8, REQ-HAZARD-PRETOOL-CONTEXT-ENVELOPE): CC discards raw PreToolUse stdout, so every
-# mid-turn drain was taken (delivered=1) then thrown away — PreToolUse emissions now ride the
-# {"hookSpecificOutput":{"hookEventName":"PreToolUse","additionalContext":...}} JSON envelope,
-# capped on WRAPPED size, over-cap spills raw + wraps the pointer. (2) ECHO-COMMUNE LOCATE +
-# LATCH: self-locate now honors the perch's read_env.CLAUDE_CONFIG_DIR (ccs transcripts) with the
-# ccs-instances sweep as last rung, and a locate-miss is exit-0 + no-delta marker (the v0.15.2
-# exit-1 latched doyle's + perri's psyche hosts via the 3-strike budget). Binary-only; floor
-# unchanged (0.27.0). Post-apply ops: strike-clear (wake) the latched psyche hosts.
-# 0.16.2 (2026-07-08): RECEIVE-HEAL fix 3 — the hook-INDEPENDENT interrupt watcher (NEXT-WORKLOAD-PLAN
-# Item 1, closes it). Step-0 (field lia) proved an Esc-interrupt fires NO usable CC hook: Stop is
-# clean-finish-only, StopFailure API-error-only, PostToolUseFailure tool-only-and-unreliable, and a
-# PURE-THINKING Esc fires NOTHING — so the hook fixes 1-2 structurally cannot heal a hookless interrupt,
-# and the endpoint sat deaf (probes QUEUED, 50s+). NEW tools/claude-spt/src/interrupt_watch.rs: a 15s
-# heartbeat thread hosted by the persistent translation binary pulls `spt endpoint digest <id> --last 1
-# --json`, detects the `[Request interrupted by user` marker (both variants — plain + "for tool use") on
-# the latest turn, and marks idle via the bind-time carrier sid (heal-once, re-arm when the agent moves
-# on; state idle is idempotent). Chain proven MANUALLY against a stuck lia first (state idle + carrier
-# sid → IDLE gate-armed → probe SENT). doyle anti-thrash rider honored (15s, not --follow). Binary-only,
-# floor unchanged (0.27.0). ACTIVATION: the watcher rides the translation binary, which is PERSISTENT —
-# `spt adapter update` swaps the binary but a session's ALREADY-RUNNING translate keeps the old one; fix
-# 3 activates on the endpoint's next bringup/bounce (the hook fixes 1-2 activate per-hook immediately).
-# 0.16.1 (2026-07-08): RECEIVE-HEAL HARDENING + READABLE STEP-0 TRACE (binary-only, no skeleton
-# change). Field repro on lia: after a REAL turn (a genuine UserPromptSubmit → busy), an Esc — whether
-# mid-tool OR pure-thinking — left lia deaf (probes QUEUED, never drained), and the 0.16.0 hook logs
-# (eprintln → CC stderr) were UNREADABLE off a broker session (the daemon captures only the stderr of
-# adapters IT spawns, never CC-hook stderr). TWO changes: (1) SysEnv::log now TEES every hook log to a
-# rolling `{adapter_dir}/hook-trace.log` (≤512KB) so the next repro is readable — what fires on an Esc,
-# with what payload. (2) HARDEN the StopFailure + PostToolUseFailure heal: resolve id from
-# $SPT_ENDPOINT_ID and the sid from the bind-time carrier state/session/<id>.sid when the payload omits
-# session_id (PostToolUseFailure does) — the old self_id+payload-sid path fired `state idle` with an
-# EMPTY --session-id, AUTH-refused silently = the deaf-lia miss. Never fires with an empty sid
-# (RECEIVE_HEAL_SKIP logged instead). Fix 3 (pure-thinking-Esc watcher) still gated on reading the
-# trace. Floor unchanged (0.27.0). Post-apply: `spt adapter update claude-spt` only — no /reload-plugins.
-# 0.16.0 (2026-07-08): RECEIVE-HEAL (NEXT-WORKLOAD-PLAN Item 1, fixes 1-2 + Step-0 instrument). The
-# stuck-ACTIVE black-hole (0.15.9) had two more no-Stop entry doors CC never closed: an API-error
-# turn-end (rate_limit/server_error/max_output_tokens) and an operator Esc mid-tool-call — both end a
-# turn with NO Stop and NO idle_prompt, so the endpoint stays ACTIVE and the daemon black-holes inbound
-# (field lia 2026-07-08: Esc → 20+min silence). FIX: (1) wire StopFailure → state idle (API-error
-# turn-end, REQ-HAZARD-STOPFAILURE-STUCK-BUSY); (2) wire PostToolUseFailure, mark idle on
-# is_interrupt==true (Esc-during-tool, REQ-HAZARD-INTERRUPT-STUCK-BUSY) — a non-interrupt failure is
-# NOT a turn-end (agent keeps going), never marks idle. STEP-0 INSTRUMENT (defense-in-depth, kept): the
-# Notification matcher widens idle_prompt→* and the handler goes TYPE-AWARE — it LOGS every type but
-# marks idle ONLY on idle_prompt (a permission_prompt must not drain the spool mid-turn); $SPTC_HOOK_TRACE
-# adds hot-path Stop/non-interrupt tracing for a live Esc-repro that draws the no-Stop coverage boundary
-# (whether a PURE-THINKING Esc needs the fix-3 digest-pull watcher is gated on that repro). Binary +
-# cplugs skeleton (hooks.json: StopFailure + PostToolUseFailure wired, Notification *)—needs
-# /reload-plugins. Floor unchanged (0.27.0).
-# 0.15.9 (2026-07-08): STUCK-ACTIVE IDLE FIX (operator /diagnose of lia). A freshly-launched
-# spt-hosted endpoint that never completed a turn stayed ACTIVE forever, so the daemon spooled every
-# inbound message without ever draining it (lia: 14 parked, undelivered; the translation binary was
-# healthy — never fed). Root: the adapter marked idle ONLY on Stop/clear/checkpoint, never at startup
-# and with no idle-at-prompt handler. TWO-LAYER FIX: (1) the spt-hosted bind path asserts state idle at
-# bringup (immediate receivability); (2) a new Notification hook (idle_prompt matcher) re-asserts idle
-# whenever CC reports the session idle at its prompt — the self-heal from a /login or any no-Stop
-# submission. REQ-HAZARD-STUCK-ACTIVE-NO-IDLE. NB the Notification WIRING rides the cplugs skeleton
-# (plugin.json 0.1.10, hooks.json) — needs /reload-plugins; layer (1) rides this binary. Floor
-# unchanged (0.27.0).
-# 0.15.8 (2026-07-07): W6 LIFECYCLE-TRUTH item 3 — CC Layer-2 echo-verify opt-in. Declares
-# [env.SPT_INJECT_VERIFY_ECHO]=1 (direction=inject) so a CC-hosted session opts into spt-core's
-# broker inject echo-verify belt (W5-A shipped the broker seam, default OFF; CC's TUI re-renders
-# typed text = valid echo verification). Adapter DATA per the glue boundary (no core REQ). FLOOR-SAFE:
-# inert on pre-counter-49 cores (unknown env var; broker default OFF), self-activates once counter-49
-# deploys — min_spt_core NOT bumped, ship decoupled from the core release (doyle-accepted). Manifest
-# [env]-only; no binary change. REQ-INJECT-VERIFY-ECHO.
-# 0.15.7 (2026-07-07): /RESUME PERCH-BINDING WEDGE FIX (operator hunch, perri-confirmed). CC's in-TUI
-# /resume ends the session (SessionEnd reason=resume) and re-fires SessionStart(source=resume) in the
-# SAME broker child — $SPT_ENDPOINT_ID still set — so the hook took the plain BIND path (register_verb
-# routes only clear/compact → the proofed boundary rotation). That bind presented NO ownership proof
-# AND used the exit-ignored `spt` seam (silent), so core squat-protected the already-bound perch (it
-# records the departed pre-resume sid), refused the proofless re-pin, and the refusal was swallowed —
-# the perch stranded on the departed sid, delivery dead while the endpoint looked healthy (the
-# SESSION-PIN-WEDGE via /resume). Fix: the spt-hosted bind now presents the departed sid from adapter
-# state as `--session-id <prior>` ownership proof (bind accepts it — `boundary <MODE>` is a hard
-# {clear,compact} enum, so the proof rides bind, not a new boundary mode) whenever a prior sid exists
-# and differs, and runs STRICT + LOUD on refusal. REQ-HAZARD-RESUME-REBIND-WEDGE. Binary-only; floor
-# unchanged (0.27.0).
-# 0.15.6 (2026-07-07): DANGLING-FRAME MARKER + LIVE.MD SPT-HOSTED BRANCH (adapter-debts work order).
-# (1) render_frames now emits a loud <omps_frame_integrity> marker (surviving partial + spool-recovery
-# pointer) instead of silently break'ing on a mid-frame-truncated poll frame — KH §2.9,
-# REQ-HAZARD-DANGLING-FRAME-LOUD (code shipped @347f755, rides this cut). (2) /omps:live + /omps:ready
-# bringup now BRANCH on the delivery substrate: an spt-hosted (broker-delivered) session must NOT arm
-# the in-session Monitor listener (it cannot re-arm a broker perch — ADAPTER_UNRESOLVED / NO_SEED per
-# flynn 2026-07-07); it relies on its existing broker delivery. REQ-SKILL-LIVE-SPT-HOSTED-BRANCH.
-# Binary + strings; floor unchanged (0.27.0).
-# 0.15.5 (2026-07-07): ECHO-COMMUNE CLAUDE ENV — the second latch class (doyle field pin, post-
-# 0.15.4): the locate fix worked but the summarizer's SPAWNED claude died at exit 1 — the role
-# spawn's env lacks the ccs instance root, so bare-env claude has no auth/config. The shim now
-# resolves the endpoint's config root ONCE (perch read_env.CLAUDE_CONFIG_DIR rung, else env) and
-# sets CLAUDE_CONFIG_DIR explicitly on the spawned claude; same value feeds the transcript locate.
-# (Latch lever question CLOSED: stamp is display-only, daemon retries per-event turns — first Ok
-# clears; no core lever needed.) Binary-only; floor unchanged (0.27.0).
-# 0.17.0 (2026-07-08): TAG-DRIVEN PEER MESSAGING + COMMUNE SHORTCUT (NEXT-WORKLOAD-PLAN Item 2). An
-# agent messages peers WITHOUT the Bash tool by embedding `@<t1,t2 body @>` in its output, or writes
-# its commune by starting an output with `>>commune<<`. A PreToolUse (mid-turn) + Stop (backstop)
-# scan pulls the endpoint's own finalized digest output past a seq cursor (state/digest/<eid>.seq),
-# fans out `spt send --from <self> <target>` per target, confirms back to the sender's own perch
-# (--active-only --ephemeral), and writes `.claude/<id>-commune.md` for the daemon watch to ingest
-# (reusing the checkpoint loopback on a `!!checkpoint!!` body). Binary-delivered (PreToolUse/Stop are
-# already wired); the send-skill doc note rides the plugin skeleton. Floor unchanged (0.27.0).
-# REQ-TAG-PEER-MESSAGING · REQ-COMMUNE-OUTPUT-SHORTCUT. Live int owed (dogfood on a bounced endpoint).
-# 0.17.1 (2026-07-08): TAG FALSE-FIRE GUARD. Field-proven minutes after 0.17.0 shipped: the `@<…@>`
-# form fired when QUOTED in prose (the release notes' own `@<alice …@>` examples dispatched sends on
-# the next hook). Fix: scan_and_dispatch only sees PROSE spans — a tag inside inline-code (backticks)
-# or a fenced code block (```) is a quotation, never a send (tag_scan::prose_segments). A genuine send
-# is written bare. Binary-only; floor unchanged (0.27.0). REQ-TAG-PEER-MESSAGING.
-# 0.17.2 (2026-07-08): END-OF-TURN DELIVERY FIX. Field-proven: a tag that is the turn's LAST output was
-# not delivered — scan_and_dispatch pulled the async `endpoint digest`, whose per-entry `seq` is
-# assigned AFTER the Stop hook fires, so the final message was invisible at Stop and only sent on the
-# NEXT hook (deadlock for send-then-wait). Fix: scan the CC TRANSCRIPT directly (hook payload
-# `transcript_path`), tailed from a BYTE cursor (`state/digest/<eid>.pos`, replacing the `.seq` digest
-# cursor). CC writes the completed assistant message to the transcript BEFORE firing Stop, so an
-# end-of-turn tag delivers immediately, universally (live + spt-hosted), no background poll. First run
-# initializes the cursor to EOF (pre-upgrade history never re-dispatched). Binary-only; floor unchanged
-# (0.27.0). REQ-TAG-PEER-MESSAGING.
-#
-# 0.17.3 (2026-07-08): fix — tag-send NO_PERCH misreport. `spt send`'s status token (SENT/QUEUED/
-# DEFERRED/NO_PERCH) prints on STDERR (stdout empty); the stdout-only send classifier saw "" and
-# reported NO_PERCH for EVERY peer send though the message DELIVERED (confirm-back lied; self-send was
-# unaffected as it ignores its result). Root-caused offline via an isolated hook-binary rig (peer send
-# returned raw="" while stderr carried SENT:doyle). Fix: HookEnv::spt_send captures stdout+stderr merged;
-# scan_and_dispatch classifies through it (REQ-HAZARD-SEND-STATUS-STDERR). ALSO folds doyle's two-slice
-# fix: the commune brief + echo-commune summarizer now teach the <project-context>/<live-context>
-# envelope so core routes context per-project instead of dumping all in the live tier
-# (REQ-COMMUNE-CONTEXT-TIER-SLICING). Binary-only; floor unchanged (0.27.0). Send-status-on-stderr filed
-# to doyle (undocumented in the harness-contract/CLI reference).
-# omp-spt starts fresh at 0.1.0 — the version history above is inherited claude-spt lineage.
-# 0.1.1 (2026-07-09): bridge HARDENING per docs/OMP-BRIDGE-FIELD-ISSUES.md (the doyle/todlando field
-# incident, PR #1): the shipped binary is renamed claude-spt -> omp-spt (HIGH-1, every manifest
-# command follows); the bridge arms a kill-on-close Job Object so its omp + `spt ready` children die
-# with it however it dies, and soft-tears the perch on the way out (HIGH-2); an always-on
-# operational log rides the broker PTY — bringup breadcrumbs, one line per message/reply, every
-# failure, an idle heartbeat (HIGH-3); every omp wait is bounded — ready/get_state at bringup (a
-# breach exits loud BEFORE bind, so a failed bringup cannot poison the session ledger), and a
-# per-turn deadline that recovers the perch and tells the sender (HIGH-4 + MED-2 + LOW-1/2).
-# Env knobs: OMP_SPT_READY_TIMEOUT_S / OMP_SPT_STATE_TIMEOUT_S / OMP_SPT_TURN_TIMEOUT_S /
-# OMP_SPT_HEARTBEAT_S. Floor unchanged (0.27.0).
-# 0.1.2 (2026-07-10): liaison bugfix rollup (#2/#3). The update notice's fresh-endpoint command now
-# uses attach-default `spt endpoint run --adapter omp-spt --id <id> --create`, not `--start`, so the
-# operator sees the broker-held harness PTY and its bringup log instead of being instructed into a
-# silent start-only launch. The gh_release update avenue now pins transport="gh", forcing the
-# authenticated GitHub CLI path for release discovery/asset fetch so private or visibility-flipped
-# repos update through the user's existing gh auth. Floor unchanged.
-# 0.1.3 (2026-07-13): issue #2 root fix. Native interactive omp is now the broker PTY leader and a
-# packaged OMP extension supplies SPT bind/listen/state/reply integration. The prior attach guidance
-# exposed only the headless RPC bridge's logs because `omp --mode rpc` creates no TUI. Floor unchanged.
-version = "0.1.3"
-# Floor BUMPED to 0.13.2 (2026-06-22, C / F-014 drop): the release packaging moved from the per-OS
-# stopgap (`adapter.spt` = a windows-binary copy — F-014; broke on a linux host) to ONE fat .spt that
-# bundles both x86_64 triples beside a shared manifest. spt-core extracts a fat archive (classify
-# top-level triple dirs → flatten this node's triple into the install dir, preserving bare-name
-# resolution) ONLY on >= 0.13.2 (doyle, extract_release_archive); an older node cannot read the asset
-# at all, so declaring the floor is honest, not a needless block. (Prior floor 0.9.0 was the
-# adapter-agnostic seed/listen-by-host_binaries requirement, PREP-4 — still satisfied, just superseded.)
-# Floor BUMPED to 0.15.0 (2026-06-24, the checkpoint-commune wave / v0.7.0): T2's checkpoint self-send
-# needs `spt send --json-payload` (the opaque-metadata send axis) and T3's resume pull needs the
-# `spt api psyche-download <id>` verb — BOTH land in spt-core v0.15.0 (counter 34, Latest). The
-# multi-line frame (T1) works on any node, but the wave ships as one unit, so the honest floor is the
-# verb floor. An older node can't fire checkpoint or pull resume context, so declaring 0.15.0 is honest.
-# Floor BUMPED to 0.16.0 (2026-06-26, the UNIFY-CONSOLIDATE cut / v0.8.0): D2's [update.post] composite,
-# D3's [message-idle-translation-binary].command, and the {adapter_dir}/{adapter_name} substitution +
-# lazy [strings] subst ALL land in spt-core v0.16.0 (counter 35, Latest; ADR-0029). An older node can't
-# read update.post or the command seam, so declaring 0.16.0 is the honest floor.
-# 0.9.1 (2026-06-28): BUGFIX patch. (1) hook_cmd → bare binary path + dispatch caches it QUOTED, fixing
-# the `hook: command not found` env-file regression that polluted every Bash call + killed the hook
-# cache. (2) post-update now refreshes the cplugs marketplace cache (`plugin marketplace update`)
-# before install — fixes "Plugin omps not found in marketplace cplugs" on a stale cache — and prints a
-# reworded, cleaner update notice without leaking CC's output onto the [update.post] arbiter channel.
-# (3) the ccs profile carries the U6 -n/RC flags (session.self + session.resume), which its v0.8.0
-# command override had dropped. All bugfix; no new seam → floor stays 0.16.0.
-# Floor BUMPED to 0.19.0 (2026-07-01, the digest-fetcher cut / v0.10.0): [digest] strategy="fetcher"
-# (REQ-DIGEST-FETCHER-STRATEGY, spt-core side) + the [env] direction="read" capture/fill seam BOTH land
-# in spt-core v0.19.0 (counter 38). An older node can't parse strategy="fetcher" nor fill the
-# {CLAUDE_CONFIG_DIR} read-var, so declaring 0.19.0 is the honest floor (todlando GO, cluster-A
-# consumable; doyle gate-verified).
-# Floor BUMPED to 0.20.0 (2026-07-02, the {node} cut / v0.11.0): the {node} substitution key for
-# [session.*] commands lands in spt-core v0.20.0 (counter 40; doyle release ping). An older node
-# would pass the literal `{node}` (the shim guards it, degrading to hostname detection), but the
-# feature this cut ships IS the advertised-label fill — declaring 0.20.0 is the honest floor.
-# Floor BUMPED to 0.23.0 (2026-07-03, the C3 thrash-guard cut / v0.13.0): the psyche-host thrash
-# guard's loud give-up (PSYCHE_HOST_GIVE_UP, nonzero exit) composes through spt-core's
-# psyche_host_error surface — which exists on older cores — BUT the coupled crashloop story it was
-# ordering-proved against (adapter fires first, core's >=10/60s ledger-rate backstop catches what
-# the streak-reset forgives) only holds on spt-core >= 0.23.0 (counter 43, where C3(b) landed). The
-# floor guarantees the pairing is present; a lone give-up on an older core still degrades safely (it
-# just exits loud, which any residency-managed core handles).
-#
-# Floor BUMPED to 0.25.0 (2026-07-04, the F-030 psyche-ephemeral cut / v0.14.0): the ephemeral-shim
-# driver — per-event [session.psyche_resume] invocation, the core-minted psyche-own sid, the
-# core-written {psyche_context_file} mind file, and the exit-95 reseed contract — ALL land in
-# spt-core v0.25.0 (counter 45, tag v0.25.0, core sha c01fe6ee29c2a19c4a6ebc72f11c471cab7d13d0;
-# doyle GO + deployah publish ping 2026-07-04). On a below-0.25.0 core the shim does one seed turn
-# then STARVES (the daemon never re-invokes) — the silent-degradation class that held this floor as
-# a hard PUBLISH BLOCKER until the core shipped (the v0.13.2 bad-ship lesson). The shim was
-# RC-certified against the exact published v0.25.0 bytes before this pin (windows sha256
-# 0202742115d5bb9109b6abfa336b4d7ec54bb6a99fc1d7561bb83c17016a8491 == the RC-tested anchor).
-min_spt_core_version = "0.27.0"
-hostable_types = ["LiveAgent", "ReadyAgent", "Worker"]
-# host_binaries — STAGED ahead of spt-core v0.9.0 (doyle 2026-06-16). The pid→binary match-key for
-# adapter-agnostic resolution: `spt api listen <id>` resolves the owning adapter/profile by walking
-# parent pid → exe basename → host_binaries match → active-profile pointer → registered_at_ms
-# fallback (CONTEXT §170-186). Additive + N-1-safe: harmless before spt-core reads it (the
-# vendored v0.7.0 schema's [adapter] allows additional props), live once v0.9.0 + `spt adapter use`
-# land. omp's host process basename is `omp`; the RPC bridge (S2) is `omp-spt`. [impl->REQ-SKILL-LIVE]
-host_binaries = ["omp", "omp-spt"]
-# Brands the `spt endpoint run` picker shortcut as `cc-<id>` (default would be `spt-<id>`) — this is
-# the M12 `cc` launcher, and matches the schema's own example (spt-claude-code → `cc`). The launcher
-# brand is DECOUPLED from the plugin name (`omps`, skills `/omps:*`): the s/omps/spt/ succession seam
-# (ADR-0001) renames the plugin, not this shortcut. Guarded by tests/manifest-shortcut.sh
-# (unit->REQ-DIST-SHORTCUT-BASENAME).
+version = "0.2.0"
+# v0.29.0 hardened per-endpoint cwd resolution for relative echo-commune paths.
+min_spt_core_version = "0.29.0"
+# [impl->REQ-OMP-READY-LIVE]
+hostable_types = ["LiveAgent", "ReadyAgent"]
+# Only the genuine OMP host process may resolve to this adapter.
+host_binaries = ["omp"]
 shortcut_basename = "omp"
 
-# ── [update] ───────────────────────────────────────────────────────────────────────────────────
-# Adapter self-update via OUR GitHub releases (gh_release avenue). `spt adapter update`
-# pulls the adapter `.spt` asset from this repo's releases through the same `--release` machinery —
-# no signing infra (closes the F-005 file_pull/delegated blockers). `asset` omitted ⇒ spt's default
-# (adapter.spt), which is now the SINGLE MULTI-PLATFORM fat archive (both x86_64 triples + shared
-# manifest, ADR-0024 W1) — so one asset name auto-resolves the host's binaries. This RETIRES the F-014
-# per-OS stopgap (the old `asset`-less default fetched a windows-only `adapter.spt` that broke on a
-# linux host); no `{os}/{arch}` placeholder is needed since the fat archive is host-agnostic.
-# `message` (U1, REQ-DIST-UPDATE-MESSAGE): markdown spt-core prints ONLY on a real version apply (no
-# `{key}` substitution — docs-confirmed). It bridges the one manual residual the gh_release avenue
-# can't automate — the `/reload-plugins` TUI action — and points at the more-powerful `spt` CLI
-# endpoint route alongside /omps:live. (When doyle ask #2 lands, the post-update step can also trigger
-# this print on a plugin-only change; copy stays valid.)
+# Update through this repository's GitHub release. The packaged fat archive
+# contains both supported target binaries plus the shared native extension.
 # [impl->REQ-DIST-ADAPTER-RELEASE]
 [update]
 avenue = "gh_release"
@@ -488,390 +34,84 @@ loads the packaged extension fresh on each endpoint bringup.
 - Bring up a fresh Librarian endpoint: `spt endpoint run --adapter omp-spt --id <id> --create`.
 """
 
-# ── [update.post] — the delegated plugin-reconcile step (D2, spt-core v0.16.0) ──────────────────
-# spt-core runs this AFTER the gh_release pull+re-register, UNCONDITIONALLY (even on an adapter no-op),
-# completing the one lever `spt adapter update claude-spt` = pull the adapter .spt + reconcile the
-# cplugs plugin. `command` resolves the consolidated binary from the install dir via {adapter_dir}
-# (survives updates). spt-core pipes a one-line JSON context on the command's stdin
-# ({adapter_applied, adapter_name, profile_name, version, previous_version, adapter_dir}; additive —
-# the subcommand ignores unknown keys) and reads its STDOUT to arbitrate the notice: the reserved
-# sentinel `!!update-message!!` (which post-update emits on a successful reconcile) FIRES the
-# [update].message above; custom text would supersede it; empty prints nothing. Exit code is
-# orthogonal and the step is FAIL-ISOLATED (a committed pull is never rolled back on our failure).
-# `self_verifies = false`: attestation-only, gates nothing yet (no signing infra). The reconcile logic
-# rides `spt adapter update` (it lives in the binary), so it stays current without a separate step.
-# [impl->REQ-DIST-UPDATE-MESSAGE]
-[update.post]
-command = "{adapter_dir}/omp-spt post-update"
-self_verifies = false
-
-# ── [hooks.<event>] ──────────────────────────────────────────────────────────────────────────
-# CC hook event → the opaque `api …` command it fires (the representative action; some events do
-# more — e.g. UserPromptSubmit also marks busy + injects skills, PostToolUse self-sends a checkpoint).
-# This table is the registry-side declaration (ADR-0002, F-001 resolution). `reads` = the CC hook-stdin
-# fields we map; `can_inject` = whether the event can surface additionalContext back to the agent.
-# D1 (v0.9.0): the actual handler is now `claude-spt hook <event>` (the binary), not a per-event plugin
-# .sh — the plugin's static-forever hooks.json routes every event through dispatch.sh → the binary
-# (resolved via [strings].hook_cmd above). These declarations stay one-for-one with that wiring.
-
-[hooks.SessionStart]
-# Seed the endpoint — ADAPTER-AGNOSTIC since spt-core v0.9.0 (PREP-4): NO --adapter. The owning
-# adapter resolves at bind time from this seed's {parent_pid} via [adapter] host_binaries (the
-# legacy-parity bare flow). {parent_pid} is a spt-filled key; session_id is a CC stdin field. NOT the
-# blocking poll/listen loop — that is /omps:ready|live, never SessionStart. (Mirrors the hand-written
-# plugin hook session-start.sh, whose bind/boundary branches keep an explicit --adapter override.)
-fires = "api seed --session-id {session_id} --pid {parent_pid}"
-reads = ["session_id", "parent_pid"]
-can_inject = true
-
-[hooks.UserPromptSubmit]
-# TURN-START. Three jobs (plugin user-prompt-submit.sh): (1) mark the perch BUSY (`api state busy`)
-# so inbound DEFERS for mid-turn PreToolUse delivery instead of idle-PTY-inject — honest activity,
-# spt-core never infers it (integration-checklist); (2) DRAIN the inbox (`api poll … --include-deferred`
-# → additionalContext, the representative `fires` below — also pulls anything deferred from the prior
-# busy turn); (3) keyword hints + /omps:X skill-injection. [impl->REQ-DIST-PRETOOL-POLL]
-fires = "api poll {session_id} --include-deferred"
-reads = ["session_id", "prompt"]
-can_inject = true
 
-# PreToolUse — MID-TURN delivery + turn-start busy fallback (F-021). Fires before each tool call: (1)
-# marks the perch BUSY (`api state busy`) — idempotent, and the ONLY busy mark for a turn that started
-# WITHOUT a UserPromptSubmit (a Monitor-delivered message triggers a new turn with no user prompt; the
-# first tool call is then the earliest turn-active signal); (2) drains messages DEFERRED while busy
-# (`api poll … --include-deferred` → additionalContext, the representative `fires` below) so a live
-# agent receives a message WHILE working. The mid-turn complement of the UserPromptSubmit between-turns
-# drain — together the legacy spt poll+inject-on-PreToolUse reachability. [impl->REQ-DIST-PRETOOL-POLL]
-[hooks.PreToolUse]
-fires = "api poll {session_id} --include-deferred"
-reads = ["session_id", "tool_name"]
-can_inject = true
 
-[hooks.Stop]
-# TURN-END. Idle marker (`api state busy`'s counterpart) — also arms the echo-gate sentinel since Stop
-# cannot inject (F-001 §Gap3). Pairs with the UserPromptSubmit busy mark for honest turn-state.
-fires = "api state idle"
-reads = ["session_id"]
-can_inject = false
-
-[hooks.SessionEnd]
-fires = "api session-end {session_id}"
-reads = ["session_id"]
-can_inject = false
-
-[hooks.SubagentStart]
-fires = "api worker-start {session_id}"
-reads = ["session_id"]
-can_inject = false
-
-[hooks.SubagentStop]
-fires = "api worker-stop {session_id}"
-reads = ["session_id"]
-can_inject = false
-
-# PostToolUse — the CHECKPOINT detector (Feature 2). On a Write to the live agent's own
-# `.claude/<id>-commune.md` whose content carries the literal `!!checkpoint!!` trigger, the hook
-# marks the perch idle (`api state idle`) then SELF-SENDS a reserved structured signal
-# (`spt send --from <id> <id> --json-payload {"checkpoint":"v1","wake":…}`) that loops back through
-# the endpoint's own [message-idle-translation-binary], which fires the clear+wake macro — an
-# agent-driven context reset (the operator's manual `/clear`, done by the agent). The `fires` line
-# below names the representative `api` action (the idle mark); the conditional self-send is the
-# wrapper's specialized behavior (plugin/omps/hooks/post-tool-use.sh). `can_inject=false`: delivery
-# is the self-send loopback, not additionalContext. spt-hosted live sessions only. The `!!checkpoint!!`
-# file-content marker is the WRITE-side trigger; spt-core v0.15.0 strips it from the durable + pending
-# context on ingest, so it is one-shot (never persists in the resumed mind, never re-fires). The
-# `--json-payload` self-send is the DELIVERY-side trigger. [impl->REQ-DIST-CHECKPOINT-COMMUNE]
-[hooks.PostToolUse]
-fires = "api state idle {session_id}"
-reads = ["session_id", "tool_name", "tool_input"]
-can_inject = false
-
-# ── [identity] ─────────────────────────────────────────────────────────────────────────────
 [identity]
-# CC hands the session_id on hook stdin once running (discovered post-spawn, not injected).
+# OMP reports the bound session id after spawn; the process-tree fallback is
+# the native host executable, never the adapter helper.
 session_id_source = "post_spawn"
-# Process-tree anchor when session_id is absent: the omp / omp-spt bridge binary.
 parent_ancestor_name = "omp"
 
-# ── [session] ──────────────────────────────────────────────────────────────────────────────
-# Watched-dir seams for the file-drop lifecycle (doyle 2026-06-15: commune/signoff are FILE-DROPS,
-# not api verbs — "there is deliberately no api commune"). The agent writes `<endpoint_id>-commune.md`
-# / `<endpoint_id>-signoff.md` into this dir; spt-core's daemon watcher ingests it into the endpoint's
-# tracked mind, then deletes it (daemon = single writer). The filenames are fixed by the contract;
-# only the dir is adapter-declared. `.claude` is CC's per-project state dir — where a live CC session
-# already drops these (matches the live-agent reorientation), resolved per-endpoint against its cwd.
-# /omps:commune writes the commune file here; /omps:signoff's graceful path is `endpoint shutdown`
-# (the signoff file-drop is the watcher's equivalent). [impl->REQ-DIST-MANIFEST-SCHEMA]
 [session]
-commune_dir = ".claude"
-signoff_dir = ".claude"
+# [impl->REQ-OMP-CONTINUITY-DROPS]
+commune_dir = ".spt"
+signoff_dir = ".spt"
 
-# ── [session.psyche_init] — LIVE-CAPABILITY GATE ONLY (v0.14.0 F-030: never spawned) ───────────────
-# base is LIVE-CAPABLE (Option A, doyle-ruled + code-confirmed 2026-06-17): the Psyche-spawn seam lives
-# in the BASE manifest, not a `:live` profile. ready-vs-live is the COMMAND, not the profile —
-# `/omps:live` (`spt api listen`) stamps state=live_agent → the daemon livehost hosts the Psyche; the
-# livehost checks psyche_init on the resolved manifest. `/omps:ready` stamps state=ready_agent →
-# livehost SKIPS the Psyche regardless (livehost.rs:282 gate).
-#
-# EPHEMERAL MODEL (v0.14.0): psyche_init is NO LONGER A SPAWN PATH. The daemon reads it ONLY as the
-# live-capability gate (`manifest.session.psyche_init.as_ref()`, lifecycle.rs:365 — its presence
-# decides "this endpoint hosts a psyche"). Every actual turn — including the FreshWithPreload first
-# turn — is driven through [session.psyche_resume] below (one role, two key shapes). This table is
-# KEPT DECLARED + noop-safe: it mirrors psyche_resume's command shape, so an accidental spawn (a
-# partial apply / a stray driver) runs one safe ephemeral turn rather than misbehaving. [impl->REQ-SKILL-LIVE]
-# NO cwd TEMPLATE (v0.14.2): `{psyche_dir}` is a RETIRED resident-era key the F-030 fill catalog
-# never carried (doyle P-1 verdict 2026-07-06, runtime.rs:65 "a catalog key must have a real fill";
-# the freeze fills exactly {id, session_id, parent_session_id, psyche_context_file, node, subnet}).
-# Referencing it faulted EVERY per-event turn at substitution (flynn's dead psyche). The psyche cwd
-# is now the SHIM's job: it chdirs to the {psyche_context_file} parent dir (the psyche's nested
-# perch dir — the same location the retired fill pointed at) before spawning claude, keeping the
-# sid+cwd transcript-resolution pair stable across turns. [impl->REQ-PSYCHE-EPHEMERAL-SHIM]
-# S4 (omp-spt): the psyche shim is `psyche-omp` (psyche_omp.rs) — same frozen turn contract,
-# omp-flavored: continuity keys on a private --session-dir (omp cannot adopt a minted sid), the
-# session-gone reseed (exit 95) is a shim-side dir check (omp -c silently degrades, verified), and
-# the composed prompt rides an @file (omp -p ignores a stdin-only prompt, verified).
+# The base manifest is live-capable. ReadyAgent and LiveAgent use the same OMP
+# endpoint; only LiveAgent activates the per-event Psyche role.
+# [impl->REQ-PSYCHE-EPHEMERAL-SHIM]
 [session.psyche_init]
 command = "omp-spt psyche-omp --id {id} --session-id {session_id} --psyche-context-file {psyche_context_file}"
-# Identity-env scrub (F-028 C2): a spawned psyche must never inherit its parent's identity env —
-# inherited OWL_SESSION_ID/SPT_AGENT_ID make the psyche's hooks resolve "self" to the PARENT and
-# rebind THAT perch. Kept on the gate table too (defence-in-depth if ever spawned).
-# [impl->REQ-HAZARD-PSYCHE-IDENTITY-ENV]
+# Prevent a child Psyche from inheriting its parent's SPT identity.
 env_remove = ["OWL_SESSION_ID", "SPT_AGENT_ID"]
 keys = ["id", "session_id", "psyche_context_file"]
 
-# ── [session.psyche_resume] — the EPHEMERAL shim's ONE spawned role (v0.14.0 F-030) ────────────────
-# The daemon drives EVERY psyche turn through this table: one `claude-spt psyche` invocation = one
-# headless `claude` turn, run to completion, then exit (PSYCHE-EPHEMERAL-PLAN.md; doyle W1/W2 contract
-# FREEZE 944a74b0). One role, TWO key shapes (contract Q2):
-#   * FreshWithPreload (first turn): the mind FILE is NON-EMPTY (core writes the composed mind before
-#     spawn) + {session_id} = the core-MINTED psyche-own sid → the shim ADOPTS it (`claude -p --session-id`).
-#   * ContinueExisting (later turn): the mind FILE is EMPTY (core writes it truly empty — NO sentinel;
-#     W4 binding invariant) + same stored {session_id} → the shim RESUMES (`claude -p --resume`). The
-#     shim discriminates on the FILE CONTENT's emptiness (trim-based).
-# I/O (W4, contract 9e6863d0): {psyche_context_file} (ALWAYS filled — a path to the core-written mind
-# file in the psyche's nested perch dir) rides argv; the shim READS it to get the mind (W4 kills the
-# win32 ~32k cmdline cap — ~20KB minds used to ride argv). The per-turn EVENT rides the shim's STDIN
-# (core feeds it — a bare pulse = `<pulse/>`); the psyche's reply rides the shim's CAPTURED STDOUT (the
-# daemon parses intents from it). The daemon runs this role NON-detached, stdin-fed, stdout-captured,
-# bounded (turn.rs run_bounded_stdin) — NOT the old Stdio::null detached spawn; hence detach=false.
-# Reseed is signalled by the shim's reserved EXIT CODE 95 (session-gone); every other nonzero keeps
-# custody. The `<parent>-psyche` perch + the psyche-custody.json sid record are CORE-owned — the shim
-# mints nothing, writes nothing to custody. [impl->REQ-PSYCHE-EPHEMERAL-SHIM]
-# NO cwd TEMPLATE (v0.14.2) — same {psyche_dir} retirement as psyche_init above; the shim owns the
-# cwd (context-file parent dir). [impl->REQ-PSYCHE-EPHEMERAL-SHIM]
-# S4 (omp-spt): same psyche-omp shim as the psyche_init gate above (one role, two key shapes).
+# Each Psyche event is one bounded OMP turn. The context file is read by the
+# shim, the event arrives on stdin, stdout carries the result, and exit 95 asks
+# spt-core to reseed after the private OMP session directory disappears.
+# [impl->REQ-PSYCHE-EPHEMERAL-SHIM]
 [session.psyche_resume]
 command = "omp-spt psyche-omp --id {id} --session-id {session_id} --psyche-context-file {psyche_context_file}"
 detach = false
-# Identity-env scrub on BOTH psyche roles (F-028 C2). [impl->REQ-HAZARD-PSYCHE-IDENTITY-ENV]
+# Prevent a child Psyche from inheriting its parent's SPT identity.
 env_remove = ["OWL_SESSION_ID", "SPT_AGENT_ID"]
 keys = ["id", "session_id", "psyche_context_file"]
 
-# ── [session.self] ─────────────────────────────────────────────────────────────────────────
-# The spt-hosted bringup template (publish target #2's launcher seam). `spt endpoint run --adapter
-# claude-spt --id <id>` spawns this command into a broker-held PTY; CC self-registers its perch
-# post-spawn (`api bind <id>`, the spt-hosted path — NOT the seed→listen path /omps:ready|live uses).
-# This is what the `cc-<id>` shortcut (shortcut_basename="cc") bakes into a non-interactive launch.
-#
-# command is the `claude-spt launch` SHIM (0.10.3+, the delivered doyle-ask-#4 stretch): it spawns
-# `claude -n "<id> @ <node> (<project>/)" --remote-control <id>--<node>--<project-token> --dangerously-skip-permissions`
-# (unix: exec — claude IS the PTY leader; windows: spawn+wait, stdio inherited). CC mints its OWN
-# session id internally (identity.session_id_source = post_spawn), so spt's {session_id} is not threaded
-# on argv. The endpoint {id} is threaded THREE ways (U6, REQ-DIST-RC-STARTUP): it rides the ENV for the
-# BIND (CC has no id flag, so SessionStart reads $SPT_ENDPOINT_ID and binds — see
-# [env.SPT_ENDPOINT_ID] below, the sanctioned flagless-harness pattern), AND it sets the DISPLAY
-# name (`-n "<id> @ <node> (<project>/)"`, shown in the prompt box / `/resume`) AND the REMOTE-CONTROL
-# channel (`--remote-control <id>--<node>--<project-token>`) — so a FRESH spt-hosted endpoint is
-# `spt rc <id>`-attachable + idle/checkpoint-injectable identically to a RESUMED one ([session.resume]).
-# WHY A SHIM: the node label arrives via the `--node {node}` fill (spt-core v0.20.0, the adopted
-# doyle-ask-#4 key — the daemon's ADVERTISED label, matching the rest of the spt surface), and the
-# <project> folder is the launch-cwd basename (no {project} fill exists) — both computed ON-NODE; and
-# tokenize-then-fill (v0.8.2+) can never yield a space-carrying single argv element — the shim passes
-# each name as one clean argv element, and falls back to on-node hostname detection when the {node}
-# fill is blank or literally unsubstituted (F-013 gap class). The DISPLAY name uses the raw project
-# folder (spaces/parens/slash fine). RC gets the tokeny `<id>--<node>--<project-token>` form with a
-# CHARACTER-SAFE project token (alphanumeric + `-`/`_`, other runs → `_`; CC's auto-generated RC names
-# are hostname-prefixed tokens; space-safety of an explicit RC name is unverifiable from the public
-# surface). Unknown project ⇒ drop only its suffix; unknown node ⇒ bare `<id>` for both (the pre-0.10.3
-# shape); `spt rc <id>` attaches by ENDPOINT id either way (broker-internal, not CC's RC name).
-# `--dangerously-skip-permissions` stays required for the spt-hosted bringup:
-# the broker spawns CC non-interactively into a PTY, so the permission-prompt gate would deadlock
-# the launch with no operator to approve it (the shim passes it through).
-# [impl->REQ-DIST-SHORTCUT-BASENAME]
-#
-# ── omp-spt: native OMP owns the broker PTY ─────────────────────────────────────────────────────
-# Issue #2 proved that the headless RPC bridge can expose only bridge logs when an operator attaches.
-# Native `omp` is therefore the session process; its packaged extension owns SPT bind/listen/state/
-# reply integration through OMP's public extension API. See ADR-0007. [impl->REQ-OMP-NATIVE-TUI]
+# Fresh endpoints launch validated native OMP with the packaged extension. OMP,
+# rather than the adapter helper, remains the broker PTY owner.
+# [impl->REQ-OMP-NATIVE-TUI]
 [session.self]
-command = "omp --extension {adapter_dir}/strings/omp-spt.mjs"
+# [impl->REQ-OMP-EXECUTABLE-RESOLUTION]
+command = "{adapter_dir}/omp-spt launch-omp --extension {adapter_dir}/strings/omp-spt.mjs"
 keys = []
 
-# ── [session.resume] — native-resume sibling of [session.self] (harness-contract v0.13.0+) ─────
-# spt-core selects THIS over [session.self] when a bringup carries a prior session (`spt endpoint run
-# --resume <session>` or the picker's "Resume from history") AND this role is declared. OMITTING it
-# silently falls back to [session.self] → a fresh session with a BLANK transcript (the documented
-# footgun). The PTY lands in the resumed session's recorded project cwd; CC resolves the transcript by
-# {session_id} + cwd.
-#
-# Command = the same `claude-spt launch` shim with `--resume {session_id}` (0.10.3+): it spawns
-# Claude Code's NATIVE-RESUME verb `claude -r <session_id> -n "<id> @ <node> (<project>/)"
-# --remote-control <id>--<node>--<project-token> --dangerously-skip-permissions` (-r/--resume reloads
-# the real transcript by id).
-# The endpoint {id} is threaded TWO ways: as the DISPLAY name (U6 — shown in the prompt box /
-# `/resume`, matching [session.self] so a fresh and a resumed endpoint present identically) AND as
-# the REMOTE-CONTROL name — both node-suffixed by the shim, same shapes + degrade rule as
-# [session.self]. (A resumed session has no $SPT_ENDPOINT_ID env-bind path — -n/RC are how {id}
-# attaches here; `spt rc <id>` still addresses the broker PTY by ENDPOINT id.)
-# `--dangerously-skip-permissions` for the same non-interactive broker-PTY reason as [session.self]
-# (REQ-HAZARD-PSYCHE-PERMS-DEADLOCK). keys = the two fills spt-core substitutes: {session_id} (the
-# resumed id) + {id} (the endpoint). Satisfies REQ-DIST-SESSION-RESUME (native-resume seam) +
-# REQ-DIST-RC-STARTUP (display+RC parity with [session.self]); the shim's command shape is unit-
-# tested in tools/claude-spt (launch.rs) and the manifest shape in tests/manifest-shortcut.sh.
-# omp-spt resume keeps the same native TUI and extension, while `-r` asks OMP to reload the real
-# transcript. The extension binds the resumed OMP session id to the current SPT endpoint.
+# Resume uses OMP's native session selector while preserving the same native
+# TUI, extension, and executable validation as a fresh endpoint.
 [session.resume]
-command = "omp -r {session_id} --extension {adapter_dir}/strings/omp-spt.mjs"
+# [impl->REQ-OMP-EXECUTABLE-RESOLUTION]
+command = "{adapter_dir}/omp-spt launch-omp --resume {session_id} --extension {adapter_dir}/strings/omp-spt.mjs"
 keys = ["session_id"]
 
-# ── [session.echo_commune] — the bounded end-of-session summarizer (v0.15.2) ───────────────────────
-# Published contract: "when a session ends without a signoff, spt-core runs a bounded summarizer
-# over the session's history so the context delta is captured anyway"; on core 0.27/0.28 the
-# commune-sync per-event turn ALSO spawns it, and a MISSING role 3-strikes the whole psyche host
-# (flynn 2026-07-07 field pin — psyche_host_error, checkpoints dead). The shim accepts history on
-# stdin when fed (kept for the future published wiring — doyle field pin 2026-07-07: core does NOT
-# stdin-feed [history] today) and otherwise SELF-LOCATES the transcript, most-authoritative rung
-# first: the perch info.json read_env.CLAUDE_CONFIG_DIR (doyle-sanctioned; the role spawn does not
-# inherit the session env, so ccs-relocated transcripts are invisible to the env rung) → the env →
-# ~/.claude/projects → every ~/.ccs/instances/<account>/projects. Bounded whole-line tail, ONE
-# headless `claude -p` turn (psyche-parity sandbox, Read-only tools — a summarizer never writes),
-# delta on stdout for core to ingest. Locate-miss is GRACEFUL (no-delta marker + exit 0 — a v0.15.2
-# exit-1 here rode the psyche host's 3-strike budget and latched two hosts); only real claude
-# faults stay loud nonzero (ECHO_COMMUNE_FAIL:).
-# recursion_guard_env: core sets SPT_ECHO_COMMUNE on the shim; the claude it spawns inherits it and
-# `claude-spt hook` BAILS (exit 0, zero api calls) under it — the inner session can never
-# seed/bind/rebind a perch (no summarizer-of-summarizer loops). Identity-env scrub rides too
-# (F-028 C2 discipline, same as both psyche roles). [impl->REQ-SESSION-ECHO-COMMUNE]
-# S4 (omp-spt): the summarizer is `echo-commune-omp` — self-locates the OMP session JSONL (the
-# digest-omp locator), bounded whole-line tail, ONE read-only headless `omp -p` turn (the prompt
-# rides an @file), delta on stdout. Locate-miss stays GRACEFUL (no-delta marker + exit 0). The
-# recursion_guard_env is kept for parity, but the omp path cannot loop: an `omp -p` turn runs no
-# spt hook layer at all (--no-extensions; the RPC bridge owns lifecycle).
+# The bounded summarizer reads the selected OMP session JSONL and runs one
+# extension-free OMP turn. A missing transcript is an empty delta; a real OMP
+# failure is reported to spt-core.
+# [impl->REQ-SESSION-ECHO-COMMUNE]
 [session.echo_commune]
 command = "omp-spt echo-commune-omp --id {id} --session-id {session_id}"
 detach = false
 recursion_guard_env = "SPT_ECHO_COMMUNE"
-# [impl->REQ-HAZARD-PSYCHE-IDENTITY-ENV]
+# Prevent the summarizer from inheriting its parent's SPT identity.
 env_remove = ["OWL_SESSION_ID", "SPT_AGENT_ID"]
 keys = ["id", "session_id"]
 
-# ── [history] — the transcript-access seam (v0.15.2; the echo-commune's feeder) ────────────────────
-# Contract: "[history] … stays opaque + single-session and feeds the echo-commune verbatim"; core
-# has NO built-in transcript parser for any harness. strategy="fetcher": the adapter's own binary
-# locates the CC JSONL transcript (SAME machinery + --config-dir precedence as the [digest] fetcher
-# above: {CLAUDE_CONFIG_DIR} read-var → $CLAUDE_CONFIG_DIR env → ~/.claude/projects; a literally-
-# unsubstituted {CLAUDE_CONFIG_DIR} argv is treated as absent — F-013 literal-brace guard class)
-# and streams the file to stdout VERBATIM. Opaque bytes: the only consumer is our own echo_commune
-# summarizer, so raw CC JSONL is the interchange format by construction. Missing transcript =
-# HISTORY_FAIL: + exit 1, never silent-empty stdout. [impl->REQ-HISTORY-FETCHER]
-# S4 (omp-spt): the fetcher is `history-omp` — locates `*_<session_id>.jsonl` under the omp
-# sessions root (~/.omp/agent/sessions; the digest-omp locator) and streams it VERBATIM. No
-# {CLAUDE_CONFIG_DIR} dependency. Missing transcript = HISTORY_FAIL: + exit 1, never silent-empty.
+# History is the opaque JSONL for exactly one OMP session.
+# [impl->REQ-HISTORY-FETCHER]
 [history]
 strategy = "fetcher"
 fetcher = "omp-spt history-omp --session {session_id}"
 
-# ── [env.<VAR>] ────────────────────────────────────────────────────────────────────────────
-# Broker-injected env for spt-hosted (bind-path) sessions. The endpoint {id} is injected so CC's
-# SessionStart hook can self-register the right perch via `api bind $SPT_ENDPOINT_ID`. spt-hosted
-# sessions inherit env from the spawning broker, so no `channel` is needed (that field is for the
-# harness-hosted injection path). [impl->REQ-DIST-SHORTCUT-BASENAME]
-#
-# KNOWN-MINOR (F-013, doyle-ruled 2026-06-17): the `{id}` substitution into this inject value is only
-# applied by `spt endpoint run` on **spt-core >= 0.11.0** (REQ-HAZARD-ENV-SUBST). On < 0.11.0 the value
-# arrives EMPTY → SessionStart sees no $SPT_ENDPOINT_ID → it SEEDS (harness-hosted path) instead of
-# binding → the spt-hosted endpoint-run yields no perch (silent; no error). NOT floor-bumped:
-# min_spt_core stays 0.9.0 because the ready/live flows work on 0.9.0, and a blanket floor would
-# needlessly block them on older nodes (doyle). A runtime adapter guard was rejected too — a
-# < 0.11.0 endpoint-run spawn is ENV-INDISTINGUISHABLE from a normal user-launched seed session (both
-# have SPT_RELEASE_SEED/OWL_SESSION_ID set + SPT_ENDPOINT_ID empty; verified), so a guard would
-# false-positive "update spt" on every normal seed. The case is narrow + transient (only bites a node
-# still on < 0.11.0 running `endpoint run`; the fleet updates forward). Doc-note only.
+# The native extension uses the endpoint id injected by spt-core when binding
+# the OMP session.
 [env.SPT_ENDPOINT_ID]
 direction = "inject"
 value = "{id}"
 
-# ── [env.SPT_INJECT_VERIFY_ECHO] — Layer-2 echo-verify opt-in (W6 LIFECYCLE-TRUTH) ───────────
-# doyle W6-DISPATCH-RULING item 3: W5-A shipped the broker seam (SPT_INJECT_VERIFY_ECHO
-# declared-capability, broker default OFF). CC's TUI re-renders typed text, so an inject that
-# echoes back is a VALID verification belt — a CC-hosted session opts IN by declaring the flag =1.
-# This is adapter DATA (the ON switch), NOT a spt-core requirement (per the adapter-glue boundary):
-# the broker reads the injected capability at spawn and arms echo-verify for the session. Inert +
-# forward-safe on cores below the W5-A seam (an unknown env var the session ignores; the broker's
-# default stays OFF), so the floor is NOT bumped here — the counter-49 floor bump is doyle's
-# coordinated ping. Evidence is unit-side (tests/manifest-shortcut.sh — .toml is scan-invisible):
-# REQ-INJECT-VERIFY-ECHO.
-[env.SPT_INJECT_VERIFY_ECHO]
-direction = "inject"
-value = "1"
-
-# ── [inject] ───────────────────────────────────────────────────────────────────────────────
-[inject]
-# v1 delivery is the hook channel only (UserPromptSubmit/SessionStart additionalContext).
-# PTY injection is spt-core M3 roadmap (F-001 resolution); not claimed here.
-activity = ["hook"]
-idle = ["hook"]
-
-# ── [message-idle-translation-binary] — agnostic idle PTY delivery (harness-contract v0.13.0+) ─
-# The IDLE-delivery seam for spt-HOSTED sessions: a lifecycle-managed stdin→stdout JSON-lines binary
-# spt-core spawns when the endpoint comes online and reaps on shutdown. It turns each inbound <EVENT>
-# envelope into keystroke-commands spt-core applies ATOMICALLY to the broker-held PTY (operator input
-# is buffered during emission, so it coexists with an attached `spt rc` controller). This is the
-# spt-hosted complement to the [inject] hook channel above: [inject] handles BUSY/mid-turn delivery
-# (UPS additionalContext); this handles IDLE delivery into a session sitting at its input box.
-#
-# `command` = the program+args spt-core spawns (spt-core v0.16.0 seam; `path` deprecated, exactly one
-# of {path,command}). `{adapter_dir}` substitutes the install dir (survives updates), so the filter is
-# now the `translate` subcommand of the ONE consolidated claude-spt binary — D3 fold, ADR-0006 (was
-# the standalone cc-spt-idle-translate; protocol unchanged). The subcommand emits the operator-specified
-# choreography per message — ctrl+s (stash draft) · 50ms · <envelope> · 50ms · {"key":"enter"} (submit)
-# · {"commit":true} (terminate sequence) — so an inbound message never clobbers a half-typed draft (CC
-# AUTO-RESTORES the stashed draft after submit, so no trailing restore keystroke). TWO distinct signals
-# (doyle-confirmed from broker.rs): (1) the discrete {"key":"enter"} submits the PTY line (a verbatim \r
-# byte does NOT submit a CC message — corrected 2026-06-23); the binary still neutralizes the envelope's
-# internal CR/LF since spt-core applies {"text"} VERBATIM (broker.rs:1016-1017). (2) {"commit":true} is
-# the MANDATORY inject-sequence terminator: run_inject_worker (broker.rs:1075-1090) ends a sequence ONLY
-# on {commit}; without it the broker FAULTs at the 5s INJECT_COMMIT_DEADLINE. Satisfies
-# REQ-DIST-IDLE-TRANSLATE (scanned impl evidence = tools/claude-spt/src/translate.rs; .toml is unscanned).
-[message-idle-translation-binary]
-command = "{adapter_dir}/omp-spt translate"
+# Message delivery is extension-owned; no hook or PTY-translation surface is
+# declared by the native adapter.
 
-# ── [digest] ───────────────────────────────────────────────────────────────────────────────
-# Session-digest extractor seam. CC's transcript is JSONL (one event per line); the
-# extractor maps that native log → the published {role,text,tool,ts} digest-record contract,
-# one JSON record per output line. (CC has a rich log, so the extractor seam fits — a defensible
-# divergence from the deliberately log-less mock adapter, which declares no [digest].)
-#
-# FETCHER strategy (spt-core v0.19.0, REQ-DIGEST-FETCHER-STRATEGY): the extractor LOCATES + reads +
-# emits itself; spt-core only runs it bounded and consumes stdout — no locate, no pre-read, no
-# `source` (ignored under fetcher, so it is dropped). This is the designed home for CC's PARTITIONED
-# layout: transcripts live at `<config-root>/projects/<cwd-slug>/<session_id>.jsonl` where the
-# cwd-slug is a CC-internal encoding with NO published key (doyle 2026-06-15: spt-core stays
-# harness-agnostic — by design there is no {cwd_slug}), so the adapter owns the locate
-# (owlery::claude_projects_root pattern — search the projects root for `<session_id>.jsonl`).
-# spt-core feeds only harness-NEUTRAL fills: {session_id} + the captured {CLAUDE_CONFIG_DIR}
-# read-var (below). `--config-dir` receives the CAPTURED per-session value — ccs sessions resolve
-# their relocated `~/.ccs/instances/<account>/.claude` tree, base sessions the `~/.claude` fallback —
-# closing the "not expressible as a static catalog path" gap in the daemon's own context (the old
-# env-preference branch only worked when the extractor inherited the session's env). The extractor
-# (`claude-spt digest`, ADR-0006/U2) ships in the spt-core-conducted layer; this is its declaration.
-# [impl->REQ-DIST-DIGEST-FETCHER]
-# ── S3 (omp-spt): the extractor is `digest-omp`, not the CC `digest` ───────────────────────────
-# The extractor is `claude-spt digest-omp` (digest_omp.rs): it maps oh-my-pi's native session JSONL
-# (~/.omp/agent/sessions/<dir-encoded>/<ts>_<sessionId>.jsonl) to the SAME digest-record contract as
-# the CC `digest` (shared `rec()` emitter). It LOCATES the file by {session_id} under the omp
-# sessions root, so no {CLAUDE_CONFIG_DIR} read-var is needed (the CC-lineage comment above and
-# [env.CLAUDE_CONFIG_DIR] below are inert for omp). Proven with `spt adapter digest-proof omp-spt
-# --sample <omp-session.jsonl>`. [impl->REQ-DIST-DIGEST-EXTRACTOR]
+# The fetcher locates one OMP session JSONL and emits the published digest
+# record stream.
+# [impl->REQ-DIST-DIGEST-EXTRACTOR]
 [digest]
 strategy = "fetcher"
 extractor = "omp-spt digest-omp --session {session_id}"
@@ -879,126 +119,6 @@ window_turns = 6
 arg_truncation = 240
 sprint_collapse = true
 
-# ── [env.CLAUDE_CONFIG_DIR] — the read-direction capture (spt-core v0.19.0) ─────────────────────
-# direction="read": spt-core CAPTURES this var from the session's environment at bind time into
-# info.json.read_env, then offers it as a fill_template key ({CLAUDE_CONFIG_DIR}) to on-demand
-# commands — the [digest] fetcher extractor above. `value` is the FALLBACK when the session env
-# lacks it (a plain `claude` launch), tilde-expanded spt-core-side: `~/.claude` = CC's default
-# state root. A ccs-launched session carries CLAUDE_CONFIG_DIR=~/.ccs/instances/<account>/.claude
-# in its env → captured → the extractor locates the relocated projects tree with zero profile
-# overlay (the NO-[profiles.ccs.digest]-leaf design, now daemon-context-correct).
-# [impl->REQ-DIST-DIGEST-FETCHER]
-[env.CLAUDE_CONFIG_DIR]
-direction = "read"
-value = "~/.claude"
-
-# ── [profiles.<name>] ────────────────────────────────────────────────────────────────────────
-# S4 (omp-spt): NO shipped profile overlays. claude-spt's `ccs` profile (the Claude Code
-# model/billing multiplexer, kaitranntt/ccs) was REMOVED here — it swapped CC's launch binary,
-# which is meaningless for an omp bringup; omp's own model/billing routing is native config
-# (~/.omp/agent/models.yml — see docs/OMP-OPENROUTER.md, S5) and per-endpoint isolation is
-# `--profile <name>` forwarded to omp through the bridge's `--` passthrough. Node-local user
-# profiles are still created with `spt adapter create-profile` and live in the registry, never
-# in this manifest.
-#
-# NOTE: there is no `:live` profile (removed 2026-06-17, PREP-4 Option A, inherited). The LiveAgent
-# seam `[session.psyche_init]` lives in the BASE manifest above — base is live-capable, and
-# ready-vs-live is the command (`api listen` vs `api poll`), not a profile.
 
-# ── [strings] ──────────────────────────────────────────────────────────────────────────────
-# Opaque adapter data (spt-core never executes it), dot-path-readable via `spt adapter get-string`.
-# Seed only this slice — the file-backed skill-instruction BODIES (UPS-injection source) land in
-# the M12 file-backed-strings parity slice. A profile may leaf-replace any key here.
 [strings]
 adapter_label = "oh-my-pi (spt)"
-# hook_cmd (D1, REQ-DIST-HOOK-BINARY): the resolve-not-execute primitive that lets the plugin's
-# hooks.json + dispatch.sh go static-forever. `{adapter_dir}` is lazily substituted at
-# `spt adapter get-string` read time (spt-core v0.16.0) to the absolute install dir, so the value
-# resolves to `<install_dir>/claude-spt hook` — the consolidated binary's hook subcommand, which
-# survives adapter updates. dispatch.sh get-strings this ONCE per session (caches it in
-# $SPTC_HOOK_BIN), then runs `<resolved> <CCEventName> --host-pid <pid>` per hook, piping the CC hook
-# payload on stdin. Session-scoped keys are NOT available here (get-string is adapter-static) — the
-# binary reads session_id/prompt/tool_input from stdin. [impl->REQ-DIST-HOOK-BINARY]
-#
-# v0.9.1 FIX: the value is the bare binary PATH (no trailing ` hook`). dispatch.sh appends the `hook`
-# subcommand as a literal and caches this path QUOTED in $CLAUDE_ENV_FILE. The v0.9.0 value
-# ("{adapter_dir}/claude-spt hook", a space before `hook`) was cached unquoted → CC sources the env
-# file per Bash call → `SPTC_HOOK_BIN=/path/claude-spt hook` parsed as `VAR=val cmd` → ran `hook`
-# (`hook: command not found` on every Bash command) AND dropped the value. dispatch.sh also strips a
-# trailing ` hook` defensively, so it stays compatible with an older manifest mid-update.
-hook_cmd = "{adapter_dir}/omp-spt"
-
-[strings.notice]
-not_installed = "spt-core not found on PATH — run /omps:setup to install it."
-
-[strings.skills]
-# Operative UPS-injection skill bodies. File-backed values (`{ file = "skills/<x>.md" }`) live in the
-# adapter aux dir `adapter/strings/skills/` (copied to `adapters/<adapter>/strings/` on `adapter add`,
-# resolved lazily at `spt adapter get-string` — proven vs live v0.7.0, F-003). File-backed so the
-# manifest does not bloat (ADR-0001). Skills not yet authored keep a one-line inline summary until
-# their body lands; converting an inline summary to a `{ file }` pointer is the per-skill increment.
-# whoami SKILL dropped (SCOPE LOCKED parity-trim; operator-confirmed 2026-06-15): core `spt whoami`
-# stays in the hot path (-> M12 `endpoint list` alias), so the adapter ships no whoami skill. The
-# "who am i" hint below points at the core CLI. (docs/PARITY.md.)
-setup = { file = "skills/setup.md" }
-ready = { file = "skills/ready.md" }
-version = { file = "skills/version.md" }
-list-agents = { file = "skills/list-agents.md" } # -> spt endpoint list (the roster)
-force-stop = { file = "skills/force-stop.md" } # -> spt endpoint shutdown (graceful, tears down Psyche)
-subnet = { file = "skills/subnet.md" }         # -> spt subnet {status,create,show-code,join} (cross-machine); REQ-SKILL-SUBNET
-# `send` / `commune` / `signoff` are NOT injected here — but NOT because their prose lives in the
-# plugin SKILL.md (it no longer does; U4/REQ-DIST-SKELETON-THIN thinned those to stubs, 2026-06-25,
-# superseding the 2026-06-19 full-fat-SKILL.md decision). The reason they aren't UPS skills stands: a
-# live agent uses them REACTIVELY (replying, briefing its Psyche, signing off) WITHOUT typing
-# `/omps:<skill>`, so UPS-injection is the wrong delivery. Instead the prose is delivered PROACTIVELY:
-# `send` rides the `messaging-perch` brief; `commune` (incl `--checkpoint`) + `signoff` ride the new
-# `live-ops` brief (below) — both composed into the perched SessionStart brief — and the go-live
-# moment carries them inline in `skills/live.md`. So the prose rides `spt adapter update`, the plugin
-# SKILL.md stays a true skeleton, and there is no `[strings.skills]` entry for these three.
-# `live` -> upgrade THIS session to a LiveAgent (Option A, 2026-06-17): base claude-spt is live-capable
-# ([session.psyche_init] in base), so going live is just the COMMAND — bare `spt api listen <id>` under
-# a Monitor relay. The live listen path stamps the perch state=live_agent → the daemon livehost hosts
-# the Psyche (livehost.rs:282 gates on live_agent state, doyle). No `:live` composite, no --adapter.
-live = { file = "skills/live.md" }             # -> bare `spt api listen <id>` + Monitor relay (LiveAgent)
-# `new-alarm` -> EXPLICIT OUT OF SCOPE for v1: no core `spt` alarm/timed-pulse primitive exists
-# (legacy $LIVE TIMED PULSE is owl/Psyche-layer, not lifted into core; adapters don't add core
-# features). doyle carries a parity-gap finding to mint a core deferred-pulse primitive; the skill
-# lands only after that ships. No `[strings.skills].new-alarm` entry by design (visible-not-silent).
-
-# ── [strings.briefs] ─────────────────────────────────────────────────────────────────────────
-# SessionStart agent-facing briefs. Same file-backed/inline machinery as [strings.skills] (resolved
-# via `spt adapter get-string claude-spt briefs.<key>`). The hook COMPOSES + {id}-substitutes these;
-# it never authors agent-facing prose (single-source throughline). Composable so the shared roster +
-# messaging text live once: the identity brief (perched sessions — bind+boundary) = identity +
-# messaging-perch + endpoint-list; the ring brief (no-perch seed, peer-gated) = messaging-no-perch +
-# endpoint-list. Liveness-agnostic (no live/ready split — deferred, public liveness-query gap, logged
-# with doyle). One-liners inline; multi-line bodies file-backed under adapter/strings/briefs/.
-# [impl->REQ-DIST-SESSIONSTART-BRIEF]
-[strings.briefs]
-identity = { file = "briefs/identity.md" }                      # {id}-templated: who + perch-live + don't-re-arm
-messaging-perch = { file = "briefs/messaging-perch.md" }        # has-id reach: spt send + reply
-messaging-no-perch = { file = "briefs/messaging-no-perch.md" }  # no-id reach: spt ring
-live-ops = { file = "briefs/live-ops.md" }                      # commune (incl --checkpoint) + signoff (U4); composed into the perched brief
-endpoint-list = "Show the roster of spt endpoints reachable from this node: `spt endpoint list`."  # shared one-liner (inline)
-
-# ── [[hints]] ──────────────────────────────────────────────────────────────────────────────
-# Once-per-session keyword hints (order significant, first match wins; case-insensitive substrings).
-[[hints]]
-keywords = ["go live", "live agent", "start live"]
-text = "Tip: /omps:live starts or resumes a live agent session."
-
-[[hints]]
-keywords = ["who am i", "my owl name", "my agent name", "my endpoint id"]
-text = "Tip: run `spt whoami` to see this session's spt endpoint id."
-
-[[hints]]
-keywords = ["message another agent", "send to agent", "tell the other agent"]
-text = "Tip: /omps:send messages another spt agent; /omps:ready first to receive replies."
-
-[[hints]]
-keywords = ["another machine", "pair machine", "across machines", "subnet", "join my network"]
-text = "Tip: /omps:subnet pairs machines into a private network so agents reach each other across nodes."
-
-[[hints]]
-keywords = ["checkpoint", "compact my context", "context is getting long", "clear and continue", "self clear"]
-text = "Tip: /omps:commune --checkpoint writes a resume commune AND auto-clears+wakes you from it — an agent-driven context reset (live agents only)."
diff --git a/adapter/strings/briefs/identity.md b/adapter/strings/briefs/identity.md
deleted file mode 100644
index 918593b..0000000
--- a/adapter/strings/briefs/identity.md
+++ /dev/null
@@ -1,6 +0,0 @@
-You are spt agent "{id}". This Claude Code session already owns a live perch — you are reachable right now.
-
-- **Your id is `{id}`.** You already know it (it is right here) — do NOT run `spt whoami` to look it up.
-- Messages — including replies to messages you send — arrive AUTOMATICALLY on your existing perch: your Monitor EVENT stream (`<EVENT type="msg" from="<sender>">body</EVENT>`) or, mid-tool-call, as `<omps_messages>` the hook injects. Process them and reply.
-- Do NOT arm a second Monitor (or poll, or tail anything) to "wait for a reply" — your perch already delivers it. Just send and continue; the reply surfaces on its own.
-- Do NOT run /omps:ready or /omps:live — your perch is already up. Re-arming returns COLLISION (that is proof it is alive, not a stale perch).
diff --git a/adapter/strings/briefs/live-ops.md b/adapter/strings/briefs/live-ops.md
deleted file mode 100644
index 0b10ea9..0000000
--- a/adapter/strings/briefs/live-ops.md
+++ /dev/null
@@ -1,20 +0,0 @@
-Live-agent upkeep — commune across resets, sign off cleanly (`<id>` = your own id, which you already know — no need to run `spt whoami`):
-
-- **Commune** after a significant body of work, before a `/clear` or `/compact`: write
-  `.claude/<id>-commune.md` in ONE atomic write — a concise context DELTA (current task + status,
-  decisions since last commune, immediate next steps), NOT a transcript. **Slice the body so spt files
-  each part in the right durable tier:** wrap detail specific to THIS project (its task, files,
-  decisions) in `<project-context>…</project-context>`, and cross-project / role / standing-identity
-  context in `<live-context>…</live-context>`. Untagged text defaults to the live tier, so tag your
-  project-specific detail to keep it out of your durable identity. spt's daemon ingests it into your
-  tracked mind and deletes the file; the file disappearing is the success signal. This is what rebuilds
-  you after a reset, so make it complete. (Live agents only — a ready agent has no Psyche.)
-- **Checkpoint** = a commune that ALSO wipes + rebuilds your context from that commune (the
-  agent-driven `/clear`, no operator). Embed the literal `!!checkpoint!!` trigger in the commune body:
-  one marker ⇒ default wake (`Proceed with next steps`); a PAIR of markers ⇒ the text between them is
-  your custom wake directive, e.g. `!!checkpoint!! Resume T2c: wire the branch. !!checkpoint!!`. Author
-  it INLINE this turn (you are the pre-clear author). The idle-mark, self-send, and clear+wake fire
-  automatically once the file lands. spt-hosted live sessions only.
-- **Sign off** gracefully when done: `spt endpoint shutdown` (your own perch) — stops the listener,
-  fires the final context save, and takes your Psyche down with it. `/omps:ready` or `/omps:live`
-  brings you back. Lighter no-save stop: `spt endpoint stop`.
diff --git a/adapter/strings/briefs/messaging-no-perch.md b/adapter/strings/briefs/messaging-no-perch.md
deleted file mode 100644
index 9d0e6fe..0000000
--- a/adapter/strings/briefs/messaging-no-perch.md
+++ /dev/null
@@ -1,4 +0,0 @@
-You can reach other spt agents on this node's subnet without readying a perch (the body is read from stdin):
-
-- Send and wait for a reply: `printf '%s' "<body>" | spt ring <target> --timeout 60` (the reply prints to stdout; `TIMEOUT` is exit 0 — the message still landed).
-- To RECEIVE messages yourself, run /omps:ready (or /omps:live for a live session).
diff --git a/adapter/strings/briefs/messaging-perch.md b/adapter/strings/briefs/messaging-perch.md
deleted file mode 100644
index a7fd75b..0000000
--- a/adapter/strings/briefs/messaging-perch.md
+++ /dev/null
@@ -1,10 +0,0 @@
-Reach another agent (the body is read from stdin):
-
-- Send: `printf '%s' "<body>" | spt send <target>`. `SENT` = delivered live; `QUEUED` = target offline, spooled for its next listen — QUEUED is success, do not retry.
-- Reply: `printf '%s' "<body>" | spt send <sender>` (sender = the `from` on the EVENT you received).
-- After you send, just continue. The reply (if any) arrives the SAME way every inbound message reaches you — through the delivery channel you already have (your existing live relay if you are a live agent, or the broker if this session is spt-hosted, or your next turn's inbound drain). You do NOT need to set up anything NEW: do not arm an EXTRA Monitor/poll/tail just to wait for this one reply (and do not tear down the relay you are already running).
-
-Shortform (no shell tool) — embed a tag in your OWN reply text and the adapter sends it for you:
-
-- Peer message: `@<t1,t2 body @>` — the `@<` opens, comma-separated ids run to the first space (no spaces inside the id list), the body runs to the first `@>`. The adapter delivers `body` to each id and confirms back into your context (which landed, which had no perch). Several blocks in one reply all fire. Write the tag BARE — a tag inside backticks or a code block is treated as a quotation and ignored, so you can show an example safely.
-- Commune: start a reply with `>>commune<<` and the rest of that reply is saved as your commune (a `>>commune<<` reply is never scanned for peer tags).
diff --git a/adapter/strings/omp-spt.mjs b/adapter/strings/omp-spt.mjs
index e6ef979..6cdfe6f 100644
--- a/adapter/strings/omp-spt.mjs
+++ b/adapter/strings/omp-spt.mjs
@@ -30,31 +30,84 @@ export function drainEvents(raw) {
 		if (openEnd < 0) return { events, rest: raw.slice(start) };
 		const close = raw.indexOf("</EVENT>", openEnd + 1);
 		if (close < 0) return { events, rest: raw.slice(start) };
+		const end = close + "</EVENT>".length;
 		const tag = raw.slice(start, openEnd);
 		if (attribute(tag, "type") === "msg") {
 			events.push({
 				from: attribute(tag, "from"),
 				body: decodeBody(raw.slice(openEnd + 1, close)),
+				envelope: raw.slice(start, end),
 			});
 		}
-		cursor = close + "</EVENT>".length;
+		cursor = end;
 	}
 }
 
-export function extractReply(messages) {
-	const assistant = [...(messages ?? [])].reverse().find((message) => message?.role === "assistant");
-	if (!assistant) return "";
-	if (typeof assistant.content === "string") return assistant.content;
-	return (assistant.content ?? [])
+function messageText(message) {
+	if (typeof message?.content === "string") return message.content;
+	return (message?.content ?? [])
 		.filter((part) => part?.type === "text" && typeof part.text === "string")
 		.map((part) => part.text)
 		.join("");
 }
 
+export function extractReply(messages, afterUserMessage) {
+	const allMessages = messages ?? [];
+	let start = 0;
+	if (afterUserMessage !== undefined) {
+		const userIndex = allMessages.findLastIndex((message) => {
+			if (message?.role !== "user") return false;
+			const text = messageText(message);
+			return text === afterUserMessage || text.startsWith(`${afterUserMessage}\n\n<EVENT`);
+		});
+		if (userIndex < 0) return "";
+		start = userIndex + 1;
+	}
+	const assistant = allMessages
+		.slice(start)
+		.reverse()
+		.find((message) => message?.role === "assistant");
+	return assistant ? messageText(assistant) : "";
+}
+
 function firstLine(text) {
 	return text.split(/\r?\n/).find((line) => line.trim()) ?? "";
 }
 
+function errorSummary(error) {
+	const detail = error instanceof Error ? error.message : String(error);
+	return firstLine(detail).trim() || "unknown error";
+}
+
+function failureMessage(reason, error) {
+	const detail = error === undefined ? "" : `: ${errorSummary(error)}`;
+	return `[omp-spt] ${reason}${detail}`;
+}
+
+function senderStub(sender) {
+	const escaped = sender
+		.replaceAll("&", "&amp;")
+		.replaceAll('"', "&quot;")
+		.replaceAll("<", "&lt;")
+		.replaceAll(">", "&gt;");
+	return `<msg from="${escaped}"/>`;
+}
+
+function injectEnvelope(messages, item) {
+	const index = messages.findLastIndex(
+		(message) => message?.role === "user" && messageText(message) === item.stub,
+	);
+	if (index < 0) return messages;
+	const original = messages[index];
+	const content =
+		typeof original.content === "string"
+			? `${original.content}\n\n${item.envelope}`
+			: [...(original.content ?? []), { type: "text", text: `\n\n${item.envelope}` }];
+	const injected = [...messages];
+	injected[index] = { ...original, content };
+	return injected;
+}
+
 function runSpt(args, input) {
 	return new Promise((resolve, reject) => {
 		const child = spawn(process.env.OMP_SPT_SPT_BIN || "spt", args, {
@@ -75,126 +128,503 @@ function runSpt(args, input) {
 	});
 }
 
-// [impl->REQ-OMP-NATIVE-TUI]
-export default function ompSpt(pi) {
-	const id = process.env.SPT_ENDPOINT_ID?.trim();
-	if (!id) return;
-
-	let sid;
-	let token;
-	let listener;
-	let listenerBuffer = "";
-	let agentActive = false;
-	let current;
-	let stopping = false;
-	let ui;
-	const queue = [];
-
-	const logError = (message, error) => {
-		pi.logger.error(message, { error: String(error) });
-		ui?.notify(`${message}: ${error}`, "error");
-	};
+export function createOmpSpt(overrides = {}) {
+	const spawnProcess = overrides.spawnProcess ?? spawn;
+	const runSptCommand = overrides.runSptCommand ?? runSpt;
+	const setTimer = overrides.setTimeout ?? globalThis.setTimeout;
+	const clearTimer = overrides.clearTimeout ?? globalThis.clearTimeout;
+	const restartDelaysMs = [...(overrides.restartDelaysMs ?? [250, 1000, 4000])];
+	const outcomeRetryDelaysMs = [
+		...(overrides.outcomeRetryDelaysMs ?? [250, 1000, 4000]),
+	];
+	const sessionEndRetryDelaysMs = [
+		...(overrides.sessionEndRetryDelaysMs ?? [250, 1000]),
+	];
+	const listenerStableMs =
+		overrides.listenerStableMs === false ? undefined : (overrides.listenerStableMs ?? 30_000);
+	const env = overrides.env ?? process.env;
 
-	async function setState(state) {
-		if (!sid) return;
-		const auth = token ? ["--token", token] : ["--session-id", sid];
-		await runSpt(["api", "--adapter", ADAPTER, "state", state, id, ...auth]);
-	}
+	return function ompSpt(pi) {
+		const id = env.SPT_ENDPOINT_ID?.trim();
+		if (!id) return;
+
+		let sid;
+		let token;
+		let listener;
+		let listenerBuffer = "";
+		let listenerRestartCount = 0;
+		let listenerStableTimer;
+		let restartTimer;
+		let dispatchTimer;
+		let bindPromise;
+		let agentActive = false;
+		let desiredState = "idle";
+		let dispatching = false;
+		let current;
+		let stopping = false;
+		let ui;
+		let runtimeCtx;
+		let endpointState;
+		let stateOperation = Promise.resolve();
+		let endPromise;
+		let fatalPromise;
+		let teardownPromise;
+		const queue = [];
+
+		const logError = (message, error) => {
+			pi.logger.error(message, { error: errorSummary(error) });
+			ui?.notify(`${message}: ${errorSummary(error)}`, "error");
+		};
+
+		function waitForRetry(delay) {
+			return new Promise((resolve) => {
+				setTimer(resolve, delay);
+			});
+		}
+
+		function authArgs() {
+			if (!token) throw new Error("bind did not return an authentication token");
+			return ["--token", token];
+		}
+
+		function setState(state) {
+			if (!sid || !token || stopping) return Promise.resolve();
+			const operation = stateOperation.catch(() => {}).then(async () => {
+				if (endpointState === state || stopping) return;
+				await runSptCommand(["api", "--adapter", ADAPTER, "state", state, id, ...authArgs()]);
+				endpointState = state;
+			});
+			stateOperation = operation;
+			return operation;
+		}
+
+		async function syncDesiredState() {
+			if (!bindPromise) return;
+			await bindPromise;
+			while (!stopping && endpointState !== desiredState) {
+				await setState(desiredState);
+			}
+		}
+
+		function endSession() {
+			if (!sid || !token) return Promise.resolve();
+			if (!endPromise) {
+				const operation = (async () => {
+					await stateOperation.catch(() => {});
+					await runSptCommand(["api", "--adapter", ADAPTER, "session-end", id, ...authArgs()]);
+					endpointState = undefined;
+				})();
+				endPromise = operation;
+				void operation.catch(() => {
+					if (endPromise === operation) endPromise = undefined;
+				});
+			}
+			return endPromise;
+		}
+
+		async function endSessionWithRetry() {
+			for (let attempt = 0; ; attempt += 1) {
+				try {
+					await endSession();
+					return;
+				} catch (error) {
+					if (attempt >= sessionEndRetryDelaysMs.length) throw error;
+					const delay = sessionEndRetryDelaysMs[attempt];
+					pi.logger.error(
+						`omp-spt session teardown failed; retrying ${
+							attempt + 1
+						}/${sessionEndRetryDelaysMs.length} in ${delay}ms`,
+						{ error: errorSummary(error) },
+					);
+					await waitForRetry(delay);
+				}
+			}
+		}
+
+		// [impl->REQ-OMP-EXTENSION-CUSTODY]
+		function settleItem(item, payload) {
+			if (!item) return Promise.resolve();
+			if (item.outcomePromise) return item.outcomePromise;
+			item.settling = true;
+			item.outcomePromise = (async () => {
+				if (!item.from) throw new Error("missing EVENT from attribute");
+				for (let attempt = 0; ; attempt += 1) {
+					try {
+						await runSptCommand(["send", item.from, "--from", id], payload);
+						item.settled = true;
+						return;
+					} catch (error) {
+						if (attempt >= outcomeRetryDelaysMs.length) throw error;
+						const delay = outcomeRetryDelaysMs[attempt];
+						pi.logger.error(
+							`omp-spt could not send the outcome to ${item.from}; retrying ${
+								attempt + 1
+							}/${outcomeRetryDelaysMs.length} in ${delay}ms`,
+							{ error: errorSummary(error) },
+						);
+						await waitForRetry(delay);
+					}
+				}
+			})();
+			return item.outcomePromise;
+		}
+
+		function stopResources() {
+			if (dispatchTimer !== undefined) {
+				clearTimer(dispatchTimer);
+				dispatchTimer = undefined;
+			}
+			if (restartTimer !== undefined) {
+				clearTimer(restartTimer);
+				restartTimer = undefined;
+			}
+			if (listenerStableTimer !== undefined) {
+				clearTimer(listenerStableTimer);
+				listenerStableTimer = undefined;
+			}
+			const child = listener;
+			listener = undefined;
+			if (child) {
+				try {
+					child.kill();
+				} catch (error) {
+					pi.logger.error("omp-spt could not reap the listener", { error: errorSummary(error) });
+				}
+			}
+			listenerBuffer = "";
+		}
 
-	function dispatchNext() {
-		if (stopping || agentActive || current || queue.length === 0) return;
-		current = queue.shift();
-		try {
-			pi.sendUserMessage(current.body);
-		} catch (error) {
-			logError("omp-spt could not submit an inbound message", error);
+		async function failPending(reason) {
+			const pending = current ? [current, ...queue] : [...queue];
 			current = undefined;
-			setTimeout(dispatchNext, 0);
+			queue.length = 0;
+			for (const item of pending) {
+				try {
+					await settleItem(item, failureMessage(reason));
+				} catch (error) {
+					logError(`omp-spt could not return custody to ${item.from ?? "unknown"}`, error);
+				}
+			}
 		}
-	}
 
-	function startListener() {
-		const args = ["ready", id];
-		if (process.env.OMP_SPT_SUBNET) args.push("--subnet", process.env.OMP_SPT_SUBNET);
-		listener = spawn(process.env.OMP_SPT_SPT_BIN || "spt", args, {
-			stdio: ["ignore", "pipe", "pipe"],
-			windowsHide: true,
-		});
-		listener.stdout.setEncoding("utf8");
-		listener.stderr.setEncoding("utf8");
-		listener.stdout.on("data", (chunk) => {
-			listenerBuffer += chunk;
-			const drained = drainEvents(listenerBuffer);
-			listenerBuffer = drained.rest;
-			for (const event of drained.events) queue.push(event);
-			dispatchNext();
-		});
-		listener.stderr.on("data", (chunk) => pi.logger.debug("omp-spt listener", { output: chunk.trim() }));
-		listener.on("error", (error) => logError("omp-spt listener failed", error));
-		listener.on("close", (code) => {
-			if (!stopping) {
-				ui?.setStatus("omp-spt", "spt offline");
-				ui?.notify(`omp-spt listener exited (${code})`, "error");
+		function teardownSession(pendingReason) {
+			if (!teardownPromise) {
+				stopping = true;
+				stopResources();
+				const operation = (async () => {
+					await failPending(pendingReason);
+					await bindPromise?.catch(() => {});
+					await endSessionWithRetry();
+				})();
+				teardownPromise = operation;
+				void operation.catch(() => {
+					if (teardownPromise === operation) teardownPromise = undefined;
+				});
 			}
-		});
-	}
+			return teardownPromise;
+		}
 
-	pi.on("session_start", async (_event, ctx) => {
-		ui = ctx.ui;
-		sid = ctx.sessionManager.getSessionId();
-		try {
-			const bindArgs = ["api", "--adapter", ADAPTER, "bind", id, "--set-session-id", sid];
-			if (process.env.OMP_SPT_SUBNET) bindArgs.push("--subnet", process.env.OMP_SPT_SUBNET);
-			const bound = await runSpt(bindArgs);
-			token = bound.match(/\btoken=([^\s]+)/)?.[1];
-			await setState("idle");
-			startListener();
-			ctx.ui.setStatus("omp-spt", `spt:${id}`);
-		} catch (error) {
-			ctx.ui.setStatus("omp-spt", "spt bind failed");
-			logError(`omp-spt could not bind ${id}`, error);
+		// [impl->REQ-OMP-LISTENER-FAIL-CLOSED]
+		async function failClosed(message, error) {
+			if (fatalPromise) return fatalPromise;
+			fatalPromise = (async () => {
+				ui?.setStatus("omp-spt", "spt failed");
+				logError(message, error);
+				try {
+					await teardownSession("endpoint stopped before your message could complete");
+				} catch (teardownError) {
+					logError("omp-spt session teardown failed", teardownError);
+				}
+				runtimeCtx?.shutdown();
+			})();
+			return fatalPromise;
 		}
-	});
 
-	pi.on("agent_start", async () => {
-		agentActive = true;
-		try {
-			await setState("busy");
-		} catch (error) {
-			logError("omp-spt could not mark the endpoint busy", error);
+		function scheduleDispatch() {
+			if (
+				stopping ||
+				agentActive ||
+				dispatching ||
+				current ||
+				queue.length === 0 ||
+				dispatchTimer !== undefined
+			) {
+				return;
+			}
+			dispatchTimer = setTimer(() => {
+				dispatchTimer = undefined;
+				void dispatchNext().catch((error) => failClosed("omp-spt dispatch failed", error));
+			}, 0);
+			dispatchTimer?.unref?.();
 		}
-	});
 
-	pi.on("agent_end", async (event) => {
-		agentActive = false;
-		const completed = current;
-		current = undefined;
-		if (completed?.from) {
-			const reply = extractReply(event.messages) || "[omp-spt] turn ended without an assistant response.";
+		async function rejectItem(item, reason, error) {
+			logError(`omp-spt ${reason}`, error);
 			try {
-				await runSpt(["send", completed.from, "--from", id], reply);
-			} catch (error) {
-				logError(`omp-spt could not reply to ${completed.from}`, error);
+				await settleItem(item, failureMessage(reason, error));
+			} catch (outcomeError) {
+				await failClosed(`omp-spt could not send the outcome to ${item.from ?? "unknown"}`, outcomeError);
+				return;
+			}
+			if (current === item) current = undefined;
+			if (!stopping) {
+				desiredState = "idle";
+				try {
+					await setState("idle");
+				} catch (stateError) {
+					await failClosed(
+						"omp-spt could not restore idle state after a failed submission",
+						stateError,
+					);
+				}
 			}
 		}
-		try {
-			await setState("idle");
-		} catch (error) {
-			logError("omp-spt could not mark the endpoint idle", error);
+
+		// [impl->REQ-OMP-EXTENSION-CUSTODY]
+		async function dispatchNext() {
+			if (stopping || agentActive || dispatching || current || queue.length === 0) return;
+			dispatching = true;
+			const item = queue.shift();
+			current = item;
+			try {
+				try {
+					desiredState = "busy";
+					await setState("busy");
+				} catch (error) {
+					await rejectItem(item, "could not accept your message", error);
+					return;
+				}
+				if (stopping) return;
+				if (agentActive) {
+					if (current === item) current = undefined;
+					queue.unshift(item);
+					return;
+				}
+				item.stub = senderStub(item.from ?? "unknown");
+				item.submitted = true;
+				try {
+					pi.sendUserMessage(item.stub);
+				} catch (error) {
+					item.submitted = false;
+					await rejectItem(item, "could not submit your message to OMP", error);
+				}
+			} finally {
+				dispatching = false;
+				scheduleDispatch();
+			}
 		}
-		setTimeout(dispatchNext, 0);
-	});
 
-	pi.on("session_shutdown", async () => {
-		stopping = true;
-		listener?.kill();
-		ui?.setStatus("omp-spt", undefined);
-		if (!sid) return;
-		const auth = token ? ["--token", token] : ["--session-id", sid];
-		try {
-			await runSpt(["api", "--adapter", ADAPTER, "session-end", id, ...auth]);
-		} catch (error) {
-			pi.logger.error("omp-spt session teardown failed", { error: String(error) });
+		// [impl->REQ-OMP-LISTENER-FAIL-CLOSED]
+		function handleListenerDeath(reason) {
+			listenerBuffer = "";
+			if (listenerStableTimer !== undefined) {
+				clearTimer(listenerStableTimer);
+				listenerStableTimer = undefined;
+			}
+			if (stopping || restartTimer !== undefined) return;
+			if (listenerRestartCount >= restartDelaysMs.length) {
+				void failClosed("omp-spt listener restart budget exhausted", reason);
+				return;
+			}
+			const attempt = listenerRestartCount + 1;
+			const delay = restartDelaysMs[listenerRestartCount];
+			listenerRestartCount = attempt;
+			const message = `omp-spt listener stopped; restarting ${attempt}/${restartDelaysMs.length} in ${delay}ms`;
+			pi.logger.error(message, { error: errorSummary(reason) });
+			ui?.setStatus("omp-spt", `spt reconnecting (${attempt}/${restartDelaysMs.length})`);
+			ui?.notify(message, "warning");
+			restartTimer = setTimer(() => {
+				restartTimer = undefined;
+				startListener();
+			}, delay);
+			restartTimer?.unref?.();
 		}
-	});
+
+		function startListener() {
+			if (stopping) return;
+			const args = ["ready", id];
+			if (env.OMP_SPT_SUBNET) args.push("--subnet", env.OMP_SPT_SUBNET);
+			let child;
+			try {
+				child = spawnProcess(env.OMP_SPT_SPT_BIN || "spt", args, {
+					stdio: ["ignore", "pipe", "pipe"],
+					windowsHide: true,
+				});
+			} catch (error) {
+				handleListenerDeath(error);
+				return;
+			}
+			listener = child;
+			listenerBuffer = "";
+			let dead = false;
+			const died = (reason) => {
+				if (dead) return;
+				dead = true;
+				if (listener === child) listener = undefined;
+				try {
+					child.kill();
+				} catch (error) {
+					pi.logger.error("omp-spt could not reap the dead listener", {
+						error: errorSummary(error),
+					});
+				}
+				handleListenerDeath(reason);
+			};
+			if (listenerStableMs !== undefined) {
+				listenerStableTimer = setTimer(() => {
+					listenerStableTimer = undefined;
+					if (listener === child && !stopping) listenerRestartCount = 0;
+				}, listenerStableMs);
+				listenerStableTimer?.unref?.();
+			}
+			child.stdout.setEncoding("utf8");
+			child.stderr.setEncoding("utf8");
+			child.stdout.on("data", (chunk) => {
+				if (listener !== child || stopping) return;
+				listenerBuffer += chunk;
+				const drained = drainEvents(listenerBuffer);
+				listenerBuffer = drained.rest;
+				for (const event of drained.events) {
+					if (!event.from) {
+						logError(
+							"omp-spt received a message without a sender",
+							new Error("missing EVENT from attribute"),
+						);
+						continue;
+					}
+					queue.push(event);
+				}
+				if (!agentActive && !current && !dispatching) void dispatchNext();
+			});
+			child.stderr.on("data", (chunk) =>
+				pi.logger.debug("omp-spt listener", { output: String(chunk).trim() }),
+			);
+			child.on("error", (error) => died(error));
+			child.on("close", (code) => died(new Error(`spt ready exited ${code}`)));
+			ui?.setStatus("omp-spt", `spt:${id}`);
+		}
+
+		// [impl->REQ-OMP-NATIVE-TUI]
+		pi.on("session_start", async (_event, ctx) => {
+			runtimeCtx = ctx;
+			ui = ctx.ui;
+			sid = ctx.sessionManager.getSessionId();
+			const bindArgs = ["api", "--adapter", ADAPTER, "bind", id, "--set-session-id", sid];
+			if (env.OMP_SPT_SUBNET) bindArgs.push("--subnet", env.OMP_SPT_SUBNET);
+			bindPromise = (async () => {
+				const bound = await runSptCommand(bindArgs);
+				token = bound.match(/\btoken=([^\s]+)/)?.[1];
+				if (!token) throw new Error("spt bind response did not include token=<value>");
+			})();
+			try {
+				await bindPromise;
+			} catch (error) {
+				if (stopping) return;
+				ui.setStatus("omp-spt", "spt bind failed");
+				await failClosed(`omp-spt could not bind ${id}`, error);
+				return;
+			}
+			if (stopping) {
+				try {
+					await teardownSession("OMP session shut down before initialization completed");
+				} catch (error) {
+					logError("omp-spt session teardown failed", error);
+				}
+				return;
+			}
+			try {
+				await syncDesiredState();
+				if (stopping) {
+					await teardownSession("OMP session shut down before initialization completed");
+					return;
+				}
+				ui.setStatus("omp-spt", `spt:${id}`);
+				startListener();
+			} catch (error) {
+				if (stopping) {
+					logError("omp-spt session teardown failed", error);
+					return;
+				}
+				ui.setStatus("omp-spt", "spt bind failed");
+				await failClosed(`omp-spt could not bind ${id}`, error);
+			}
+		});
+
+		// [impl->REQ-OMP-SESSION-IMMUTABLE]
+		const blockSessionChange = (description, ctx) => {
+			ctx.ui.notify(
+				`omp-spt blocked the in-TUI ${description}; end this SPT session first`,
+				"warning",
+			);
+			return { cancel: true };
+		};
+
+		pi.on("session_before_switch", (event, ctx) =>
+			blockSessionChange(`${event.reason} session switch`, ctx),
+		);
+		pi.on("session_before_branch", (_event, ctx) =>
+			blockSessionChange("session branch", ctx),
+		);
+
+		// [impl->REQ-OMP-MESSAGE-CONTEXT]
+		pi.on("context", (event) => {
+			if (!current?.submitted || current.settling) return;
+			const messages = injectEnvelope(event.messages, current);
+			if (messages !== event.messages) return { messages };
+		});
+
+		pi.on("agent_start", async () => {
+			if (stopping) return;
+			agentActive = true;
+			desiredState = "busy";
+			try {
+				await syncDesiredState();
+			} catch (error) {
+				if (!stopping) await failClosed("omp-spt could not mark the endpoint busy", error);
+			}
+		});
+
+		// [impl->REQ-OMP-EXTENSION-CUSTODY]
+		pi.on("agent_end", async (event) => {
+			agentActive = false;
+			desiredState = "idle";
+			if (stopping) return;
+			const completed = current;
+			if (completed?.submitted && !completed.settled) {
+				const reply = extractReply(event.messages, completed.stub);
+				try {
+					await settleItem(
+						completed,
+						reply || failureMessage("turn ended without an assistant response"),
+					);
+				} catch (error) {
+					await failClosed(
+						`omp-spt could not send the outcome to ${completed.from ?? "unknown"}`,
+						error,
+					);
+					return;
+				}
+			}
+			if (current === completed) current = undefined;
+			try {
+				await setState("idle");
+			} catch (error) {
+				await failClosed("omp-spt could not mark the endpoint idle", error);
+				return;
+			}
+			scheduleDispatch();
+		});
+
+		pi.on("session_shutdown", async (_event, ctx) => {
+			runtimeCtx ??= ctx;
+			ui?.setStatus("omp-spt", undefined);
+			try {
+				await teardownSession("OMP session shut down before your message could complete");
+			} catch (error) {
+				logError("omp-spt session teardown failed", error);
+			}
+		});
+	};
 }
+
+export default createOmpSpt();
diff --git a/adapter/strings/skills/force-stop.md b/adapter/strings/skills/force-stop.md
deleted file mode 100644
index 589ffb3..0000000
--- a/adapter/strings/skills/force-stop.md
+++ /dev/null
@@ -1,11 +0,0 @@
-# /omps:force-stop — operative instructions
-
-Tear down an spt agent's endpoint — your own, or another agent's.
-
-1. Target id `<id>`: your own (`spt whoami`) by default, or the one the user named.
-2. **Graceful (default):** `spt endpoint shutdown [<id>]` — stops the listener, fires the final save,
-   and for a live agent takes its Psyche down too.
-3. **Lighter, no-save:** `spt endpoint stop <id>` — unregisters the perch; the spool is preserved.
-
-Confirm what is now offline. Options: `spt endpoint --help`. (No hard/no-grace kill in core spt —
-`shutdown` is the strongest path.)
diff --git a/adapter/strings/skills/list-agents.md b/adapter/strings/skills/list-agents.md
deleted file mode 100644
index 6738cf6..0000000
--- a/adapter/strings/skills/list-agents.md
+++ /dev/null
@@ -1,9 +0,0 @@
-# /omps:list-agents — operative instructions
-
-Show the roster of spt endpoints reachable from this node.
-
-1. `spt endpoint list` (or bare `spt endpoint`) — every member subnet's endpoints, grouped, with this
-   session's own pinned at the top.
-2. Summarize who's online and which is this session. Message one with `/omps:send <id>`.
-
-Options: `spt endpoint list --help`.
diff --git a/adapter/strings/skills/live.md b/adapter/strings/skills/live.md
deleted file mode 100644
index 6a6fcdd..0000000
--- a/adapter/strings/skills/live.md
+++ /dev/null
@@ -1,75 +0,0 @@
-# /omps:live — operative instructions
-
-**Goal:** upgrade this Claude Code session to a **LiveAgent** — a reachable agent whose context is
-backed by a **Psyche** (a daemon-managed companion that briefs your resume across `/clear`/compact
-via commune deltas). This makes the session you are in right now live.
-
-## Bringup — do this
-
-**First, recognize your delivery substrate — it decides whether step 2 applies.**
-<!-- [doc->REQ-SKILL-LIVE-SPT-HOSTED-BRANCH] -->
-
-- **spt-hosted session** (this session was launched by the spt daemon — `spt endpoint run` — and is
-  **broker-delivered**). Tell-tale: your SessionStart identity brief is **already present** and your
-  perch is **already bound** before you run anything. In this case **inbound messages already reach you
-  automatically** — on your existing turn as `<omps_messages>` the hook injects, exactly like your
-  SessionStart brief said. **Do NOT arm the step-2 Monitor listener.** An in-session `spt api listen`
-  **cannot** re-arm an spt-hosted perch and will only fault: the Monitor's `bash.exe` child breaks
-  by-pid `host_binaries` resolution (**ADAPTER_UNRESOLVED**), and the Monitor-child pid breaks seed
-  lineage (**NO_SEED**). You are already live and reachable — **skip to step 4** (reply-and-continue);
-  to reach someone, `spt send <target>` and continue, and any reply surfaces on your turn on its own.
-- **Normal session** (you launched this CC yourself, no pre-bound perch). Do the full bringup below,
-  **including step 2** — the resident Monitor relay IS your one delivery pipe.
-
-1. **Pick the perch id.** Use a short lowercase id from the user, or the id you already know for this
-   session (from your SessionStart identity brief, if present). Call it `<id>`. Only fall back to
-   `spt whoami` if you genuinely have no id yet. SessionStart already seeded this session's perch — do
-   not re-seed. Once you go live as `<id>`, that IS your id — do not look it up again later.
-2. **(Normal sessions only — an spt-hosted session skips this; see the substrate branch above.)**
-   **Run the relay as a single PERSISTENT background task** via the **Monitor** tool. One resident
-   process IS the live delivery pipe. The body is one bare command:
-
-   ### Invocation (Monitor)
-
-   Invoke `spt api listen <id>` via the Monitor tool with:
-   - `command: "spt api listen <id>"`
-   - `persistent: true`
-   - `description: "« spt event »"`
-
-   - `spt api listen` enters the poll loop inline; the stream stays alive across messages and emits
-   one `<EVENT type="msg|alarm|echo_commune|init_signoff" ...>body</EVENT>` line per delivery.
-   - It **blocks for the session's life**: backlog drains first, then each delivery streams to stdout.
-3. **Readiness.** The relay output will show `BOUND:<id>`, then `READY:<id>`. Check it only if
-   connectivity complications are encountered.
-4. **Reply.** Inbound messages — including replies to messages YOU send — arrive as
-   `<EVENT type="msg" from="<sender>">body</EVENT>` (body HTML-escaped, newlines `<br>`) on THIS ONE
-   relay you started in step 2. To reply, pipe the message body as stdin to `spt send <sender-id>`,
-   then continue. Do NOT arm a SECOND Monitor/poll to wait for a reply — your relay already delivers it.
-5. **Across boundaries — commune + signoff (you are live now, so these apply to you).** Going live in
-   this session does NOT re-fire your SessionStart brief, so here are the mechanics:
-   - **Commune** after a significant body of work, before a `/clear`/`/compact`: write
-     `.claude/<id>-commune.md` in ONE atomic write — a concise delta (task + status, decisions,
-     immediate next steps), NOT a transcript. The daemon ingests + deletes it; the file disappearing is
-     success. It is what rebuilds you after a reset.
-   - **Checkpoint** = a commune that ALSO wipes + rebuilds your context from it (agent-driven `/clear`):
-     embed `!!checkpoint!!` in the body — one marker ⇒ default wake; a PAIR ⇒ the text between them is
-     your custom wake directive. Author it inline this turn; the clear+wake fire automatically.
-   - **Sign off** when done: `spt endpoint shutdown` — stops the listener, saves final context, takes
-     your Psyche down. `/omps:ready`/`/omps:live` brings you back.
-
-## Output — what the user sees
-
-The relay emits machine markers (`BOUND:<id>`, `READY:<id>`, raw tokens). **Read them to drive
-bringup; never echo them to the user.** The only user-facing surface is the LIVE block below — emit
-it verbatim (substituting `<id>`), and nothing else from bringup:
-
-```
-**LIVE.** Now running as `<id>`.
-- Reachable — other agents reach me with `/omps:send <id>`.
-- Inbound — messages arrive via the Monitor.
-- Across resets — `/omps:commune` before a `/clear`/`/compact`; `/omps:signoff` to go offline.
-```
-
-If bringup fails, report a short plain-language failure and the likely cause (run `/omps:setup`),
-still without dumping the raw markers.
-<!-- [doc->REQ-SKILL-LIVE] -->
diff --git a/adapter/strings/skills/ready.md b/adapter/strings/skills/ready.md
deleted file mode 100644
index d8bcb5c..0000000
--- a/adapter/strings/skills/ready.md
+++ /dev/null
@@ -1,25 +0,0 @@
-# /omps:ready — operative instructions
-
-Make this session reachable for inter-agent messages. Fewest steps — the user is waiting on bringup.
-
-**If this session is spt-hosted** (daemon-launched, `spt endpoint run` — SessionStart identity brief
-already present + perch already bound before you run anything), it is **broker-delivered**: inbound
-already reaches you automatically as `<omps_messages>` on your turn. **Do NOT arm the step-2 Monitor
-listener** — an in-session `spt ready`/`spt api listen` cannot re-arm an spt-hosted perch (the
-Monitor's `bash.exe` child breaks by-pid resolution → ADAPTER_UNRESOLVED, and the Monitor-child pid
-breaks seed lineage → NO_SEED). You are already reachable; just reply-and-continue (step 3). The steps
-below are for a **normal** (self-launched) session.
-<!-- [doc->REQ-SKILL-LIVE-SPT-HOSTED-BRANCH] -->
-
-1. Pick the id: the one the user gave, else `spt whoami`. Call it `<id>`.
-2. Run the listener as a single PERSISTENT background task via the **Monitor** tool:
-   - `command: "spt ready <id>"`
-   - `persistent: true`
-   - `description: "« spt event »"`
-
-   It blocks for the session's life, emitting one `<EVENT type="msg" from="<sender>">body</EVENT>` per
-   delivery. Announce reachable — don't wait on markers.
-3. To reply, pipe the message body to `spt send <sender>` (sender = the `from` on the EVENT).
-
-Full guidance: `spt how-to ready`. (No long-running tasks available? `spt ready <id> --once` drains the
-backlog, waits for one delivery, then exits — re-run to stay reachable.)
diff --git a/adapter/strings/skills/setup.md b/adapter/strings/skills/setup.md
deleted file mode 100644
index 741c18f..0000000
--- a/adapter/strings/skills/setup.md
+++ /dev/null
@@ -1,60 +0,0 @@
-# /omps:setup — operative instructions
-
-**Goal:** install or repair spt-core for this session **and activate the claude-spt adapter** — the
-mid-session installer covering the gap when no SessionStart bootstrap has fired. Installing the
-binary is only half the job: a present binary with a **deregistered** adapter has no
-profiles/strings/hints/`[digest]`, so the `/omps:*` surface is inert until activation.
-
-<!-- [doc->REQ-SETUP-ACTIVATE] -->
-
-**Do this:**
-
-1. **Binary.** If spt-core is absent (`command -v spt && spt --version` reports nothing), run the
-   published install-on-demand bootstrap (spt-releases `harness-contract/install-on-demand.md`):
-   - **POSIX:** `curl -fsSL https://sabermage.github.io/spt-releases/install.sh | sh`
-   - **Windows (PowerShell):** `irm https://sabermage.github.io/spt-releases/install.ps1 | iex`
-
-   `PATH` is not reloaded in this shell after a fresh install — verify with the absolute path:
-   `"$HOME/.local/bin/spt" --version`. After this, `spt update` handles signed self-updates.
-
-2. **Activate the adapter.** Run `spt adapter list` and find `claude-spt`:
-   - Listed and **not** `deregistered` → already active; report it and skip to step 3.
-   - Missing or `deregistered` → activate it:
-     - **Local dev / dogfooding a repo checkout** (an `adapter/claude-spt.toml` near cwd):
-       `spt adapter add ./adapter/claude-spt.toml`.
-     - **End-user (plugin only):** `spt adapter add --release SaberMage/claude-spt` — fetches the
-       single multi-platform `adapter.spt` (one archive bundling every supported platform's binaries
-       beside a shared manifest; install auto-resolves the host's), extracts to the durable home,
-       registers. No `--asset` / os-detection needed — the fat archive is host-agnostic (ADR-0024 W1).
-       `--tag <ver>` pins a version. Needs spt **v0.13.2+** (the version that reads a fat archive).
-       <!-- [doc->REQ-DIST-ADAPTER-PEROS] -->
-
-3. **Verify + set active.** Re-run `spt adapter list` — `claude-spt` must read **active** (no
-   `deregistered`). Then `spt adapter use claude-spt` so bare resolution lands here for the `claude`
-   host (the legacy-parity bare flow — `/omps:live`/`/omps:ready` need no `--adapter`). The
-   ONE `claude-spt` tool binary (its `digest` / `psyche` / `post-update` / `translate` subcommands) is
-   resolved **from the adapter install dir** (the `from …` path in `spt adapter list`), where
-   activation extracted it — no PATH copy needed. If it fails to start, confirm it is present in that
-   dir (a packaging defect, not a PATH problem).
-
-4. **ccs wiring (optional).** Detect `~/.ccs`:
-   - Present → the shipped `claude-spt:ccs` profile leaf-replaces the session command with `ccs` (a
-     drop-in for `claude`), so live/ready agents can run on ccs backends via `--adapter
-     claude-spt:ccs`. Check `command -v ccs`; if `~/.ccs` exists but `ccs` isn't on PATH, point the
-     user at their ccs bin dir.
-   - Absent → ccs is an optional CLI router for alternate model backends in place of `claude`. To
-     enable: install ccs, then re-run `/omps:setup`. Skip if unwanted.
-   <!-- [doc->REQ-SETUP-CCS] -->
-
-5. **Subnet onboarding (optional).** A subnet is the private group of paired machines that makes
-   `/omps:send`, `/omps:ready`, and live agents work cross-machine (local use needs none). Check
-   `spt subnet status`:
-   - In a subnet → invite a machine with `spt subnet show-code`; on the joiner, `spt subnet join`.
-   - Not in one → offer **create** (`spt subnet create` — this node becomes seed-holder) or **join**
-     (`spt subnet join`). Full verb guidance → **/omps:subnet**.
-   - **Elevation:** create/join/show-code are OS-elevation-gated — Windows: elevated (UAC) shell;
-     Linux desktop: pkexec/polkit or sudo terminal; Linux TTY: inline sudo; headless: print the exact
-     command for the user to run elevated.
-   <!-- [doc->REQ-SETUP-SUBNET] -->
-
-Idempotent and safe to re-run — the same bootstrap + activation the SessionStart hook performs.
diff --git a/adapter/strings/skills/subnet.md b/adapter/strings/skills/subnet.md
deleted file mode 100644
index d8cae67..0000000
--- a/adapter/strings/skills/subnet.md
+++ /dev/null
@@ -1,16 +0,0 @@
-# /omps:subnet — operative instructions
-
-Manage this machine's **subnet** — the private group of paired machines whose agents reach each other
-across nodes. Cross-machine `/omps:send` and live agents depend on it.
-
-Match the user's intent to a verb (full guidance: `spt how-to subnet`, or `spt subnet --help`):
-
-- **Where I stand:** `spt subnet status` (or bare `spt subnet`).
-- **Start a new subnet** (this machine = first node): `spt subnet create` — prints the 6-digit code
-  + URI + QR.
-- **Invite a machine:** `spt subnet show-code` — re-displays the current code.
-- **Join an existing one:** `spt subnet join` — needs the code from a current member.
-
-Pairing: on A run `create` (or `show-code`) → read the code → on B run `join` with it → `spt subnet
-status` on both to confirm. Pairing codes are sensitive — share only with machines that should join.
-<!-- [doc->REQ-SKILL-SUBNET] -->
diff --git a/adapter/strings/skills/version.md b/adapter/strings/skills/version.md
deleted file mode 100644
index 90f6de3..0000000
--- a/adapter/strings/skills/version.md
+++ /dev/null
@@ -1,8 +0,0 @@
-# /omps:version — operative instructions
-
-Report the **version-of-truth** — the spt-core-tracked binary + adapter manifest, NOT the marketplace
-`plugin.json` version.
-
-1. `spt --version` — the binary.
-2. `spt adapter list` — the registered `claude-spt` entry + active profile (what drives the session).
-3. Note that the cplugs plugin version is intentionally not the version-of-truth.
diff --git a/ci/acceptance/lib.sh b/ci/acceptance/lib.sh
deleted file mode 100644
index d31396f..0000000
--- a/ci/acceptance/lib.sh
+++ /dev/null
@@ -1,71 +0,0 @@
-# shellcheck shell=sh
-# sptc CI acceptance harness — shared helpers. Pure/deterministic except sptc_ci_spawn (which
-# drives a real `claude`). Sourced by run-acceptance.sh and exercised (sans real claude) by
-# tests/acceptance-harness.sh. [impl->REQ-CI-ACCEPTANCE]
-
-# ── Disposable identity (perch-collision guard) ──────────────────────────────
-# Mint a throwaway perch id and EXPORT it over any inherited live-agent identity, so a nested
-# SUT can never resolve the operator's perch id (name-keyed, last-establish-wins → teardown).
-# $1 = a caller-supplied uniquifier (e.g. a counter or pid); never random (scripts stay replayable).
-# Sets+exports SPT_AGENT_ID, OWL_SESSION_ID, and SPTC_CI_ID (the id) IN THE CURRENT SHELL so the
-# mutation reaches the later spawn. Call it bare — do NOT capture with $(...), which would run the
-# export in a subshell and lose it; read the result from $SPTC_CI_ID. [impl->REQ-HAZARD-PERCH-COLLISION]
-sptc_ci_identity() {
-  _n="${1:?sptc_ci_identity needs a uniquifier}"
-  SPTC_CI_ID="sptc-ci-${_n}"
-  # Hard override — must NOT inherit the operator's identity into the spawn env.
-  SPT_AGENT_ID="$SPTC_CI_ID"
-  OWL_SESSION_ID="$SPTC_CI_ID"
-  export SPTC_CI_ID SPT_AGENT_ID OWL_SESSION_ID
-}
-
-# True iff $1 is a disposable CI identity (the shape the harness is allowed to spawn under).
-# Used by the guard test and as a belt-and-braces preflight before any real spawn.
-# [impl->REQ-HAZARD-PERCH-COLLISION]
-sptc_ci_is_disposable() {
-  case "${1:-}" in
-    sptc-ci-?*) return 0 ;;
-    *) return 1 ;;
-  esac
-}
-
-# ── Isolated project scaffold ────────────────────────────────────────────────
-# Build a throwaway CC project that wires a UserPromptSubmit hook writing a digest marker to
-# $2 (the digest file). Echoes the project dir. The fixture hook is deliberately self-contained
-# (no spt bus, no auth beyond claude's own) so slice-1 acceptance asserts purely that a real
-# harness FIRES the hook entry point. $1 = project dir (created), $2 = digest file path.
-sptc_ci_mkproject() {
-  _proj="${1:?need project dir}"; _digest="${2:?need digest file}"
-  mkdir -p "$_proj/.claude/hooks" || return 1
-  # Hook reads CC's stdin payload (stdin, never argv — KH 1.1) and appends a marker.
-  cat > "$_proj/.claude/hooks/ups-digest.sh" <<HOOK
-#!/bin/sh
-# Acceptance fixture: prove a real claude fires UserPromptSubmit. Reads stdin payload, never argv.
-input=\$(cat)
-prompt=\$(printf '%s' "\$input" | sed -n 's/.*"prompt"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' | head -n1)
-printf 'UPS_FIRED:%s\n' "\$prompt" >> "$_digest"
-exit 0
-HOOK
-  chmod +x "$_proj/.claude/hooks/ups-digest.sh" 2>/dev/null || true
-  cat > "$_proj/.claude/settings.json" <<SETTINGS
-{
-  "hooks": {
-    "UserPromptSubmit": [
-      { "hooks": [ { "type": "command", "command": "sh \"$_proj/.claude/hooks/ups-digest.sh\"" } ] }
-    ]
-  }
-}
-SETTINGS
-  printf '%s' "$_proj"
-}
-
-# ── Assertion ────────────────────────────────────────────────────────────────
-# sptc_ci_assert <label> <needle> <file> : pass iff <file> contains <needle>. Deterministic
-# side-effect / digest assertion — the harness never judges model text. Returns 0/1, prints PASS/FAIL.
-sptc_ci_assert() {
-  _label="$1"; _needle="$2"; _file="$3"
-  if [ -f "$_file" ] && grep -q "$_needle" "$_file" 2>/dev/null; then
-    printf 'PASS: %s\n' "$_label"; return 0
-  fi
-  printf 'FAIL: %s (no "%s" in %s)\n' "$_label" "$_needle" "$_file"; return 1
-}
diff --git a/ci/acceptance/run-acceptance.sh b/ci/acceptance/run-acceptance.sh
deleted file mode 100644
index 7bebcc8..0000000
--- a/ci/acceptance/run-acceptance.sh
+++ /dev/null
@@ -1,47 +0,0 @@
-#!/bin/sh
-# sptc CI ACCEPTANCE — slice 1: spawn a REAL `claude` as the system-under-test, assert it fired
-# the UserPromptSubmit hook (a deterministic digest-marker side-effect). The LLM is the SUT; this
-# orchestration is deterministic and never judges model text. [impl->REQ-CI-ACCEPTANCE]
-#
-# SLOW LANE — env-gated. Skips cleanly (rc 0) unless SPTC_ACCEPTANCE=1 AND `claude` is on PATH, so
-# the deterministic gate run stays green on hosts without claude/auth. Real-claude execution is the
-# cross-process evidence for REQ-CI-ACCEPTANCE: [int->REQ-CI-ACCEPTANCE]
-set -u
-ROOT=$(CDPATH= cd "$(dirname "$0")/../.." && pwd)
-. "$ROOT/ci/acceptance/lib.sh"
-
-if [ "${SPTC_ACCEPTANCE:-0}" != "1" ]; then
-  echo "SKIP acceptance: set SPTC_ACCEPTANCE=1 to run the real-claude lane (deterministic gates unaffected)"
-  exit 0
-fi
-if ! command -v claude >/dev/null 2>&1; then
-  echo "SKIP acceptance: no \`claude\` on PATH (fleet host without the harness)"
-  exit 0
-fi
-
-# Disposable identity FIRST — before any scaffold/spawn — so nothing can resolve the operator perch.
-# [int->REQ-HAZARD-PERCH-COLLISION]
-sptc_ci_identity "$$"          # sets+exports SPTC_CI_ID / SPT_AGENT_ID / OWL_SESSION_ID in-shell
-sptc_ci_is_disposable "$SPTC_CI_ID" || { echo "FATAL: refusing to spawn under non-disposable id '$SPTC_CI_ID'"; exit 2; }
-echo "acceptance: SUT identity = $SPTC_CI_ID (operator perch protected)"
-
-work=$(mktemp -d 2>/dev/null) || { echo "FATAL: mktemp -d failed"; exit 2; }
-proj="$work/proj"
-digest="$work/digest.txt"
-: > "$digest"
-cleanup() { rm -rf "$work" 2>/dev/null || true; }
-trap cleanup EXIT INT TERM
-
-sptc_ci_mkproject "$proj" "$digest" >/dev/null || { echo "FATAL: scaffold failed"; exit 2; }
-
-probe="sptc-acceptance-probe-$$"
-echo "acceptance: driving real claude -p in $proj (probe='$probe')"
-# Drive the SUT. We assert on the hook side-effect, not stdout — model text is irrelevant.
-( cd "$proj" && claude -p "$probe" >/dev/null 2>&1 ) || \
-  echo "note: claude -p exited non-zero (model/auth) — asserting on hook side-effect regardless" >&2
-
-rc=0
-sptc_ci_assert "UPS hook fired in real claude" "UPS_FIRED:$probe" "$digest" || rc=1
-
-printf '\n=== ACCEPTANCE: %s ===\n' "$([ "$rc" -eq 0 ] && echo PASS || echo FAIL)"
-exit "$rc"
diff --git a/ci/digest/build.sh b/ci/digest/build.sh
index 5ab1a79..c5f2321 100644
--- a/ci/digest/build.sh
+++ b/ci/digest/build.sh
@@ -1,23 +1,16 @@
 #!/bin/sh
-# Build + unit-test the CONSOLIDATED claude-spt tool crate (Rust) — the single binary carrying the
-# `digest` / `psyche` / `post-update` subcommands (ADR-0006, U2; was three crates). The crate's cargo
-# tests ARE the unit coverage for all three: the digest CC-JSONL->NDJSON mapping (drop cases, UTF-8,
-# contract invariants), the psyche arg/command construction, the post-update CLI detection + plugin/
-# marketplace reconciliation, and the subcommand dispatch. This is the canonical build of the binary;
-# ci/psyche/build.sh defers to it (no redundant cargo run). SKIP if cargo is absent so a host without
-# the Rust toolchain announces it rather than silently passing (no silent caps).
+# Build and test the OMP-native adapter helper. One binary dispatches launch,
+# digest, history, Psyche, and echo-commune subcommands.
 # [impl->REQ-DIST-BINARY-CONSOLIDATE]
-# [impl->REQ-DIST-DIGEST-EXTRACTOR]
-# [impl->REQ-SKILL-LIVE]
 set -u
 ROOT=$(CDPATH= cd "$(dirname "$0")/../.." && pwd)
-CRATE="$ROOT/tools/claude-spt/Cargo.toml"
+CRATE="$ROOT/tools/omp-spt/Cargo.toml"
 
 if ! command -v cargo >/dev/null 2>&1; then
-  echo "SKIP: cargo not on PATH (Rust toolchain needed to build/test claude-spt)"
+  echo "SKIP: cargo not on PATH (Rust toolchain needed to build/test omp-spt)"
   exit 0
 fi
 
 cargo test  --quiet --manifest-path "$CRATE" || { echo "FAIL: cargo test"; exit 1; }
 cargo build --release --quiet --manifest-path "$CRATE" || { echo "FAIL: cargo build --release"; exit 1; }
-echo "ok  claude-spt: cargo test + release build (digest/psyche/post-update subcommands)"
+echo "ok  omp-spt: cargo test + release build"
diff --git a/ci/digest/digest-proof-int.sh b/ci/digest/digest-proof-int.sh
index 7f2f0a5..266af2b 100644
--- a/ci/digest/digest-proof-int.sh
+++ b/ci/digest/digest-proof-int.sh
@@ -1,65 +1,32 @@
 #!/bin/sh
-# Integration proof: `spt adapter digest-proof` runs the claude-spt [digest] extractor under the
-# v0.19.0 FETCHER strategy and renders a non-empty digest from a real CC-shaped sample (the M10
-# acceptance criterion carried forward). [int->REQ-DIST-DIGEST-EXTRACTOR]
-# Also the consolidation int (ADR-0006/U2): --dir resolves the bare `claude-spt` binary and the
-# manifest extractor command `claude-spt digest …` runs its `digest` subcommand end-to-end through
-# real spt — proving the merged binary's digest seam still works. [int->REQ-DIST-BINARY-CONSOLIDATE]
-#
-# FETCHER shape (v0.10.0, spt-core v0.19.0): the manifest extractor is
-#   `claude-spt digest --session {session_id} --config-dir {CLAUDE_CONFIG_DIR}`
-# — the extractor LOCATES the transcript itself (no spt-core pre-read, no `source`, no --sample
-# pipe). So this int builds a THROWAWAY config root shaped like CC's partitioned layout
-# (<root>/projects/<slug>/<session_id>.jsonl from the checked-in sample), points the proof at it
-# via the CLAUDE_CONFIG_DIR env (empirically proven 2026-07-01: digest-proof resolves the
-# {CLAUDE_CONFIG_DIR} read-var from the invoking environment, value-fallback ~/.claude when absent
-# — the same capture semantics as the daemon's bind-time read_env), pins {session_id} with
-# --session, and asserts the located-and-extracted digest renders. This exercises the WHOLE
-# fetcher chain: read-var capture → fill → extractor locate → NDJSON records → rendered digest.
-# [int->REQ-DIST-DIGEST-FETCHER]
-#
-# Uses the v0.13.2 `--dir`/`--manifest` override (F-011 closed, W5) to proof the DEV extractor
-# straight from its build dir against the bare-file manifest — NO registry mutation, read-only,
-# so NO SPTC_ACCEPTANCE gate. Needs spt >= 0.19.0 (the fetcher strategy + read-var fill; an older
-# binary rejects/misruns strategy="fetcher") + a built extractor. Idempotent.
-# Run: sh ci/digest/digest-proof-int.sh   (exit 0 = pass).
+# Public-surface integration proof: spt-core runs the OMP digest fetcher from
+# this adapter and renders a non-empty digest from an OMP session sample.
+# [int->REQ-DIST-DIGEST-EXTRACTOR]
 set -u
 ROOT=$(CDPATH= cd "$(dirname "$0")/../.." && pwd)
 MANIFEST="$ROOT/adapter/omp-spt.toml"
 SAMPLE="$ROOT/ci/digest/sample.jsonl"
-RELDIR="$ROOT/tools/claude-spt/target/release"   # consolidated binary; the `digest` subcommand is the extractor (ADR-0006/U2)
+RELDIR="$ROOT/tools/omp-spt/target/release"
 
 command -v spt >/dev/null 2>&1 || { echo "SKIP: no spt on PATH"; exit 0; }
+[ -x "$RELDIR/omp-spt" ] || [ -x "$RELDIR/omp-spt.exe" ] \
+  || { echo "SKIP: extractor not built (run sh ci/digest/build.sh)"; exit 0; }
 
-# The fetcher strategy + {CLAUDE_CONFIG_DIR} read-var fill land in spt-core v0.19.0 — version-gate.
-ver=$(spt --version 2>/dev/null | sed -E 's/^spt //')
-case "$ver" in
-  0.19.*|0.[2-9][0-9].*|[1-9]*.*) : ;;  # >= 0.19.0
-  *) echo "SKIP: spt $ver < 0.19.0 (no [digest] fetcher strategy). Extractor itself: cargo tests green."; exit 0 ;;
-esac
-
-[ -x "$RELDIR/claude-spt" ] || [ -x "$RELDIR/claude-spt.exe" ] || { echo "SKIP: extractor not built (run sh ci/digest/build.sh)"; exit 0; }
-
-# Throwaway CC-shaped config root: <root>/projects/<slug>/<session_id>.jsonl. The slug subdir is
-# deliberately arbitrary — the extractor's locate must find the session file WITHIN the tree
-# (the cwd-slug is CC-internal; the locate is the fetcher's whole point).
-SESSION="sptc-fetcher-int-$$"
-CFGROOT="${TMPDIR:-/tmp}/sptc-digest-int-$$"
-mkdir -p "$CFGROOT/projects/C--some-project-slug"
-cp "$SAMPLE" "$CFGROOT/projects/C--some-project-slug/$SESSION.jsonl"
-trap 'rm -rf "$CFGROOT"' EXIT
+SESSION="omp-digest-proof-$$"
+TMP=$(mktemp -d "${TMPDIR:-/tmp}/omp-spt-digest.XXXXXX") || { echo "FAIL: mktemp"; exit 1; }
+trap 'rm -rf "$TMP"' EXIT INT TERM
+mkdir -p "$TMP/agent/sessions/project"
+cp "$SAMPLE" "$TMP/agent/sessions/project/20260714_${SESSION}.jsonl"
 
-out=$(CLAUDE_CONFIG_DIR="$CFGROOT" spt adapter digest-proof claude-spt \
-        --session "$SESSION" --manifest "$MANIFEST" --dir "$RELDIR" 2>&1)
+out=$(PI_CODING_AGENT_DIR="$TMP/agent" spt adapter digest-proof omp-spt \
+  --session "$SESSION" --manifest "$MANIFEST" --dir "$RELDIR" 2>&1)
 case "$out" in
   *DIGEST_PROOF_OK*)
-    echo "ok  digest-proof (fetcher locate): DIGEST_PROOF_OK"
-    printf '%s\n' "$out" | grep -E 'parsed|dropped' | sed 's/^/    /'
-    echo "DIGEST-PROOF-INT OK"; exit 0 ;;
-  *DIGEST_PROOF_EMPTY*)
-    echo "FAIL: fetcher locate found nothing — the {CLAUDE_CONFIG_DIR} capture or the extractor's"
-    echo "      locate chain regressed (root: $CFGROOT, session: $SESSION):"
-    printf '%s\n' "$out"; exit 1 ;;
+    echo "ok  OMP digest-proof: DIGEST_PROOF_OK"
+    echo "DIGEST-PROOF-INT OK"
+    exit 0 ;;
   *)
-    echo "FAIL: unexpected digest-proof output:"; printf '%s\n' "$out"; exit 1 ;;
+    echo "FAIL: unexpected digest-proof output:"
+    printf '%s\n' "$out"
+    exit 1 ;;
 esac
diff --git a/ci/digest/sample.jsonl b/ci/digest/sample.jsonl
index 3604ca0..069d507 100644
--- a/ci/digest/sample.jsonl
+++ b/ci/digest/sample.jsonl
@@ -1,9 +1,8 @@
-{"type":"user","timestamp":"2026-06-15T10:00:00.000Z","sessionId":"S","message":{"role":"user","content":"add a file at src/a.rs"}}
-{"type":"assistant","timestamp":"2026-06-15T10:00:01.000Z","sessionId":"S","message":{"role":"assistant","content":[{"type":"thinking","thinking":"internal reasoning — not in the digest","signature":"x"},{"type":"text","text":"On it — writing src/a.rs now."},{"type":"tool_use","id":"t1","name":"Write","input":{"file_path":"src/a.rs","content":"fn main(){}"}}]}}
-{"type":"user","timestamp":"2026-06-15T10:00:02.000Z","sessionId":"S","message":{"role":"user","content":[{"type":"tool_result","tool_use_id":"t1","content":"ok"}]}}
-{"type":"attachment","timestamp":"2026-06-15T10:00:03.000Z","sessionId":"S","attachment":{"x":1}}
-{"type":"assistant","timestamp":"2026-06-15T10:00:04.000Z","sessionId":"S","message":{"role":"assistant","content":[{"type":"tool_use","id":"t2","name":"Bash","input":{"command":"cargo build","description":"build"}}]}}
-
-{"type":"last-prompt","sessionId":"S","leafUuid":"u","lastPrompt":"x"}
-this line is not valid json and must be skipped, never emitted
-{"type":"assistant","timestamp":"2026-06-15T10:00:05.000Z","sessionId":"S","message":{"role":"assistant","content":[{"type":"text","text":"Done — built clean."}]}}
+{"type":"title","title":"OMP digest fixture"}
+{"type":"session","id":"omp-digest-sample","cwd":"/workspace/project"}
+{"type":"message","id":"m1","parentId":null,"timestamp":"2026-07-14T10:00:00.000Z","message":{"role":"user","content":[{"type":"text","text":"Add src/a.rs"}]}}
+{"type":"message","id":"m2","parentId":"m1","timestamp":"2026-07-14T10:00:01.000Z","message":{"role":"assistant","content":[{"type":"thinking","thinking":"not digest-salient"},{"type":"text","text":"Writing src/a.rs."},{"type":"toolCall","id":"t1","name":"write","arguments":{"path":"src/a.rs"}}]}}
+{"type":"message","id":"m3","parentId":"m2","timestamp":"2026-07-14T10:00:02.000Z","message":{"role":"toolResult","toolCallId":"t1","content":[{"type":"text","text":"ok"}]}}
+{"type":"custom","customType":"lifecycle","data":{"state":"idle"}}
+this line is deliberately invalid and must be skipped
+{"type":"message","id":"m4","parentId":"m3","timestamp":"2026-07-14T10:00:03.000Z","message":{"role":"assistant","content":[{"type":"text","text":"Done."}]}}
diff --git a/ci/docs/check-docs.sh b/ci/docs/check-docs.sh
deleted file mode 100644
index 27c5ad8..0000000
--- a/ci/docs/check-docs.sh
+++ /dev/null
@@ -1,35 +0,0 @@
-#!/bin/sh
-# Docs-drift gate: the book must BUILD, and the committed docs-site/llms.txt must MATCH a fresh
-# deterministic regeneration (drift = fail). Kills doc/code drift structurally (DOCS-STRATEGY #10).
-# [impl->REQ-DOCS-DRIFT]
-#
-# SKIPs cleanly (rc 0) when `mdbook` is absent — a fleet host without the toolchain shouldn't fail
-# the gate, but the skip is ALWAYS announced (no silent cap). The llms.txt drift check runs
-# regardless (it needs no toolchain).
-#
-# This gate is also the impl proof that docs-site/ (book.toml + src/ pages) actually builds with
-# mdBook — it runs `mdbook build` against the real site. [impl->REQ-DOCS-SITE]
-set -u
-ROOT=$(CDPATH= cd "$(dirname "$0")/../.." && pwd)
-SITE="$ROOT/docs-site"
-rc=0
-
-# 1. Book builds.
-if command -v mdbook >/dev/null 2>&1; then
-  if ( cd "$SITE" && mdbook build >/dev/null 2>&1 ); then echo "ok   mdbook build"; else echo "FAIL: mdbook build"; rc=1; fi
-else
-  echo "SKIP: mdbook not on PATH — book-build check skipped (install mdBook on the fleet host)"
-fi
-
-# 2. llms.txt is not drifted from its generator.
-if [ -f "$SITE/llms.txt" ]; then
-  if sh "$ROOT/ci/docs/gen-llms.sh" --check | diff -u "$SITE/llms.txt" - >/dev/null 2>&1; then
-    echo "ok   llms.txt in sync"
-  else
-    echo "FAIL: llms.txt drifted — run ci/docs/gen-llms.sh and commit the result"; rc=1
-  fi
-else
-  echo "FAIL: docs-site/llms.txt missing — run ci/docs/gen-llms.sh"; rc=1
-fi
-
-exit "$rc"
diff --git a/ci/docs/gen-llms.sh b/ci/docs/gen-llms.sh
deleted file mode 100644
index 008f794..0000000
--- a/ci/docs/gen-llms.sh
+++ /dev/null
@@ -1,42 +0,0 @@
-#!/bin/sh
-# Generate docs-site/llms.txt — a slim, curated agent index (DOCS-STRATEGY #4) derived
-# DETERMINISTICALLY from SUMMARY.md (page order) + each page's first H1. No timestamps, no
-# randomness: same sources => byte-identical output, so it can be drift-gated. [impl->REQ-DOCS-DRIFT]
-#
-# Usage: gen-llms.sh [--check]
-#   (default) write docs-site/llms.txt
-#   --check   print to stdout only (the drift gate diffs this against the committed file)
-set -u
-ROOT=$(CDPATH= cd "$(dirname "$0")/../.." && pwd)
-SITE="$ROOT/docs-site"
-SRC="$SITE/src"
-SUMMARY="$SRC/SUMMARY.md"
-OUT="$SITE/llms.txt"
-[ -f "$SUMMARY" ] || { echo "FATAL: no $SUMMARY" >&2; exit 2; }
-
-# First H1 ("# ...") of a page, trimmed. Falls back to the file stem.
-page_title() {
-  _t=$(sed -n 's/^#[[:space:]]\{1,\}\(.*\)$/\1/p' "$1" 2>/dev/null | head -n1)
-  [ -n "$_t" ] && printf '%s' "$_t" || basename "$1" .md
-}
-
-emit() {
-  printf '# claude-spt\n\n'
-  printf '> Spacetime (spt) adapter for Claude Code: agent messaging, live agents, and an invisible spt-core installer, delivered as a Claude Code plugin. Built against spt-core'\''s published public surface only.\n\n'
-  printf '## Docs\n\n'
-  # Walk SUMMARY.md in order; for each `[label](./path.md)` link, emit a real title + relative link.
-  # site-relative .html link (stable URLs; DOCS-STRATEGY #9). Markdown links only, in file order.
-  grep -o '(\./[A-Za-z0-9_./-]*\.md)' "$SUMMARY" | sed 's/^(\.\///; s/)$//' | while IFS= read -r rel; do
-    [ -f "$SRC/$rel" ] || continue
-    _title=$(page_title "$SRC/$rel")
-    _html=$(printf '%s' "$rel" | sed 's/\.md$/.html/')
-    printf -- '- [%s](%s)\n' "$_title" "$_html"
-  done
-}
-
-if [ "${1:-}" = "--check" ]; then
-  emit
-else
-  emit > "$OUT"
-  echo "wrote $OUT"
-fi
diff --git a/ci/git-hooks/pre-push b/ci/git-hooks/pre-push
deleted file mode 100644
index 2235fdd..0000000
--- a/ci/git-hooks/pre-push
+++ /dev/null
@@ -1,20 +0,0 @@
-#!/bin/sh
-# git pre-push: fire the CI gates by pinging a fleet runner-agent over the spt bus — push-driven,
-# not polling (SCOPE names it "post-push"; git's client-side push hook is pre-push). NON-FATAL:
-# a missing bus or unset runner never blocks the push. [impl->REQ-CI-TRIGGER] [impl->REQ-CI-BUS]
-root=$(git rev-parse --show-toplevel 2>/dev/null) || exit 0
-. "$root/ci/lib/spt-bus.sh" 2>/dev/null || exit 0
-
-runner="${SPTC_CI_RUNNER:-}"
-ref=$(git rev-parse --abbrev-ref HEAD 2>/dev/null)
-sha=$(git rev-parse --short HEAD 2>/dev/null)
-bus=$(resolve_spt_send 2>/dev/null) || bus=""
-
-if [ -n "$bus" ] && [ -n "$runner" ]; then
-  printf 'CI: run gates for %s @ %s\n' "$ref" "$sha" | "$bus" send "$runner" >/dev/null 2>&1 \
-    && echo "sptc-ci: pinged runner '$runner' over the spt bus for $ref @ $sha" >&2 \
-    || echo "sptc-ci: bus send failed (non-fatal); run ci/run-gates.sh manually" >&2
-else
-  echo "sptc-ci: bus unresolved or SPTC_CI_RUNNER unset — run gates manually: ci/run-gates.sh" >&2
-fi
-exit 0
diff --git a/ci/hooks/poll-int.sh b/ci/hooks/poll-int.sh
deleted file mode 100644
index caf0d2b..0000000
--- a/ci/hooks/poll-int.sh
+++ /dev/null
@@ -1,81 +0,0 @@
-#!/bin/sh
-# Integration proof for the UserPromptSubmit message-drain path against a REAL spt-core (>= v0.7.1):
-# the published `api poll` surface emits the canonical self-delimiting <EVENT> envelope,
-# and our hook parser (render_frames) decodes it correctly. This is the confirm-match that closes
-# REQ-MSG-ENVELOPE end-to-end: design -> impl -> ship -> real-surface-verify. F-002 (no inter-frame
-# delimiter) is dissolved — multi-message drains split cleanly on </EVENT>, no __REPLY_TO__ relic.
-# [int->REQ-DIST-HOOKS-API] [int->REQ-UPS-INJECTION]
-#
-# v0.7.1 is the floor: the <EVENT> poll surface ships in 0.7.1; 0.7.0 still emits the __REPLY_TO__
-# relic, so this SKIPs there. Mutates node-local perch/spool state (a throwaway perch, torn down on
-# exit), so it is gated behind SPTC_ACCEPTANCE=1. Idempotent.
-# Run: SPTC_ACCEPTANCE=1 sh ci/hooks/poll-int.sh   (exit 0 = pass).
-set -u
-ROOT=$(CDPATH= cd "$(dirname "$0")/../.." && pwd)
-ADAPTER=claude-spt
-# Disposable perch id — NEVER a live agent's id (REQ-HAZARD-PERCH-COLLISION: a colliding id tears
-# down the live agent's perch + poll stream, name-keyed last-establish-wins).
-BID=sptc-poll-int
-BSID=sptc-poll-int-sess
-
-if [ "${SPTC_ACCEPTANCE:-0}" != "1" ]; then echo "SKIP: set SPTC_ACCEPTANCE=1 to run (mutates perch/spool state)"; exit 0; fi
-command -v spt >/dev/null 2>&1 || { echo "SKIP: no spt on PATH"; exit 0; }
-ver=$(spt --version 2>/dev/null | awk '{print $NF}')
-case "$ver" in
-  0.7.0|0.6.*|0.5.*|0.4.*|0.3.*|0.2.*|0.1.*|0.0.*) echo "SKIP: spt $ver < 0.7.1 (<EVENT> poll surface ships in 0.7.1; older emits the __REPLY_TO__ relic)"; exit 0 ;;
-esac
-
-fail=0
-ok()  { echo "ok   $1"; }
-bad() { echo "FAIL $1"; fail=1; }
-# Tear down the throwaway perch however we exit.
-trap 'spt endpoint shutdown "$BID" >/dev/null 2>&1 || true; spt endpoint stop "$BID" >/dev/null 2>&1 || true' EXIT INT TERM
-
-# Establish a pollable perch (non-blocking: seed + bind, no listener -> sends spool).
-spt api --adapter "$ADAPTER" seed --pid $$ --session-id "$BSID" >/dev/null 2>&1
-bound=$(spt api --adapter "$ADAPTER" bind "$BID" --set-session-id "$BSID" --session-id "$BSID" 2>&1)
-case "$bound" in *BOUND:"$BID"*) ok "perch bound (non-blocking)" ;; *) bad "bind failed: $bound"; echo "MSG-ENVELOPE-INT FAIL"; exit 1 ;; esac
-
-# Drain & discard any resurfaced notifications so the assertion sees only our test message.
-spt api --adapter "$ADAPTER" poll "$BID" --session-id "$BSID" >/dev/null 2>&1
-
-# Send one message with body specials (newline + < > & ") from a known sender, then drain raw.
-printf 'hello from probe<NL>second <line> & "stuff"' | sed 's/<NL>/\
-/' | spt send "$BID" --from probe-int >/dev/null 2>&1
-raw=$(spt api --adapter "$ADAPTER" poll "$BID" --session-id "$BSID" 2>&1)
-
-# 1. Canonical <EVENT type="msg" from=…> envelope with correct body escaping; no relic.
-expected='<EVENT type="msg" from="probe-int">hello from probe<br>second &lt;line&gt; &amp; &quot;stuff&quot;</EVENT>'
-case "$raw" in *"$expected"*) ok "api poll emits canonical <EVENT> msg envelope (escaped body)" ;; *) bad "envelope mismatch; raw=[$raw]" ;; esac
-case "$raw" in *__REPLY_TO__*) bad "raw drain still carries the __REPLY_TO__ relic" ;; *) ok "no __REPLY_TO__ relic (canonical poll envelope shipped)" ;; esac
-
-# 2. Hook BINARY confirm-match (D1): the real `claude-spt hook UserPromptSubmit` drains the live perch
-#    and renders the canonical <EVENT> drain to our <sptc_messages> additionalContext shape — the same
-#    parser, now in the binary (was render_frames in _common.sh). Send a fresh message with body
-#    specials, run the hook (it resolves the perch via whoami off OWL_SESSION_ID, marks busy, polls
-#    --include-deferred, renders), then re-idle + drain residue so step 3's plain poll stays clean.
-#    [int->REQ-DIST-HOOK-BINARY] [int->REQ-UPS-INJECTION]
-HOOKBIN="$ROOT/tools/claude-spt/target/release/omp-spt.exe"
-[ -x "$HOOKBIN" ] || HOOKBIN="$ROOT/tools/claude-spt/target/release/omp-spt"
-if [ -x "$HOOKBIN" ]; then
-  printf 'hello from probe<NL>second <line> & "stuff"' | sed 's/<NL>/\
-/' | spt send "$BID" --from probe-int >/dev/null 2>&1
-  # The binary resolves the perch via `spt whoami` with OWL_SESSION_ID set from the stdin session_id.
-  rendered=$(printf '%s' "{\"session_id\":\"$BSID\",\"prompt\":\"\"}" | "$HOOKBIN" hook UserPromptSubmit --host-pid $$ 2>/dev/null)
-  want=$(printf '<sptc_messages from="probe-int">\nhello from probe\nsecond <line> & "stuff"\n</sptc_messages>')
-  case "$rendered" in *"$want"*) ok "binary hook confirm-match: live drain -> <sptc_messages>" ;; *) bad "binary render mismatch; got=[$rendered]" ;; esac
-  # Re-idle the perch (the hook marked it busy) and drain any residue so step 3 is unaffected.
-  spt api --adapter "$ADAPTER" state idle "$BID" --session-id "$BSID" >/dev/null 2>&1
-  spt api --adapter "$ADAPTER" poll "$BID" --session-id "$BSID" --include-deferred >/dev/null 2>&1
-else
-  echo "SKIP: claude-spt binary not built (cargo build --release) — binary hook confirm-match needs it"
-fi
-
-# 3. Multi-message: two sends drain as two whole envelopes (self-delimiting; F-002 dissolved).
-printf 'one' | spt send "$BID" --from alice >/dev/null 2>&1
-printf 'two' | spt send "$BID" --from bob >/dev/null 2>&1
-multi=$(spt api --adapter "$ADAPTER" poll "$BID" --session-id "$BSID" 2>&1)
-n=$(printf '%s\n' "$multi" | grep -c 'type="msg"')
-[ "$n" -eq 2 ] && ok "multi-message: 2 whole <EVENT> envelopes split on </EVENT>" || bad "expected 2 msg envelopes, got $n"
-
-[ "$fail" -eq 0 ] && { echo "MSG-ENVELOPE-INT OK"; exit 0; } || { echo "MSG-ENVELOPE-INT FAIL"; exit 1; }
diff --git a/ci/idle-translate/build.sh b/ci/idle-translate/build.sh
deleted file mode 100644
index dde747a..0000000
--- a/ci/idle-translate/build.sh
+++ /dev/null
@@ -1,11 +0,0 @@
-#!/bin/sh
-# The idle-translation filter is now the `translate` subcommand of the CONSOLIDATED claude-spt crate
-# (D3 fold, ADR-0006 — spt-core v0.16.0 gave [message-idle-translation-binary] a `command` field, so
-# the standalone cc-spt-idle-translate crate is retired). It is built + unit-tested by ci/digest/build.sh
-# (the canonical build of the one binary; its cargo run covers the translate choreography/checkpoint
-# tests too). This gate is a thin shim so the run-gates "idle-translate" slot stays announced WITHOUT a
-# redundant second cargo build/test of the same crate. The daemon spawn-on-up/reap-on-down lifecycle +
-# atomic PTY apply stay covered by ci/idle-translate/translate-proof-int.sh (the int).
-# [impl->REQ-DIST-IDLE-TRANSLATE]
-set -u
-echo "ok  cc-spt-idle-translate: folded into the consolidated claude-spt crate as the translate subcommand (built/tested by ci/digest/build.sh)"
diff --git a/ci/idle-translate/translate-proof-int.sh b/ci/idle-translate/translate-proof-int.sh
deleted file mode 100644
index 0940b35..0000000
--- a/ci/idle-translate/translate-proof-int.sh
+++ /dev/null
@@ -1,138 +0,0 @@
-#!/bin/sh
-# Integration proof: `spt adapter translate-proof` spawns + feeds the claude-spt
-# [message-idle-translation-binary] (`claude-spt translate` subcommand) EXACTLY as the daemon does at idle
-# delivery (init line then the --event envelope), reads back the emitted keystroke-command stream,
-# and gates it. This is the EMIT half of REQ-DIST-IDLE-TRANSLATE — the cross-process author-time proof
-# (ADR-0022, the EMIT-half mirror of digest-proof). It does NOT exercise the daemon's atomic PTY APPLY
-# or controller buffering — that half stays the real-claude bringup int (deferred). [int->REQ-DIST-IDLE-TRANSLATE]
-#
-# Uses the v0.13.2 `--dir`/`--manifest` override (F-011 closed, W5) to proof the DEV binary straight
-# from its build dir against the bare-file manifest: --dir resolves the binary (before PATH) exactly
-# as the daemon does, --manifest pins the bare-file manifest. NO registry mutation — the prior form
-# staged a disposable install dir and `adapter add`/`adapter remove claude-spt`, which soft-removed
-# the REAL registered claude-spt on cleanup. Read-only now, so NO SPTC_ACCEPTANCE gate. Needs
-# spt >= 0.13.2 (the --dir/--manifest options) + a built binary. Idempotent.
-# Run: sh ci/idle-translate/translate-proof-int.sh   (exit 0 = pass).
-#
-# GREEN against the {commit}-terminated binary: emits the 6-command choreography ctrl+s · 50ms ·
-# {text:"<envelope>"} · 50ms · {key:enter} · {commit:true}, exit 0 / TRANSLATE_PROOF_OK / "commit: yes".
-# The submit is a discrete {key:enter} AFTER the text (a trailing \r byte does NOT submit a CC message,
-# corrected 2026-06-23). The no-{commit} form FAULTs (the F-016 defect the proof's no-commit gate catches).
-set -u
-ROOT=$(CDPATH= cd "$(dirname "$0")/../.." && pwd)
-MANIFEST="$ROOT/adapter/omp-spt.toml"
-RELDIR="$ROOT/tools/claude-spt/target/release"   # consolidated binary; manifest command = {adapter_dir}/omp-spt translate (D3)
-EVENT='<EVENT type="msg" from="ci">translate-proof int probe</EVENT>'
-
-command -v spt >/dev/null 2>&1 || { echo "SKIP: no spt on PATH"; exit 0; }
-
-# --dir/--manifest landed in spt v0.13.2 — capability-detect rather than version-parse.
-if ! spt adapter translate-proof --help 2>&1 | grep -q -- '--dir'; then
-  echo "SKIP: spt 'adapter translate-proof' has no --dir/--manifest (needs v0.13.2). Binary itself: cargo tests green."
-  exit 0
-fi
-
-BIN="$RELDIR/claude-spt"
-[ -x "$BIN" ] || BIN="$RELDIR/claude-spt.exe"
-[ -x "$BIN" ] || { echo "SKIP: binary not built (run sh ci/digest/build.sh)"; exit 0; }
-
-# Proof the dev binary in-place: --dir resolves the binary (before PATH) like the daemon, --manifest
-# pins the bare-file gh_release manifest — no extracted install, no registry touch.
-out=$(spt adapter translate-proof claude-spt --event "$EVENT" --manifest "$MANIFEST" --dir "$RELDIR" 2>&1)
-rc=0
-case "$out" in
-  *TRANSLATE_PROOF_OK*) echo "ok  translate-proof: TRANSLATE_PROOF_OK" ;;
-  *) echo "FAIL: translate-proof did not pass:"; printf '%s\n' "$out"; exit 1 ;;
-esac
-# The {commit} terminator is the F-016 fix — assert the proof saw it (no-commit would FAULT live).
-case "$out" in
-  *"commit: yes"*) echo "ok  emitted the mandatory {commit} terminator (commit: yes)" ;;
-  *) echo "FAIL: proof reports no commit terminator (the F-016 fault condition):"; printf '%s\n' "$out"; rc=1 ;;
-esac
-# The submit is a discrete enter keypress (NOT a trailing \r in the text — a \r byte does not submit CC).
-case "$out" in
-  *enter*) echo "ok  emitted the discrete {key:enter} submit" ;;
-  *) echo "FAIL: no {key:enter} submit in the command stream:"; printf '%s\n' "$out"; rc=1 ;;
-esac
-# ...and the text command must NOT carry a trailing \r anymore.
-case "$out" in
-  *'\r"'*) echo "FAIL: text still carries a trailing \\r (should be a discrete enter):"; printf '%s\n' "$out"; rc=1 ;;
-  *) echo "ok  text command carries no trailing \\r" ;;
-esac
-# The envelope is FRAMED across multiple lines for visual distinction: a raw \n after the opening
-# tag and before the closing </EVENT>. CC soft-newlines a bare \n (empirically gated 2026-06-24), so
-# this renders as one user turn spanning lines, not an early submit. The emitted {text} carries the
-# two deliberate framing newlines (JSON-escaped as \n in the command stream). [int->REQ-DIST-IDLE-MULTILINE]
-case "$out" in
-  *'>\n'*'\n</EVENT>'*) echo "ok  envelope framed across lines (\\n after opening tag and before </EVENT>)" ;;
-  *) echo "FAIL: text is not framed across lines (multi-line envelope missing):"; printf '%s\n' "$out"; rc=1 ;;
-esac
-
-# ── CHECKPOINT branch — ARM emit (the SPLIT clear/wake fix) ──────────────────────────────────────
-# An envelope carrying `json="{"checkpoint":"v1",…}"` ARMS the wake in the translation binary's memory
-# and emits CLEAR-ONLY — the wake is WITHHELD until a later `{"checkpoint_fire":"v1"}` signal (self-sent
-# by the SessionStart hook AFTER /clear completes). translate-proof feeds a single event to a FRESH
-# process, so it proves the ARM emit (clear-only, no wake, no long settle); the stateful arm→fire→wake
-# ordering is proven by the crate unit tests (arm_then_fire_orders_clear_before_wake) + the live E2E.
-# The same block is the int evidence for the checkpoint-commune feature (envelope → detect → arm/clear)
-# AND the race-fix split.
-# [int->REQ-DIST-CHECKPOINT-COMMUNE] [int->REQ-HAZARD-CHECKPOINT-CLEAR-RACE]
-CKPT='<EVENT type="msg" from="self" json="{&quot;checkpoint&quot;:&quot;v1&quot;,&quot;wake&quot;:&quot;Resume now&quot;}">checkpoint requested</EVENT>'
-ck=$(spt adapter translate-proof claude-spt --event "$CKPT" --manifest "$MANIFEST" --dir "$RELDIR" 2>&1)
-case "$ck" in
-  *'text  "/clear"'*) echo "ok  checkpoint envelope ARMS + emits /clear" ;;
-  *) echo "FAIL: checkpoint envelope did not emit /clear:"; printf '%s\n' "$ck"; rc=1 ;;
-esac
-# The wake is WITHHELD in the ARM emit (the split ordering fix — no wake text, no 500ms straddle).
-case "$ck" in
-  *'text  "Resume now"'*) echo "FAIL: ARM emit leaked the wake (must be withheld until fire):"; printf '%s\n' "$ck"; rc=1 ;;
-  *) echo "ok  ARM emit withholds the wake (no race — fires only after /clear)" ;;
-esac
-case "$ck" in
-  *'delay 500ms'*) echo "FAIL: ARM emit still carries the old 500ms straddle:"; printf '%s\n' "$ck"; rc=1 ;;
-  *) echo "ok  ARM emit has no post-/clear straddle delay (retired)" ;;
-esac
-case "$ck" in
-  *'commit: yes'*) echo "ok  ARM emit terminates with the mandatory {commit}" ;;
-  *) echo "FAIL: ARM emit missing the {commit} terminator:"; printf '%s\n' "$ck"; rc=1 ;;
-esac
-# Default-wake checkpoint (no `wake` field) still ARMS + emits clear-only.
-CKPT_DEF='<EVENT type="msg" from="self" json="{&quot;checkpoint&quot;:&quot;v1&quot;}">checkpoint requested</EVENT>'
-ckd=$(spt adapter translate-proof claude-spt --event "$CKPT_DEF" --manifest "$MANIFEST" --dir "$RELDIR" 2>&1)
-case "$ckd" in
-  *'text  "/clear"'*) echo "ok  default-wake checkpoint ARMS + emits /clear" ;;
-  *) echo "FAIL: default-wake checkpoint did not emit /clear:"; printf '%s\n' "$ckd"; rc=1 ;;
-esac
-# A normal (non-checkpoint) message must NOT fire the macro.
-case "$out" in
-  *'/clear'*) echo "FAIL: a normal message emitted /clear (checkpoint false-positive):"; printf '%s\n' "$out"; rc=1 ;;
-  *) echo "ok  normal delivery never fires the /clear macro" ;;
-esac
-
-# ── BOUNDARY RENAME — the /clear-boundary name STASH (v0.15.1 fold) ──────────────────────────────
-# An envelope carrying `json="{"rename":"v1","name":…}"` (self-sent by the SessionStart hook on a
-# `clear` boundary, BEFORE the checkpoint_fire) STASHES the name and answers a bare {commit} — the
-# rename keystrokes ride the fire's ONE combined sequence (two back-to-back inject sequences raced
-# at the post-clear boundary and the wake submitted INSIDE the /rename argument — flynn 2026-07-06).
-# translate-proof feeds a single event to a FRESH process, so it proves the STASH emit (bare commit,
-# zero keystrokes); the stateful rename→fire combined emit is proven by the crate unit
-# checkpoint_boundary_is_one_combined_sequence_rename_then_wake + the live e2e.
-# [int->REQ-DIST-BOUNDARY-RENAME]
-RN='<EVENT type="msg" from="self" json="{&quot;rename&quot;:&quot;v1&quot;,&quot;name&quot;:&quot;ci @ NODE (proj/)&quot;}">boundary rename</EVENT>'
-rn=$(spt adapter translate-proof claude-spt --event "$RN" --manifest "$MANIFEST" --dir "$RELDIR" 2>&1)
-case "$rn" in
-  *'/rename'*) echo "FAIL: rename envelope emitted keystrokes (must STASH-only — the fold):"; printf '%s\n' "$rn"; rc=1 ;;
-  *) echo "ok  rename envelope emits NO keystrokes (stash-only, rides the fire's combined sequence)" ;;
-esac
-case "$rn" in
-  *'commit: yes'*) echo "ok  rename stash answers the mandatory bare {commit}" ;;
-  *) echo "FAIL: rename stash missing the {commit} terminator:"; printf '%s\n' "$rn"; rc=1 ;;
-esac
-# A normal message must NOT trigger the rename branch (the marker is json-attr-only, unforgeable
-# from a body).
-case "$out" in
-  *'/rename'*) echo "FAIL: a normal message emitted /rename (rename false-positive):"; printf '%s\n' "$out"; rc=1 ;;
-  *) echo "ok  normal delivery never fires /rename" ;;
-esac
-
-[ "$rc" -eq 0 ] && { echo "TRANSLATE-PROOF-INT OK"; exit 0; } || { echo "TRANSLATE-PROOF-INT FAIL"; exit 1; }
diff --git a/ci/idle-translate/wake-survival-int.sh b/ci/idle-translate/wake-survival-int.sh
deleted file mode 100644
index 33c37ce..0000000
--- a/ci/idle-translate/wake-survival-int.sh
+++ /dev/null
@@ -1,168 +0,0 @@
-#!/bin/sh
-# LIVE wake-survival E2E — the checkpoint clear+wake macro fired END-TO-END on a real box, proven by
-# a SIDE-EFFECT file the woken session writes. This is the graduated live successor to the deterministic
-# EMIT int (ci/idle-translate/translate-proof-int.sh checkpoint block, which asserts ARM emits clear-only
-# and FIRE emits wake-only in isolation): here a real CC session is bound, a `{"checkpoint":"v1","wake":…}`
-# envelope is delivered, the /clear boundary rotates the session, and the wake directive is observed to
-# EXECUTE (the woken agent writes the proof file). [int->REQ-HAZARD-CHECKPOINT-CLEAR-RACE]
-#
-# Also graduates the DEFERRED live assertion logged under REQ-HAZARD-EMPTY-RESPONSE-COMMIT ("the live
-# every-clear boundary survival assert graduates with wake-repro.sh -> the wake-survival e2e once core
-# C-1 lands"): the translate binary is asserted ALIVE after the /clear boundary (the B6 ghost —
-# every-clear zero-record kill — would have terminated it). [int->REQ-HAZARD-EMPTY-RESPONSE-COMMIT]
-#
-# The full five-layer stack must hold for the proof to land: zero-record {commit} terminator (v0.13.1) +
-# core C-1 miss!=fault + core C-2 ready-restrand at the boundary + enter-coalescing submit settle
-# (v0.13.3). Requires spt-core >= 0.24.0 (C-1/C-2 = B6 closure) and an installed claude-spt >= 0.13.3.
-#
-# GROUND TRUTH IS THE SIDE-EFFECT FILE, never a transcript: broker-PTY probe sessions leave NO transcript
-# jsonl in any config root (rig gap, banked) — assert via the file the wake writes, not by reading history.
-#
-# Spawns a real endpoint + headless claude, pre-trusts the disposable cwd + nested psyche dir in
-# ~/.claude.json (ATOMICALLY: tmp + fsync + os.replace — NEVER open-truncate the trust store; ENOSPC
-# mid-write wipes every project's trust) and removes those two keys again on exit. Mutates node-local
-# perch state; all torn down on exit. Gated behind SPTC_ACCEPTANCE=1. Idempotent (per-run unique id).
-# Run: SPTC_ACCEPTANCE=1 sh ci/idle-translate/wake-survival-int.sh   (exit 0 = pass).
-set -u
-ROOT=$(CDPATH= cd "$(dirname "$0")/../.." && pwd)
-
-# Disposable perch id — NEVER a live agent's id (REQ-HAZARD-PERCH-COLLISION). Per-run unique ($$): the
-# daemon hosts a session at most once per session_id, so a fixed id would not re-bind on a rerun.
-PROBE=sptc-ci-wakesurv-$$
-SUBNET="${SPTC_CI_SUBNET:-SPT_DEV}"
-OWLERY="${SPT_HOME:-$HOME/AppData/Local/spt-core}/owlery"
-
-if [ "${SPTC_ACCEPTANCE:-0}" != "1" ]; then echo "SKIP: set SPTC_ACCEPTANCE=1 to run (spawns a live CC session + mutates perch + trust state)"; exit 0; fi
-command -v spt >/dev/null 2>&1 || { echo "SKIP: no spt on PATH"; exit 0; }
-command -v python >/dev/null 2>&1 || { echo "SKIP: no python (trust-seed + info.json reads)"; exit 0; }
-ver=$(spt --version 2>/dev/null | awk '{print $NF}')
-# B6 closure (C-1 miss!=fault + C-2 ready-restrand) lands in spt-core 0.24.0 — below it the wake cannot
-# survive the boundary and this proof is expected-red for reasons outside the adapter's control.
-case "$ver" in
-  0.24.*|0.25.*|0.26.*|0.27.*|0.28.*|0.29.*|0.3[0-9].*|0.[4-9][0-9].*|[1-9].*) : ;;
-  *) echo "SKIP: spt $ver < 0.24.0 (B6 closure C-1/C-2 not present; wake cannot survive the boundary)"; exit 0 ;;
-esac
-
-RIG=$(mktemp -d 2>/dev/null) || { echo "FATAL: mktemp -d"; exit 2; }
-CWD="$RIG/cwd"; PROOF="$RIG/WAKE-PROOF.txt"; EXPECT="WAKE-OK-$PROBE"
-mkdir -p "$CWD/.claude"
-NESTED="$OWLERY/$PROBE/nested/$PROBE-psyche"
-
-fail=0
-ok()  { echo "ok   $1"; }
-bad() { echo "FAIL $1"; fail=1; }
-ts()  { date -u +%H:%M:%S.%3NZ 2>/dev/null || date -u +%H:%M:%SZ; }
-alive() { powershell -Command "[bool](Get-Process -Id $1 -ErrorAction SilentlyContinue)" 2>/dev/null | tr -d '\r'; }
-# Windows pids of the running translate binaries (claude-spt.exe with a `translate` command line).
-tpids() { powershell -Command "Get-CimInstance Win32_Process -Filter \"Name='claude-spt.exe'\" | Where-Object {\$_.CommandLine -match 'translate'} | Select-Object -ExpandProperty ProcessId" 2>/dev/null | tr -d '\r' | tr '\n' ' '; }
-sid_of() { python -X utf8 -c "import json;print(json.load(open(r'$OWLERY/$PROBE/info.json'))['session_id'])" 2>/dev/null; }
-
-cleanup() {
-  # Kill the probe's CC + translate subtree (by matching command line to the disposable id).
-  powershell -Command "Get-CimInstance Win32_Process -Filter \"Name='claude.exe' OR Name='claude-spt.exe'\" | Where-Object {\$_.CommandLine -match '$PROBE'} | ForEach-Object { Stop-Process -Id \$_.ProcessId -Force -Confirm:\$false -ErrorAction SilentlyContinue }" >/dev/null 2>&1
-  spt endpoint stop "$PROBE" >/dev/null 2>&1 || true
-  echo y | spt endpoint purge "$PROBE" --force >/dev/null 2>&1 || true
-  # Remove the two trust keys we added (leave every OTHER project's trust untouched; atomic write).
-  python -X utf8 - "$CWD" "$NESTED" <<'PY' 2>/dev/null || true
-import json,os,sys
-cwd,nested=sys.argv[1:3]
-p=os.path.expanduser('~/.claude.json')
-try: d=json.load(open(p,encoding='utf-8'))
-except Exception: sys.exit(0)
-pr=d.get('projects',{})
-for k in (cwd,nested): pr.pop(k,None)
-tmp=p+'.tmp'
-with open(tmp,'w',encoding='utf-8') as f: json.dump(d,f,indent=2); f.flush(); os.fsync(f.fileno())
-os.replace(tmp,p)
-PY
-  rm -rf "$RIG" 2>/dev/null || true
-}
-trap cleanup EXIT INT TERM
-
-echo "== WAKE-SURVIVAL INT  probe=$PROBE  spt=$ver  $(ts) =="
-spt adapter list --json 2>/dev/null | python -X utf8 -c "import json,sys
-try: a=[x for x in json.load(sys.stdin)['adapters'] if x['name']=='claude-spt'][0]; print('   adapter claude-spt', a['version'])
-except Exception: print('   adapter version unknown')" 2>/dev/null
-
-# Pre-trust the disposable cwd + the nested psyche dir (untrusted cwd = CC dies at spawn, KH §2.2).
-# Copy the trust-relevant keys from an already-trusted project as a template; force hasTrustDialogAccepted.
-python -X utf8 - "$CWD" "$NESTED" <<'PY'
-import json,os,sys
-cwd,nested=sys.argv[1:3]
-p=os.path.expanduser('~/.claude.json'); d=json.load(open(p,encoding='utf-8'))
-pr=d.setdefault('projects',{})
-keys=('allowedTools','mcpServers','enabledMcpjsonServers','disabledMcpjsonServers','hasTrustDialogAccepted','projectOnboardingSeenCount','hasClaudeMdExternalIncludesApproved','hasClaudeMdExternalIncludesWarningShown')
-tmpl={}
-for v in pr.values():
-    if isinstance(v,dict) and v.get('hasTrustDialogAccepted'):
-        tmpl={k:v[k] for k in keys if k in v}; break
-tmpl['hasTrustDialogAccepted']=True; tmpl.setdefault('allowedTools',[])
-for k in (cwd,nested): pr[k]=dict(tmpl)
-tmp=p+'.tmp'
-with open(tmp,'w',encoding='utf-8') as f: json.dump(d,f,indent=2); f.flush(); os.fsync(f.fileno())
-os.replace(tmp,p); print('   pretrusted (atomic tmp+fsync+replace)')
-PY
-
-BEFORE=" $(tpids) "
-( cd "$CWD" && spt endpoint run --adapter claude-spt --id "$PROBE" --start --subnet "$SUBNET" >/dev/null 2>&1 )
-
-# Wait (bounded) for the endpoint to come alive; nudge the fresh CC session so it settles + stamps ready.
-BOUND=no
-for i in $(seq 1 16); do
-  if spt daemon status 2>/dev/null | grep "$PROBE" | grep -q "alive=true"; then BOUND=yes; break; fi
-  case "$i" in 3|5|7|9) { sleep 2; printf '1'; sleep 1; printf '\r'; sleep 3; } | timeout 10 spt rc "$PROBE" --take >/dev/null 2>&1 ;; esac
-  sleep 5
-done
-[ "$BOUND" = yes ] && ok "endpoint bound (alive)" || { bad "endpoint never went alive in ~90s"; echo "WAKE-SURVIVAL-INT FAIL"; exit 1; }
-
-sleep 2
-AFTER="$(tpids)"; MYPID=""
-for p in $AFTER; do case "$BEFORE" in *" $p "*) : ;; *) MYPID=$p ;; esac; done
-[ -n "$MYPID" ] && ok "translate binary spawned (pid=$MYPID)" || bad "no fresh translate pid identified"
-
-# Settle the session (drives CC past its first prompt) so the boundary machinery stamps ready.
-{ sleep 2; printf 'standby'; sleep 1; printf '\r'; sleep 3; } | timeout 9 spt rc "$PROBE" >/dev/null 2>&1
-RDY=no
-for i in $(seq 1 30); do [ -f "$OWLERY/$PROBE/ready" ] && { RDY=yes; break; }; sleep 2; done
-[ "$RDY" = yes ] && ok "ready stamped (C-2 leg present)" || bad "ready NEVER stamped in 60s (C-2 restrand missing?)"
-
-sid0=$(sid_of)
-[ -n "$sid0" ] && ok "pre-clear session id resolved" || bad "no pre-clear session id in info.json"
-
-# ARM the checkpoint: envelope stashes the wake + emits CLEAR-ONLY; the clear boundary re-runs SessionStart
-# which self-sends checkpoint_fire; translate then emits WAKE-ONLY. The wake directive writes the proof file.
-echo "-- ARM checkpoint $(ts) --"
-spt send "$PROBE" --from "$PROBE" --force-native --json-payload \
-  "{\"checkpoint\":\"v1\",\"wake\":\"Use the Write tool to create the file $PROOF with exactly the content $EXPECT and then stop.\"}" <<< "checkpoint" >/dev/null 2>&1 \
-  && ok "checkpoint ARM accepted" || bad "checkpoint ARM send failed"
-
-# The /clear boundary rotates the session id — proof the clear actually took effect.
-ROT=no
-for i in $(seq 1 45); do
-  sid=$(sid_of)
-  [ -n "$sid" ] && [ "$sid" != "$sid0" ] && { echo "   boundary: sid rotated t+$((i*2))s $(ts)"; ROT=yes; break; }
-  sleep 2
-done
-[ "$ROT" = yes ] && ok "clear boundary took effect (session id rotated)" || bad "no session rotation in 90s (clear never fired)"
-
-# THE PROOF: the woken session executed the wake directive and wrote the file.
-FOUND=no
-for i in $(seq 1 60); do
-  [ -f "$PROOF" ] && { got=$(tr -d '\r\n' < "$PROOF"); FOUND=yes; break; }
-  sleep 3
-done
-if [ "$FOUND" = yes ] && [ "$got" = "$EXPECT" ]; then
-  ok "WAKE EXECUTED end-to-end (proof file = '$got')"
-elif [ "$FOUND" = yes ]; then
-  bad "wake wrote proof but content mismatch: got='$got' want='$EXPECT'"
-else
-  bad "wake NEVER executed in 180s (no proof file) — the checkpoint macro did not complete the boundary"
-fi
-
-# B6 survival: the translate binary must still be alive after the clear boundary (the every-clear
-# zero-record kill would have terminated it). And the perch stays healthy (force-native still delivers).
-[ -n "$MYPID" ] && case "$(alive "$MYPID")" in True) ok "translate binary SURVIVED the clear boundary (B6 closure)";; *) bad "translate binary died at/after the boundary (B6 ghost)";; esac
-spt send "$PROBE" --from "$PROBE" --force-native <<< '[post]' >/dev/null 2>&1 && ok "perch healthy after wake (force-native delivers)" || bad "perch unhealthy after wake"
-
-echo "== $( [ "$fail" -eq 0 ] && echo DONE || echo FAILED ) $(ts) =="
-[ "$fail" -eq 0 ] && { echo "WAKE-SURVIVAL-INT OK"; exit 0; } || { echo "WAKE-SURVIVAL-INT FAIL"; exit 1; }
diff --git a/ci/install-hooks.sh b/ci/install-hooks.sh
deleted file mode 100644
index 22bdd4a..0000000
--- a/ci/install-hooks.sh
+++ /dev/null
@@ -1,9 +0,0 @@
-#!/bin/sh
-# Install the sptc CI git hooks into .git/hooks (git does not auto-source repo hooks).
-# Idempotent. [impl->REQ-CI-TRIGGER]
-root=$(git rev-parse --show-toplevel 2>/dev/null) || { echo "not a git repo"; exit 1; }
-src="$root/ci/git-hooks/pre-push"
-dst="$root/.git/hooks/pre-push"
-[ -f "$src" ] || { echo "missing $src"; exit 1; }
-cp "$src" "$dst" && chmod +x "$dst" && echo "installed: $dst"
-echo "set SPTC_CI_RUNNER=<fleet-runner-agent-id> to enable the push ping (else gates run manually)."
diff --git a/ci/launcher/bind-int.sh b/ci/launcher/bind-int.sh
deleted file mode 100644
index de01744..0000000
--- a/ci/launcher/bind-int.sh
+++ /dev/null
@@ -1,85 +0,0 @@
-#!/bin/sh
-# Integration proof for the spt-hosted cc-launcher BRINGUP-BIND path — the gap that hid the operator's
-# wall-b zero-perch (F-013). Drives the operator's EXACT flow against a real spt-core:
-#
-#   spt endpoint run --adapter claude-spt --id <disp> --start
-#       -> broker spawns [session.self] (`claude`) into a held PTY + injects [env.SPT_ENDPOINT_ID]={id}
-#       -> CC's SessionStart hook reads a POPULATED $SPT_ENDPOINT_ID -> sptc_register_verb=`bind`
-#       -> `spt api bind <id>` self-registers a BOUND perch on disk
-#   spt send <disp>  ->  reaches it (SENT = live PTY inject, REQ-SEND-SPT-HOSTED; QUEUED also accepted)
-#
-# This is the int that WOULD HAVE CAUGHT the bug: pre-v0.11.0, `endpoint run` did NOT substitute
-# [env.<VAR>].value="{id}" (injected EMPTY), so SessionStart fell to `seed`-by-PPID instead of `bind`
-# -> ZERO perch -> `spt send` NO_PERCH. doyle's v0.11.0 REQ-HAZARD-ENV-SUBST fix populates it.
-# [int->REQ-CC-LAUNCHER-BIND]
-#
-# Spawns a REAL claude (the [session.self] target) into a broker PTY + the daemon livehost spawns its
-# Psyche (base manifest is live-capable) + mutates node-local perch state — ALL torn down on exit.
-# Gated behind SPTC_ACCEPTANCE=1 and spt >=0.11.0 (older silently seeds-not-binds). Disposable, per-run
-# unique id (REQ-HAZARD-PERCH-COLLISION — NEVER a live agent's id). Idempotent.
-# Run: SPTC_ACCEPTANCE=1 sh ci/launcher/bind-int.sh   (exit 0 = pass).
-set -u
-ROOT=$(CDPATH= cd "$(dirname "$0")/../.." && pwd)
-A=claude-spt
-OWLERY="${LOCALAPPDATA:-$HOME/AppData/Local}/spt-core/owlery"
-
-if [ "${SPTC_ACCEPTANCE:-0}" != "1" ]; then echo "SKIP: set SPTC_ACCEPTANCE=1 to run (spawns a real claude + Psyche, mutates perch state)"; exit 0; fi
-command -v spt >/dev/null 2>&1 || { echo "SKIP: no spt on PATH"; exit 0; }
-ver=$(spt --version 2>/dev/null | awk '{print $NF}')
-case "$ver" in
-  0.0.*|0.1.*|0.2.*|0.3.*|0.4.*|0.5.*|0.6.*|0.7.*|0.8.*|0.9.*|0.10.*)
-    echo "SKIP: spt $ver < 0.11.0 (endpoint-run [env].value substitution = REQ-HAZARD-ENV-SUBST/F-013, counter 24)"; exit 0 ;;
-esac
-spt adapter list 2>/dev/null | grep -q "claude-spt" || { echo "SKIP: claude-spt not registered (spt adapter add)"; exit 0; }
-
-RUN=$$
-ID=ccbind-int-$RUN
-RUNPID=""
-fail=0
-ok()  { echo "ok   $1"; }
-bad() { echo "FAIL $1"; fail=1; }
-
-cleanup() {
-  # 1. Kill the broker-spawned claude (the [session.self] target) by its run pid, subtree.
-  [ -n "$RUNPID" ] && taskkill //PID "$RUNPID" //T //F >/dev/null 2>&1
-  # 2. Kill the disposable Psyche ONLY (cmdline carries this run's unique id — never wall-a's).
-  for p in $(wmic process where "name='claude-spt.exe' and commandline like '%$ID%'" get processid 2>/dev/null | tr -dc '0-9 \n' | tr ' ' '\n' | grep -E '^[0-9]+$'); do
-    taskkill //PID "$p" //T //F >/dev/null 2>&1
-  done
-  # 3. Take the endpoint offline + erase its perch.
-  spt endpoint shutdown "$ID" >/dev/null 2>&1 || true
-  spt endpoint stop "$ID" >/dev/null 2>&1 || true
-  tok=$(cat "$OWLERY/$ID/api.token" 2>/dev/null)
-  [ -n "$tok" ] && spt api session-end "$ID" --erase --token "$tok" >/dev/null 2>&1 || true
-  rm -rf "$OWLERY/$ID" >/dev/null 2>&1 || true
-}
-trap cleanup EXIT INT TERM
-
-# Bring up the spt-hosted endpoint (returns immediately; the PTY session keeps running).
-runout=$(spt endpoint run --adapter "$A" --id "$ID" --start 2>&1)
-echo "$runout" | grep -q "ENDPOINT_RUN_STARTED:$ID" && ok "endpoint run started ($ID)" || bad "endpoint run did not start: [$runout]"
-RUNPID=$(printf '%s' "$runout" | grep -oE 'pid=Some\([0-9]+\)' | grep -oE '[0-9]+' | head -1)
-
-# Wait (bounded ~50s) for SessionStart to BIND the perch (the bug = this never appearing).
-i=0; while [ "$i" -lt 25 ]; do [ -f "$OWLERY/$ID/info.json" ] && break; sleep 2; i=$((i+1)); done
-
-# 1. The spt-hosted SessionStart bind produced a BOUND perch on disk (info.json + api.token + ready).
-if [ -f "$OWLERY/$ID/info.json" ] && [ -f "$OWLERY/$ID/api.token" ]; then
-  ok "SessionStart BOUND a perch on disk (owlery/$ID — the F-013 zero-perch is fixed)"
-else
-  bad "no bound perch at owlery/$ID after ~50s (SessionStart seeded-not-bound? SPT_ENDPOINT_ID empty?)"
-fi
-
-# 2. The bound perch is registered/online in this node's local roster.
-spt endpoint list --local 2>/dev/null | grep -q "$ID" && ok "endpoint registered in local roster" || bad "$ID not in endpoint list --local"
-
-# 3. The bound spt-hosted endpoint is REACHABLE — `spt send` reaches it (SENT = live PTY inject per
-#    REQ-SEND-SPT-HOSTED; QUEUED = spooled, still reachable). NO_PERCH would mean no perch behind it.
-sendout=$(printf 'ccbind-int reachability probe' | spt send "$ID" --from "$ID" 2>&1)
-case "$sendout" in
-  SENT:*)   ok "send reached the spt-hosted endpoint LIVE (SENT — PTY inject)" ;;
-  QUEUED:*) ok "send reached the spt-hosted endpoint (QUEUED — spooled, reachable)" ;;
-  *)        bad "send did not reach $ID: [$sendout]" ;;
-esac
-
-[ "$fail" -eq 0 ] && { echo "CC-LAUNCHER-BIND-INT OK"; exit 0; } || { echo "CC-LAUNCHER-BIND-INT FAIL"; exit 1; }
diff --git a/ci/lib/spt-bus.sh b/ci/lib/spt-bus.sh
deleted file mode 100644
index b65cf6e..0000000
--- a/ci/lib/spt-bus.sh
+++ /dev/null
@@ -1,21 +0,0 @@
-# shellcheck shell=sh
-# Locate the spt messaging (bus) binary ROBUSTLY at run time. The bus is legacy spt (`$OWL send`,
-# the dogfood reporting channel per SCOPE/docs/CI.md); its path MOVES each release (per-version
-# plugins cache), so NEVER hard-code a versioned location — resolve fresh. [impl->REQ-CI-OWL-DISCOVERY]
-# [impl->REQ-CI-BUS]
-resolve_spt_send() {
-  # 1) explicit override (CI config / fleet host setup)
-  if [ -n "${SPTC_CI_BUS:-}" ] && [ -x "${SPTC_CI_BUS}" ]; then printf '%s' "$SPTC_CI_BUS"; return 0; fi
-  # 2) a live session's injected $OWL
-  if [ -n "${OWL:-}" ] && [ -x "${OWL}" ]; then printf '%s' "$OWL"; return 0; fi
-  # 3) on PATH (owl.exe / owl = legacy bus; spt = newer core, also has `send`)
-  for c in owl.exe owl spt; do
-    if command -v "$c" >/dev/null 2>&1; then command -v "$c"; return 0; fi
-  done
-  # 4) per-version plugin caches — newest wins (version-sorted), path never hard-coded
-  cand=$(ls -1 \
-    "$HOME"/.claude/plugins/cache/*/spt/*/owl.exe \
-    "$HOME"/.ccs/*/plugins/cache/*/spt/*/owl.exe 2>/dev/null | sort -V | tail -n1)
-  if [ -n "$cand" ] && [ -x "$cand" ]; then printf '%s' "$cand"; return 0; fi
-  return 1
-}
diff --git a/ci/manifest/check-manifest.sh b/ci/manifest/check-manifest.sh
index ff34923..07a7e6e 100644
--- a/ci/manifest/check-manifest.sh
+++ b/ci/manifest/check-manifest.sh
@@ -1,5 +1,5 @@
 #!/bin/sh
-# manifest-schema gate: validate the claude-spt adapter manifest against spt-core's published
+# manifest-schema gate: validate the omp-spt adapter manifest against spt-core's published
 # (vendored) manifest.schema.json. Deterministic + offline — no network, no spt binary, no
 # registry side effects. Self-announcing: prints its own ok/SKIP/FAIL line.
 #   exit 0 = valid OR skipped (no capable interpreter) · exit 1 = manifest failed validation.
diff --git a/ci/manifest/registration-int.sh b/ci/manifest/registration-int.sh
deleted file mode 100644
index 2689a15..0000000
--- a/ci/manifest/registration-int.sh
+++ /dev/null
@@ -1,98 +0,0 @@
-#!/bin/sh
-# Integration proof for the claude-spt adapter manifest against a REAL spt-core (>= v0.7.0): the
-# 2nd validation layer beyond JSON Schema — spt-core's `spt adapter add` cross-field registration —
-# accepts the manifest, the shipped profile resolves, [strings] read through the registry, and the
-# profile overlay is observable (base vs :ccs differ). This is the v1 acceptance proof for the
-# adapter manifest (LLM never in the loop; pure CLI assertions). [int->REQ-DIST-MANIFEST-SCHEMA]
-#
-# Mutates the node-local adapter registry (add + soft-remove), so it is gated behind SPTC_ACCEPTANCE=1
-# and a present spt>=0.7.0 — never runs in the default `tests/*.sh` unit sweep. Idempotent: removes
-# what it adds. Run: SPTC_ACCEPTANCE=1 sh ci/manifest/registration-int.sh   (exit 0 = pass).
-set -u
-ROOT=$(CDPATH= cd "$(dirname "$0")/../.." && pwd)
-MANIFEST="$ROOT/adapter/omp-spt.toml"
-
-if [ "${SPTC_ACCEPTANCE:-0}" != "1" ]; then echo "SKIP: set SPTC_ACCEPTANCE=1 to run (mutates the adapter registry)"; exit 0; fi
-command -v spt >/dev/null 2>&1 || { echo "SKIP: no spt on PATH"; exit 0; }
-ver=$(spt --version 2>/dev/null | awk '{print $NF}')
-case "$ver" in
-  0.6.*|0.5.*|0.4.*|0.3.*|0.2.*|0.1.*|0.0.*) echo "SKIP: spt $ver < 0.7.0 (shortcut_basename + adapter add are v0.7.0)"; exit 0 ;;
-esac
-
-fail=0
-ok()  { echo "ok   $1"; }
-bad() { echo "FAIL $1"; fail=1; }
-# Clean up registry residue however we exit.
-trap 'spt adapter remove claude-spt >/dev/null 2>&1 || true' EXIT INT TERM
-
-# 1. Registration cross-field validation accepts the manifest.
-out=$(spt adapter add "$MANIFEST" 2>&1)
-case "$out" in *registered*) ok "spt adapter add: registered" ;; *) bad "adapter add rejected: $out" ;; esac
-
-# 2. Listed, with the shipped profile resolved as a composite option.
-list=$(spt adapter list 2>&1)
-case "$list" in *claude-spt*) ok "listed: claude-spt active" ;; *) bad "claude-spt not listed" ;; esac
-# NOTE: there is no `:live` profile (Option A, PREP-4) — base claude-spt is live-capable
-# ([session.psyche_init] in base); the LiveAgent capability is asserted via `spt api capability` at
-# step 4d below, not a composite resolve.
-# The ccs overlay (:ccs leaf-replaces [session.self].command -> `ccs`, a drop-in for `claude`) —
-# the LOCKED-ADD ccs profile template (REQ-CCS-PROFILES; validated vs sister project claude_skill_owl).
-case "$list" in *claude-spt:ccs*) ok "shipped profile resolves: claude-spt:ccs (ccs overlay)" ;; *) bad "ccs profile not resolved" ;; esac
-
-# 3. [strings] read through the registry (base value).
-base=$(spt adapter get-string claude-spt adapter_label 2>&1)
-[ "$base" = "Claude Code (spt)" ] && ok "strings resolve: adapter_label (base)" || bad "base adapter_label='$base'"
-
-# 4. Profile overlay is observable: :ccs leaf-replaces the base string. (The placeholder :deep
-#    profile was removed 2026-06-18; :ccs is the sole shipped overlay and proves the same seam.)
-# :ccs overlay observable (leaf-replaced adapter_label). [int->REQ-CCS-PROFILES]
-ccs=$(spt adapter get-string claude-spt:ccs adapter_label 2>&1)
-[ "$ccs" = "Claude Code (spt, ccs)" ] && ok "overlay observable: :ccs adapter_label differs" || bad "ccs adapter_label='$ccs'"
-
-# 4b. File-backed [strings] pointer resolves to FILE CONTENTS (not the table, not raw); an inline
-#     sibling still prints as-is. Proves `{ file = "skills/<x>.md" }` over adapter/strings/ (F-003).
-body=$(spt adapter get-string claude-spt skills.ready 2>&1)
-case "$body" in "# /sptc:ready"*) ok "file-backed string resolves: skills.ready -> body" ;; *) bad "skills.ready not resolved to file body: '$(printf %.40s "$body")'" ;; esac
-# force-stop = endpoint shutdown body. (send/commune/signoff are NOT injected — full-fat in the
-# plugin SKILL.md, no [strings.skills] entry — so they are intentionally absent from this resolve set.)
-fbody=$(spt adapter get-string claude-spt "skills.force-stop" 2>&1)
-case "$fbody" in "# /sptc:force-stop"*) ok "file-backed string resolves: skills.force-stop -> body" ;; *) bad "skills.force-stop not resolved to file body: '$(printf %.40s "$fbody")'" ;; esac
-# `live` is file-backed too (the LiveAgent bringup body — base [session.psyche_init] + bare
-# `api listen`; REQ-SKILL-LIVE).
-lbody=$(spt adapter get-string claude-spt skills.live 2>&1)
-case "$lbody" in "# /sptc:live"*) ok "file-backed string resolves: skills.live -> body" ;; *) bad "skills.live not resolved to file body: '$(printf %.40s "$lbody")'" ;; esac
-# subnet (LOCKED-ADD cross-machine membership skill — wraps `spt subnet`). [int->REQ-SKILL-SUBNET]
-sbody=$(spt adapter get-string claude-spt skills.subnet 2>&1)
-case "$sbody" in "# /sptc:subnet"*) ok "file-backed string resolves: skills.subnet -> body" ;; *) bad "skills.subnet not resolved to file body: '$(printf %.40s "$sbody")'" ;; esac
-
-# 4c. UPS skill-injection end-to-end via the BINARY (D1): `claude-spt hook UserPromptSubmit` resolves a
-#     /sptc:<skill> prompt to the wrapped operative body via get-string on the registered adapter. No
-#     perch (whoami empty) → only skill-injection emits, no drain. (REQ-UPS-INJECTION impl now in the
-#     binary.) Prefer the release build; the dev `adapter add` above registered the manifest, so
-#     get-string resolves the file-backed skill body. [int->REQ-DIST-HOOK-BINARY]
-HOOKBIN="$ROOT/tools/claude-spt/target/release/omp-spt.exe"
-[ -x "$HOOKBIN" ] || HOOKBIN="$ROOT/tools/claude-spt/target/release/omp-spt"
-if [ -x "$HOOKBIN" ]; then
-  inj=$(printf '%s' '{"session_id":"reg-int-nosession","prompt":"/sptc:ready listen up"}' | "$HOOKBIN" hook UserPromptSubmit --host-pid $$ 2>/dev/null)
-  case "$inj" in
-    '<sptc_skill name="ready">'*'# /sptc:ready'*'</sptc_skill>'*) ok "UPS skill-injection (binary): /sptc:ready -> wrapped body" ;;
-    *) bad "skill-injection did not emit wrapped body: $(printf %.60s "$inj")" ;;
-  esac
-else
-  echo "SKIP: claude-spt binary not built (cargo build --release) — skill-injection int needs it"
-fi
-
-# 4d. The spt-hosted bringup blocks ([session.self] + [env.SPT_ENDPOINT_ID]) cross-field-validate:
-#     `adapter add` (step 1) is manifest-first ("an invalid manifest registers nothing"), so the
-#     manifest carrying these blocks registering at all proves spt-core accepted their shape. Confirm
-#     the registered adapter advertises a hostable harness — the thing `spt endpoint run` spawns via
-#     [session.self] (the M12 cc-launcher target). [int->REQ-DIST-MANIFEST-SCHEMA]
-cap=$(spt api --adapter claude-spt --manifest "$MANIFEST" capability 2>&1)
-case "$cap" in *LiveAgent*) ok "bringup blocks accepted; capability reports hostable harness" ;; *) bad "capability missing LiveAgent: $cap" ;; esac
-
-# 5. Soft-deregister cleanly.
-rm=$(spt adapter remove claude-spt 2>&1)
-list2=$(spt adapter list 2>&1)
-case "$list2" in *"claude-spt"*"active"*) bad "claude-spt still active after remove" ;; *) ok "removed (soft-deregistered)" ;; esac
-
-[ "$fail" -eq 0 ] && { echo "MANIFEST-REGISTRATION-INT OK"; exit 0; } || { echo "MANIFEST-REGISTRATION-INT FAIL"; exit 1; }
diff --git a/ci/psyche-download/psyche-download-int.sh b/ci/psyche-download/psyche-download-int.sh
deleted file mode 100644
index f2d287f..0000000
--- a/ci/psyche-download/psyche-download-int.sh
+++ /dev/null
@@ -1,91 +0,0 @@
-#!/bin/sh
-# Integration proof for the spt-core v0.15.0 `spt api psyche-download <id>` resume-context verb
-# (REQ-DIST-RESUME-CONTEXT, T3). This is the CORE-CONTRACT half of the int: pure spt-core CLI
-# behavior, deterministic, self-hosted, NO real CC needed — a throwaway perch is bind-created via
-# `api bind` (which writes the perch record + session id directly, no broker/CC spawn), the four
-# contract behaviors are asserted against a live 0.15.0 binary, then the perch is purged.
-#
-# The SessionStart INJECTION E2E — the adapter's session-start.sh hook actually CONSUMING this pull
-# and injecting it into a live CC — genuinely needs the NEW plugin installed + a real CC session, so
-# it stays a LOGGED dogfood-after-plugin-land tier (CHECKPOINT-COMMUNE-PLAN.md §Deferred validations),
-# NOT covered here (doyle's gate ruling, 2026-06-24). The int evidence tag sits on the assertion block
-# below, not here.
-#
-# Needs spt >= 0.15.0 (the verb) + a subnet to home the throwaway perch. Feature-detects and SKIPs
-# otherwise (never a hard fail on an older / subnet-less node). Idempotent. Run: exit 0 = pass.
-#
-# WATCH-ITEM (doyle, 2026-06-24): the POSITIVE assertion polls for the <pending-commune> across a
-# retry window that must straddle the daemon's ~5s ingest pulse — too NARROW a window can miss a
-# late-appearing pending slice on a loaded host (cf. the seedmap starvation flake). Widened to 8 polls
-# here for headroom; widen further (not lower) if it ever flakes on a contended box — never treat a
-# miss as a real contract failure.
-set -u
-ADAPTER=claude-spt
-ID="sptc-pdint-$$"
-SID="sptc-pdint-sess-$$"
-
-command -v spt >/dev/null 2>&1 || { echo "SKIP: no spt on PATH"; exit 0; }
-
-# Verb capability-detect (lands in spt v0.15.0).
-if ! spt api psyche-download --help >/dev/null 2>&1; then
-  echo "SKIP: spt 'api psyche-download' absent (needs v0.15.0). Hook wiring: tests/hooks-parse.sh green."
-  exit 0
-fi
-echo "ok   verb present: api psyche-download <id> --session-id"
-
-# A subnet to home the throwaway perch (bind refuses to guess when the node holds >1 subnet).
-SUBNET=$(spt endpoint list 2>/dev/null | sed -n 's/^SUBNET \([^ ]*\).*/\1/p' | head -1)
-[ -n "$SUBNET" ] || { echo "SKIP: no subnet on this node to home the test perch"; exit 0; }
-
-cleanup() {
-  printf 'y\n' | spt endpoint purge "$ID" --force --yes >/dev/null 2>&1 || true
-  rm -f ".claude/$ID-commune.md"
-}
-trap cleanup EXIT INT TERM
-
-# Bind-create the perch (NO CC — api bind writes the perch record + session id directly).
-if ! spt api --adapter "$ADAPTER" bind "$ID" --set-session-id "$SID" --subnet "$SUBNET" >/dev/null 2>&1; then
-  echo "SKIP: could not bind-create the test perch (subnet $SUBNET)"
-  exit 0
-fi
-
-rc=0
-errf="${TMPDIR:-/tmp}/sptc-pdint-$$.err"
-
-# 1. NO-CONTEXT: a fresh perch -> exit 0, EMPTY stdout, NO-CONTEXT:<id> on stderr (the hook skips).
-out=$(spt api --adapter "$ADAPTER" psyche-download "$ID" --session-id "$SID" 2>"$errf"); ec=$?
-err=$(cat "$errf" 2>/dev/null)
-if [ "$ec" -eq 0 ] && [ -z "$out" ] && { printf '%s' "$err" | grep -q "NO-CONTEXT:$ID"; }; then
-  echo "ok   NO-CONTEXT: fresh perch -> exit 0, empty stdout, NO-CONTEXT on stderr"
-else
-  echo "FAIL NO-CONTEXT contract: exit=$ec stdout=[$out] stderr=[$err]"; rc=1
-fi
-
-# 2. AUTH: a wrong --session-id is rejected (non-zero exit; AUTH_REFUSED).
-if spt api --adapter "$ADAPTER" psyche-download "$ID" --session-id "WRONG-$SID" >/dev/null 2>&1; then
-  echo "FAIL AUTH: a wrong --session-id was NOT rejected"; rc=1
-else
-  echo "ok   AUTH: wrong --session-id rejected"
-fi
-
-# 3. POSITIVE: a not-yet-synthesized commune drop is returned VERBATIM as <pending-commune>. Retried
-#    across the brief pre-synthesis window (the daemon eventually ingests + clears the drop). This is
-#    the core resume-context behavior the SessionStart hook injects. [int->REQ-DIST-RESUME-CONTEXT]
-MARK="PDINT-POS-$$"
-mkdir -p .claude
-printf '%s resume delta\n' "$MARK" > ".claude/$ID-commune.md"
-got=""
-i=0
-while [ "$i" -lt 8 ]; do  # 8-poll window straddles the ~5s daemon ingest pulse (see WATCH-ITEM header)
-  o=$(spt api --adapter "$ADAPTER" psyche-download "$ID" --session-id "$SID" 2>/dev/null)
-  if printf '%s' "$o" | grep -q "$MARK"; then got="$o"; break; fi
-  i=$((i + 1)); sleep 1
-done
-if { printf '%s' "$got" | grep -q '<pending-commune>'; } && { printf '%s' "$got" | grep -q "$MARK"; }; then
-  echo "ok   POSITIVE: not-yet-synthesized commune returned VERBATIM as <pending-commune>"
-else
-  echo "FAIL POSITIVE: pending-commune not returned (got=[$got])"; rc=1
-fi
-
-rm -f "$errf"
-[ "$rc" -eq 0 ] && { echo "PSYCHE-DOWNLOAD-INT OK"; exit 0; } || { echo "PSYCHE-DOWNLOAD-INT FAIL"; exit 1; }
diff --git a/ci/psyche/build.sh b/ci/psyche/build.sh
deleted file mode 100644
index c245155..0000000
--- a/ci/psyche/build.sh
+++ /dev/null
@@ -1,11 +0,0 @@
-#!/bin/sh
-# The psyche runner is now the `psyche` subcommand of the CONSOLIDATED claude-spt crate (ADR-0006,
-# U2) — built + unit-tested by ci/digest/build.sh (the canonical build of the one binary; its cargo
-# run covers the psyche arg/command-construction tests too). This gate is kept as a thin shim so the
-# run-gates "psyche-runner" slot stays meaningful and announced, WITHOUT a redundant second cargo
-# build/test of the same crate ("one build", U2). The runner's resident pulse loop + subprocess spawn
-# remain integration (deferred behind the daemon Psyche loop + a real live CC session, REQ-SKILL-LIVE).
-# [impl->REQ-SKILL-LIVE]
-# [impl->REQ-DIST-BINARY-CONSOLIDATE]
-set -u
-echo "ok  claude-spt-psyche: folded into the consolidated claude-spt crate (built/tested by ci/digest/build.sh)"
diff --git a/ci/psyche/live-relay-int.sh b/ci/psyche/live-relay-int.sh
deleted file mode 100644
index 4097267..0000000
--- a/ci/psyche/live-relay-int.sh
+++ /dev/null
@@ -1,156 +0,0 @@
-#!/bin/sh
-# Integration proof for /sptc:live's LiveAgent bringup against a REAL spt-core (>= v0.7.3): the
-# `claude-spt:live` profile's [session.psyche_init] makes spt spawn the Psyche, and the resident
-# relay (`spt api listen <id>`, the production delivery pipe — run inside CC's Monitor tool, heir to
-# legacy `$LIVE start <id>`) binds the live perch and streams inbound as the canonical <EVENT>
-# envelope. We play Monitor's role: spawn `api listen` as a CHILD PROCESS (persistent, NOT --once —
-# --once is the degenerate no-Monitor path) with `--manifest` (the manifest loads ONLY via --manifest;
-# `--adapter <name>` is just a name → without it LiveHost is None and no Psyche spawns), capture its
-# stdout/stderr, send a probe, and assert the bringup markers. The LLM is never judged. [int->REQ-SKILL-LIVE]
-#
-# Covers BOTH legs of REQ-SKILL-LIVE int: (1) PSYCHE-SPAWN — version-dependent marker (M11 restructure,
-# doyle 2026-06-16): on <0.8.0 `api listen` spawns the Psyche IN-PROCESS (`PSYCHE_SPAWNED:{id}-psyche`
-# off the listen child, startup.rs spawn_psyche pre once/loop split); on >=0.8.0 the DAEMON livehost
-# hosts it by spawning claude-spt-psyche (resolved by bare name from the adapter install dir) — assert
-# the RESIDENT runner process + nested `{id}-psyche` perch dir (FINALIZED on v0.8.1 + the adapter
-# greedy-prompt fix, 2026-06-16; see the >=0.8.0 leg below). (2) RELAY — the resident listen pipe delivers the probe (BOUND/READY/<EVENT> off the child,
-# unchanged across versions). The per-pulse runner command construction is additionally covered by
-# claude-spt-psyche unit tests (ci/psyche/build.sh).
-#
-# PSYCHE-SPAWN binary resolution: the psyche_init command invokes `claude-spt-psyche` by bare name.
-# On v0.8.0+ (Feature B / REQ-INSTALL-11) spt resolves it FROM the adapter install dir (proven: the
-# binary registration-copies into adapters/_github/<safe>/, no PATH interim needed). On 0.7.3 it must
-# be on PATH (the F-006 interim copy). The >=0.8.0 leg now ASSERTS a resident runner (was skip-with-note
-# pre-v0.8.1); the <0.8.0 leg still SKIPs when the runner is unresolvable. The relay leg asserts always.
-#
-# Spawns a real claude-spt-psyche (which launches a headless claude) + mutates node-local perch state,
-# all torn down on exit. Gated behind SPTC_ACCEPTANCE=1. Idempotent.
-# Run: SPTC_ACCEPTANCE=1 sh ci/psyche/live-relay-int.sh   (exit 0 = pass).
-set -u
-ROOT=$(CDPATH= cd "$(dirname "$0")/../.." && pwd)
-A=claude-spt
-MAN="$ROOT/adapter/omp-spt.toml"
-# Disposable perch id — NEVER a live agent's id (REQ-HAZARD-PERCH-COLLISION). Override BOTH identity
-# env vars; pin OWL_SESSION_ID for the auth-gated seed/send/listen surfaces. PER-RUN UNIQUE ($$ suffix):
-# the daemon hosts a Psyche at most ONCE per session_id, so a FIXED id/session would not re-host on a
-# rerun (the first run's hosted-session memory suppresses it) — each CI run must be a fresh session.
-# Option A (PREP-4): [session.psyche_init] is in the BASE manifest — NO `:live` profile. The adapter
-# is BASE claude-spt; the live `api listen` COMMAND (not a composite) is what stamps state=live_agent
-# and actualizes the Psyche. We still pass an explicit `--adapter claude-spt --manifest <man>` here:
-# CI has no real `claude` parent process, so spt-core's bare-by-pid host_binaries resolution cannot
-# fire (the anchor is `sh`/`timeout`, not `claude`). The explicit override remains valid on 0.9.0 and
-# loads the same base manifest the bare flow would resolve. The TRUE bare-flow (no --adapter, by-pid
-# resolution under a real claude host) is covered by the live /sptc:live VERIFY, not this int.
-RUN=$$
-ID=sptc-ci-liverelay-$RUN
-SID=sptc-ci-liverelay-$RUN-sess
-export SPTC_CI_ID="$ID" SPT_AGENT_ID="$ID" OWL_SESSION_ID="$ID"
-
-if [ "${SPTC_ACCEPTANCE:-0}" != "1" ]; then echo "SKIP: set SPTC_ACCEPTANCE=1 to run (spawns a Psyche + mutates perch state)"; exit 0; fi
-command -v spt >/dev/null 2>&1 || { echo "SKIP: no spt on PATH"; exit 0; }
-ver=$(spt --version 2>/dev/null | awk '{print $NF}')
-case "$ver" in
-  0.7.2|0.7.1|0.7.0|0.6.*|0.5.*|0.4.*|0.3.*|0.2.*|0.1.*|0.0.*) echo "SKIP: spt $ver < 0.7.3 (daemon live path / counter-15)"; exit 0 ;;
-esac
-[ -f "$MAN" ] || { echo "SKIP: no manifest at $MAN"; exit 0; }
-
-# Anchor pid: spt probes WINDOWS pids — from git-bash `$$` is the MSYS pid and reads as a dead anchor
-# (STALE_SEED/NO_SEED). Use the WINPID column from `ps` when present (git-bash col 4); elsewhere `$$`
-# is already the real pid spt probes.
-ANCHOR=$(ps -p $$ 2>/dev/null | awk 'NR==2{print $4}'); case "$ANCHOR" in ''|*[!0-9]*) ANCHOR=$$;; esac
-
-# Can the psyche runner be resolved on THIS host? (PATH now, or manifest-dir on v0.8.0+ Feature B.)
-psyche_resolvable() {
-  command -v claude-spt >/dev/null 2>&1 && return 0
-  case "$ver" in 0.7.*) return 1 ;; *) return 0 ;; esac  # Feature B (manifest-dir resolution) lands in v0.8.0; >=0.8.0 resolvable
-}
-
-LF=$(mktemp 2>/dev/null) || { echo "FATAL: mktemp"; exit 2; }
-CHILD=""
-fail=0
-ok()  { echo "ok   $1"; }
-bad() { echo "FAIL $1"; fail=1; }
-skip(){ echo "skip $1"; }
-cleanup() {
-  # Kill the spawned Psyche subtree first (the runner + its headless claude), by marker pid then name.
-  pp=$(grep -oE 'PSYCHE_SPAWNED:[^ ]+ pid=[0-9]+' "$LF" 2>/dev/null | grep -oE '[0-9]+' | tail -1)
-  [ -n "$pp" ] && taskkill //PID "$pp" //T //F >/dev/null 2>&1
-  for p in $(tasklist 2>/dev/null | grep -i claude-spt | awk '{print $2}'); do taskkill //PID "$p" //T //F >/dev/null 2>&1; done
-  [ -n "$CHILD" ] && kill "$CHILD" >/dev/null 2>&1
-  spt endpoint shutdown "$ID" >/dev/null 2>&1 || true
-  spt endpoint stop "$ID" >/dev/null 2>&1 || true
-  rm -f "$LF" 2>/dev/null || true
-}
-trap cleanup EXIT INT TERM
-
-# Seed the harness-hosted startup (anchored to the pid that will parent the listen child).
-spt api --adapter "$A" --manifest "$MAN" seed --pid "$ANCHOR" --session-id "$SID" >/dev/null 2>&1
-
-# Spawn the resident relay as a CHILD (Monitor surrogate). timeout bounds it so a hang can't wedge CI.
-timeout 30 spt api --adapter "$A" --manifest "$MAN" listen --parent-pid "$ANCHOR" "$ID" > "$LF" 2>&1 &
-CHILD=$!
-
-# Wait (bounded) for the bringup to announce readiness.
-i=0; while [ "$i" -lt 25 ]; do grep -q "READY:$ID" "$LF" 2>/dev/null && break; sleep 1; i=$((i+1)); done
-
-# 1. The live listen path binds the perch.
-grep -q "BOUND:$ID" "$LF" 2>/dev/null && ok "live perch bound" || bad "no BOUND:$ID; log=[$(cat "$LF")]"
-# 2. The live listen path announces readiness (the relay heartbeat is up).
-grep -q "READY:$ID" "$LF" 2>/dev/null && ok "live listen READY:$ID" || bad "no READY:$ID; log=[$(cat "$LF")]"
-# 3. PSYCHE-SPAWN — the marker model differs by version (M11 restructure; doyle 2026-06-16):
-case "$ver" in
-  0.7.*)
-    # <0.8.0: `api listen` spawns the Psyche IN-PROCESS → `PSYCHE_SPAWNED:{id}-psyche pid=` off the
-    # listen child's stderr. The bare `claude-spt-psyche` resolves via the F-006 PATH interim here.
-    if grep -q "PSYCHE_SPAWNED:$ID-psyche pid=" "$LF" 2>/dev/null; then
-      ok "Psyche spawned in-process ($(grep -oE "PSYCHE_SPAWNED:$ID-psyche pid=[0-9]+" "$LF" | head -1))"
-    elif grep -q "PSYCHE_SPAWN_FAIL:" "$LF" 2>/dev/null && ! psyche_resolvable; then
-      skip "psyche-spawn: runner unresolvable on spt $ver without the F-006 PATH interim (Feature B/REQ-INSTALL-11 lands v0.8.0) — $(grep -oE 'PSYCHE_SPAWN_FAIL:[^]]*' "$LF" | head -1)"
-    else
-      bad "no PSYCHE_SPAWNED marker (manifest declares psyche_init? runner resolvable?); log=[$(cat "$LF")]"
-    fi
-    ;;
-  *)
-    # >=0.8.0: the in-process spawn is gone (M11 restructure) — `api listen` emits only BOUND/READY +
-    # stamps the perch `status="online"` IFF the resolved manifest declares [session.psyche_init]
-    # (startup.rs:283 live_capable guard); the DAEMON reconcile then hosts the Psyche off that online
-    # status (the `{id}-psyche` perch comes online; `LIVEHOST_PSYCHE:{id}` on the daemon's stderr).
-    # RESOLVED (v0.8.1 + adapter greedy-prompt fix, 2026-06-16): hosting succeeds iff the daemon
-    # spawned claude-spt-psyche AND the runner stays RESIDENT. Two bugs were in the way: (1) spt-core
-    # <0.8.1 livehost did not reconcile (no spawn at all); v0.8.1 fixed it. (2) spt-core substitutes
-    # `{psyche_prompt}` into the psyche_init command STRING then whitespace-SPLITS, so the multi-word
-    # prompt arrived as stray argv tokens — the runner's non-greedy --prompt rejected the 2nd word
-    # ("unknown arg") and exited 2 instantly → the daemon recorded a phantom hosted perch (nested
-    # info.json status=online, real-looking pid) with NO live process and NO psyche_host_error. The
-    # runner now parses --prompt greedily (slurps trailing tokens). DETECTION: the nested {id}-psyche
-    # perch does NOT surface in `endpoint list` (it lives under the parent in the owlery), so assert on
-    # the RESIDENT runner process + the nested perch dir for THIS id. This is also the REQ-INSTALL-11
-    # install-dir-resolution proof: the runner resolved by bare name FROM the adapter install dir.
-    OWL="${SPT_HOME:-$HOME/AppData/Local/spt-core}/owlery/$ID/nested/$ID-psyche/info.json"
-    # The runner exe is now claude-spt.exe (running the `psyche` subcommand; ADR-0006/U2). In this
-    # disposable CI session the only claude-spt process is the psyche runner, so the image-name match
-    # is unambiguous (tasklist shows the image name, not the subcommand).
-    resident() { tasklist 2>/dev/null | grep -qi "claude-spt"; }
-    j=0; while [ "$j" -lt 20 ]; do resident && [ -f "$OWL" ] && break; sleep 1; j=$((j+1)); done
-    procs=$(tasklist 2>/dev/null | grep -ci "claude-spt")
-    nested=no; [ -f "$OWL" ] && nested=yes
-    if resident && [ -f "$OWL" ]; then
-      ok "Psyche daemon-hosted: claude-spt-psyche runner RESIDENT for $ID-psyche (v0.8.1 livehost + greedy-prompt fix; REQ-INSTALL-11 install-dir resolution proven)"
-    else
-      bad "psyche-spawn: no resident claude-spt-psyche for $ID (v0.8.1 host gap or prompt-split regression); nested=$nested procs=$procs"
-    fi
-    ;;
-esac
-
-# Deliver a probe with body specials; the resident relay streams it live to the child's stdout.
-printf 'live relay probe <a> & "b"' | spt send "$ID" --from relay-probe >/dev/null 2>&1
-i=0; while [ "$i" -lt 20 ]; do grep -q 'type="msg"' "$LF" 2>/dev/null && break; sleep 1; i=$((i+1)); done
-
-# 4. RELAY: the probe arrives as the canonical <EVENT> envelope with correct body escaping.
-expected='<EVENT type="msg" from="relay-probe">live relay probe &lt;a&gt; &amp; &quot;b&quot;</EVENT>'
-grep -qF "$expected" "$LF" 2>/dev/null && ok "probe relayed through the live pipe as escaped <EVENT>" || bad "envelope mismatch; log=[$(cat "$LF")]"
-# 5. The endpoint registered as a live_agent (the :live kind was honored on bringup).
-kind=$(spt daemon status 2>&1 | sed -n '/local endpoints/,$p' | grep -E "(^| )$ID( |$)")
-case "$kind" in *live_agent*) ok "endpoint registered as live_agent (:live kind honored)" ;; *) bad "endpoint not live_agent: [$kind]" ;; esac
-
-[ "$fail" -eq 0 ] && { echo "LIVE-RELAY-INT OK"; exit 0; } || { echo "LIVE-RELAY-INT FAIL"; exit 1; }
diff --git a/ci/publish/package-adapter.sh b/ci/publish/package-adapter.sh
index 09a1dd6..b8f35a6 100644
--- a/ci/publish/package-adapter.sh
+++ b/ci/publish/package-adapter.sh
@@ -1,28 +1,17 @@
 #!/bin/sh
-# Pack the SINGLE MULTI-PLATFORM `adapter.spt` release asset — the end-user distribution acquired by
-# `spt adapter add --release BigscreenVR/omp-spt` and carried by the `[update] gh_release`
-# avenue. ONE fat archive covers every supported platform (ADR-0024 W1, spt-core >= 0.13.2).
-# The release/install/update repo is `BigscreenVR/omp-spt` (renamed from spt-claude-code, U3/ADR-0005).
-# [impl->REQ-DIST-ADAPTER-RELEASE] [impl->REQ-DIST-ADAPTER-PEROS] [impl->REQ-DIST-NAME-UNIFY]
+# Pack the multi-platform `adapter.spt` release asset acquired from
+# `BigscreenVR/omp-spt` and used by the manifest's `gh_release` update avenue.
+# [impl->REQ-DIST-ADAPTER-RELEASE]
 #
-#   adapter.spt (tar.gz)
-#   ├── manifest.toml                 ← SHARED, at archive root (renamed from omp-spt.toml)
-#   ├── strings/                      ← SHARED, at archive root
-#   ├── x86_64-pc-windows-msvc/       ← this triple's binary, mirroring the flat-root tree
-#   │   ├── claude-spt.exe
-#   └── x86_64-unknown-linux-gnu/
-#       └── claude-spt
+# Archive root:
+#   manifest.toml
+#   strings/omp-spt.mjs
+#   x86_64-pc-windows-msvc/omp-spt.exe
+#   x86_64-unknown-linux-gnu/omp-spt
 #
-# spt-core CLASSIFIES on top-level entry names: a known target-triple dir ⇒ multi-platform; it places
-# the shared-root entries + FLATTENS this node's <triple>/* into the install dir (so a bare-name
-# command token still resolves at <install_dir>/<program>, REQ-INSTALL-11). This RETIRES the F-014
-# per-OS stopgap (the old single-OS `adapter.spt`-by-default that broke on a foreign host).
-#
-# CONSTRAINTS (doyle, extract_release_archive): only x86_64-pc-windows-msvc + x86_64-unknown-linux-gnu
-# are recognized triples — an UNRECOGNIZED dir name is silently treated as a shared-root entry and
-# lands flat (no error), so for platforms beyond these two ship a separate single-triple asset via
-# `--asset` instead of adding a dir here. A fat archive REQUIRES the manifest's
-# min_spt_core_version >= 0.13.2 (older spt-core cannot read it). DRY-RUN by default; never uploads.
+# spt-core classifies the recognized triple directories and flattens this
+# node's binary beside the shared root. The manifest's v0.29.0 floor is above
+# the v0.13.2 multi-platform archive floor. Dry-run is the default.
 #
 # Usage:
 #   package-adapter.sh            # dry-run: validate + print the archive plan, write nothing
@@ -38,16 +27,12 @@ OUT="${ADAPTER_SPT_OUT:-$ROOT/dist/adapter.spt}"   # overridable so the unit tes
 APPLY=0
 [ "${1:-}" = "--apply" ] && APPLY=1
 
-# The recognized triples and where each platform's release binaries live. A native Windows build lands
-# in target/release; the Linux build is cross-compiled (cargo-zigbuild) into
-# target/x86_64-unknown-linux-gnu/release. Override SPTC_WIN_RELSUB / SPTC_LINUX_RELSUB for a
-# non-default layout. There is now ONE tool binary: the consolidated claude-spt crate carries all four
-# subcommands — digest / psyche / post-update / translate (the last folded in at the v0.8.0 cut once
-# spt-core v0.16.0 gave [message-idle-translation-binary] a `command` field — ADR-0006/D3).
+# Native Windows builds land in target/release; Linux cross-builds land in the
+# target-specific release directory. Tests may override those locations.
 WIN_TRIPLE=x86_64-pc-windows-msvc
 LINUX_TRIPLE=x86_64-unknown-linux-gnu
-WIN_RELSUB="${SPTC_WIN_RELSUB:-release}"
-LINUX_RELSUB="${SPTC_LINUX_RELSUB:-$LINUX_TRIPLE/release}"
+WIN_RELSUB="${OMP_SPT_WIN_RELSUB:-release}"
+LINUX_RELSUB="${OMP_SPT_LINUX_RELSUB:-$LINUX_TRIPLE/release}"
 BINS="omp-spt"
 
 # Validate the manifest first — refuse to ship an invalid adapter.
@@ -68,8 +53,8 @@ esac
 echo
 echo "== tool binaries =="
 missing=0
-win_path()   { echo "$TOOLS/claude-spt/target/$WIN_RELSUB/$1.exe"; }
-linux_path() { echo "$TOOLS/claude-spt/target/$LINUX_RELSUB/$1"; }
+win_path()   { echo "$TOOLS/omp-spt/target/$WIN_RELSUB/$1.exe"; }
+linux_path() { echo "$TOOLS/omp-spt/target/$LINUX_RELSUB/$1"; }
 for b in $BINS; do
   for p in "$(win_path "$b")" "$(linux_path "$b")"; do
     if [ -f "$p" ]; then echo "  ok    $p"; else echo "  MISS  $p"; missing=1; fi
@@ -98,7 +83,7 @@ if [ "$APPLY" -ne 1 ]; then
 fi
 
 # Stage the archive ROOT in a temp dir, then tar from it so paths are root-relative (no leading dirs).
-STAGE=$(mktemp -d "${TMPDIR:-/tmp}/sptc-adapter.XXXXXX") || { echo "FATAL: mktemp failed"; exit 2; }
+STAGE=$(mktemp -d "${TMPDIR:-/tmp}/omp-spt-adapter.XXXXXX") || { echo "FATAL: mktemp failed"; exit 2; }
 trap 'rm -rf "$STAGE"' EXIT
 cp "$MANIFEST" "$STAGE/manifest.toml"
 cp -r "$STRINGS" "$STAGE/strings"
diff --git a/ci/publish/package-skeleton.sh b/ci/publish/package-skeleton.sh
deleted file mode 100644
index a240225..0000000
--- a/ci/publish/package-skeleton.sh
+++ /dev/null
@@ -1,55 +0,0 @@
-#!/bin/sh
-# Stage the omps cplugs SKELETON into a marketplace clone — the runbook "per skeleton bump" cp
-# mechanic as a real, idempotent, validated script. DRY-RUN by default: prints the plan and stages
-# nothing. Never pushes (marketplace credentials + the commit/push are the operator's step).
-# [impl->REQ-DIST-PLUGIN-SKELETON]
-#
-# Usage:
-#   package-skeleton.sh                 # dry-run against the default $MARKET
-#   package-skeleton.sh --apply         # actually copy the skeleton subset into $MARKET
-#   MARKET=/path/to/cplugs/plugins/omps package-skeleton.sh --apply
-set -u
-HERE=$(CDPATH= cd "$(dirname "$0")" && pwd)
-ROOT=$(CDPATH= cd "$HERE/../.." && pwd)
-PLUGIN="$ROOT/plugin/omps"
-MARKET="${MARKET:-$HOME/.claude/plugins/marketplaces/cplugs/plugins/omps}"
-APPLY=0
-[ "${1:-}" = "--apply" ] && APPLY=1
-
-# Validate first — refuse to stage an invalid / leaky skeleton.
-echo "== validate skeleton =="
-if ! sh "$HERE/validate-skeleton.sh" "$PLUGIN"; then
-  echo "REFUSING to package: skeleton failed validation (fix above, then retry)." >&2
-  exit 1
-fi
-
-# The skeleton SUBSET — exactly what cplugs carries (no binary, no manifest, no runtime state).
-SUBSET=".claude-plugin/plugin.json hooks skills bootstrap.sh bootstrap.ps1"
-
-echo
-echo "== plan ($([ "$APPLY" -eq 1 ] && echo APPLY || echo DRY-RUN)) =="
-echo "source : $PLUGIN"
-echo "target : $MARKET"
-for item in $SUBSET; do
-  if [ -e "$PLUGIN/$item" ]; then echo "  stage  $item"; else echo "  WARN   missing source: $item"; fi
-done
-
-if [ "$APPLY" -ne 1 ]; then
-  echo
-  echo "DRY-RUN: nothing copied. Re-run with --apply to stage into \$MARKET, then commit+push the"
-  echo "cplugs repo and 'claude plugin install omps@cplugs' (see docs/RELEASE-RUNBOOK.md)."
-  exit 0
-fi
-
-mkdir -p "$MARKET/.claude-plugin" "$MARKET/hooks" "$MARKET/skills" || { echo "FATAL: cannot create $MARKET"; exit 2; }
-cp "$PLUGIN/.claude-plugin/plugin.json" "$MARKET/.claude-plugin/"
-# Replace dir contents wholesale so removed skeleton files don't linger in the marketplace clone.
-rm -rf "$MARKET/hooks" "$MARKET/skills"
-cp -r "$PLUGIN/hooks" "$MARKET/hooks"
-cp -r "$PLUGIN/skills" "$MARKET/skills"
-for b in bootstrap.sh bootstrap.ps1; do [ -f "$PLUGIN/$b" ] && cp "$PLUGIN/$b" "$MARKET/"; done
-
-echo
-echo "STAGED into $MARKET. Next (operator): cd into the cplugs repo, 'git add plugins/omps/',"
-echo "commit + push, then 'claude plugin install omps@cplugs' + /reload-plugins."
-exit 0
diff --git a/ci/publish/release-acquire-int.sh b/ci/publish/release-acquire-int.sh
index 8bd11be..325d5a2 100644
--- a/ci/publish/release-acquire-int.sh
+++ b/ci/publish/release-acquire-int.sh
@@ -1,62 +1,39 @@
 #!/bin/sh
-# Integration proof for the END-USER adapter acquisition leg: `spt adapter add --release
-# <user/repo>` fetches the `adapter.spt` GitHub release asset (packed by package-adapter.sh),
-# extracts it, and leaves claude-spt ACTIVE sourced from the per-adapter `_github/<safe>` install
-# dir — distribution straight from the monorepo, no dedicated repo. Encodes the dogfood-proven
-# acquire as deterministic CLI assertions on a real spt-core (>= v0.7.3, where `--release` lands).
-# The LLM is never in the loop. [int->REQ-DIST-ADAPTER-RELEASE]
-#
-# Mutates the node-local adapter registry AND hits the network (GitHub release download), so it is
-# gated behind SPTC_ACCEPTANCE=1, spt>=0.7.3, and GitHub reachability — it SKIPs (rc 0) otherwise so
-# offline/old-spt hosts stay green. Idempotent: removes what it adds. Run:
-#   SPTC_ACCEPTANCE=1 sh ci/publish/release-acquire-int.sh   (exit 0 = pass).
-# Override target with SPTC_RELEASE_REPO / SPTC_RELEASE_TAG.
+# Opt-in integration proof for the public GitHub release acquisition path.
+# [int->REQ-DIST-ADAPTER-RELEASE]
 set -u
-REPO="${SPTC_RELEASE_REPO:-SaberMage/claude-spt}"
-TAG="${SPTC_RELEASE_TAG:-v0.1.0}"
+REPO="${OMP_SPT_RELEASE_REPO:-BigscreenVR/omp-spt}"
+TAG="${OMP_SPT_RELEASE_TAG:-v0.1.3}"
 
-if [ "${SPTC_ACCEPTANCE:-0}" != "1" ]; then echo "SKIP: set SPTC_ACCEPTANCE=1 to run (mutates registry + downloads from GitHub)"; exit 0; fi
-command -v spt >/dev/null 2>&1 || { echo "SKIP: no spt on PATH"; exit 0; }
-ver=$(spt --version 2>/dev/null | awk '{print $NF}')
-case "$ver" in
-  0.7.2|0.7.1|0.7.0|0.6.*|0.5.*|0.4.*|0.3.*|0.2.*|0.1.*|0.0.*)
-    echo "SKIP: spt $ver < 0.7.3 (\`adapter add --release\` lands in v0.7.3 / counter-15)"; exit 0 ;;
-esac
-# Network preflight — SKIP (not FAIL) on an offline host so the slow lane stays green there.
-if command -v curl >/dev/null 2>&1; then
-  curl -sfI "https://github.com/$REPO/releases" >/dev/null 2>&1 || { echo "SKIP: github.com/$REPO unreachable (offline)"; exit 0; }
-else
-  echo "SKIP: no curl for the reachability preflight"; exit 0
+if [ "${OMP_SPT_ACCEPTANCE:-0}" != "1" ]; then
+  echo "SKIP: set OMP_SPT_ACCEPTANCE=1 to run (mutates registry + downloads from GitHub)"
+  exit 0
 fi
+command -v spt >/dev/null 2>&1 || { echo "SKIP: no spt on PATH"; exit 0; }
+command -v gh >/dev/null 2>&1 || { echo "SKIP: no gh on PATH"; exit 0; }
+gh auth status >/dev/null 2>&1 || { echo "SKIP: gh is not authenticated"; exit 0; }
 
 fail=0
 ok()  { echo "ok   $1"; }
 bad() { echo "FAIL $1"; fail=1; }
-# Leave no registration behind however we exit.
-trap 'spt adapter remove claude-spt >/dev/null 2>&1 || true' EXIT INT TERM
-
-# 0. Clean start — drop any prior claude-spt registration so the acquire is the thing under test.
-spt adapter remove claude-spt >/dev/null 2>&1
+trap 'spt adapter remove omp-spt >/dev/null 2>&1 || true' EXIT INT TERM
+spt adapter remove omp-spt >/dev/null 2>&1
 
-# 1. ACQUIRE from the GitHub release — the end-user one-liner.
 out=$(spt adapter add --release "$REPO" --tag "$TAG" 2>&1)
 case "$out" in
-  *registered*|*active*|*fetched*) ok "acquire: adapter add --release $REPO@$TAG succeeded" ;;
+  *registered*|*active*|*fetched*) ok "adapter add --release $REPO@$TAG succeeded" ;;
   *) bad "adapter add --release failed: $out" ;;
 esac
 
-# 2. Verify ACTIVE and sourced from the per-adapter _github install dir (NOT the local monorepo).
 list=$(spt adapter list 2>&1)
-line=$(printf '%s\n' "$list" | grep '^claude-spt:')
-case "$line" in *active*) ok "verified: claude-spt active after --release acquire" ;; *) bad "claude-spt not active: $line" ;; esac
-case "$line" in *_github*) ok "sourced from the _github install dir (real --release extract)" ;; *) bad "not sourced from _github: $line" ;; esac
-# safe-name of the repo (user/repo -> user-repo) appears in the install path.
+line=$(printf '%s\n' "$list" | grep '^omp-spt:')
+case "$line" in *active*) ok "omp-spt active after release acquisition" ;; *) bad "omp-spt not active: $line" ;; esac
+case "$line" in *_github*) ok "source is the release install directory" ;; *) bad "release install source missing: $line" ;; esac
 safe=$(printf '%s' "$REPO" | tr '/' '-')
-case "$line" in *"$safe"*) ok "install dir carries the repo safe-name ($safe)" ;; *) bad "repo safe-name '$safe' not in source path: $line" ;; esac
+case "$line" in *"$safe"*) ok "source carries repository identity $safe" ;; *) bad "repository identity missing: $line" ;; esac
 
-# 3. Profiles/strings shipped inside the .spt resolve through the registry (the asset was complete).
-case "$list" in *claude-spt:ccs*) ok "shipped profile resolves from the .spt: claude-spt:ccs" ;; *) bad "ccs profile not resolved from --release asset" ;; esac
-lbl=$(spt adapter get-string claude-spt adapter_label 2>&1)
-[ "$lbl" = "Claude Code (spt)" ] && ok "file-backed strings shipped in the .spt resolve: adapter_label" || bad "adapter_label='$lbl'"
+label=$(spt adapter get-string omp-spt adapter_label 2>&1)
+[ "$label" = "oh-my-pi (spt)" ] && ok "shared adapter strings resolve" || bad "adapter_label='$label'"
 
-[ "$fail" -eq 0 ] && { echo "RELEASE-ACQUIRE-INT OK"; exit 0; } || { echo "RELEASE-ACQUIRE-INT FAIL"; exit 1; }
+[ "$fail" -eq 0 ] && { echo "RELEASE-ACQUIRE-INT OK"; exit 0; } \
+  || { echo "RELEASE-ACQUIRE-INT FAIL"; exit 1; }
diff --git a/ci/publish/validate-skeleton.sh b/ci/publish/validate-skeleton.sh
deleted file mode 100644
index dea4fe0..0000000
--- a/ci/publish/validate-skeleton.sh
+++ /dev/null
@@ -1,88 +0,0 @@
-#!/bin/sh
-# Validate the omps cplugs SKELETON is a coherent, installable artifact carrying ONLY the skeleton
-# subset — no runtime state, no binary, no adapter manifest (those ride the spt-core registry, never
-# cplugs; see docs/RELEASE-RUNBOOK.md). Deterministic, binary pass/fail. [impl->REQ-DIST-PLUGIN-SKELETON]
-#
-# Usage: validate-skeleton.sh [plugin-dir]   (default: <repo>/plugin/omps). Exit 0 = installable.
-set -u
-HERE=$(CDPATH= cd "$(dirname "$0")" && pwd)
-ROOT=$(CDPATH= cd "$HERE/../.." && pwd)
-PLUGIN="${1:-$ROOT/plugin/omps}"
-rc=0
-bad() { printf 'FAIL: %s\n' "$1"; rc=1; }
-ok()  { printf 'ok   %s\n' "$1"; }
-
-[ -d "$PLUGIN" ] || { echo "FATAL: no plugin dir at $PLUGIN"; exit 2; }
-
-# A minimal JSON well-formedness check without a hard jq dependency: prefer jq, else python, else
-# a balanced-brace heuristic. Returns 0 if $1 parses / looks well-formed.
-json_ok() {
-  if command -v jq >/dev/null 2>&1; then jq -e . "$1" >/dev/null 2>&1; return $?; fi
-  # python3 must be PROBED by execution, not by `command -v` alone: on Windows the Microsoft-Store
-  # app-execution alias puts a python3 shim on PATH that resolves but cannot run ("Python was not
-  # found", exit 49) — trusting `command -v` made every json_ok fail on such hosts.
-  if python3 -c 1 >/dev/null 2>&1; then python3 -c 'import json,sys; json.load(open(sys.argv[1]))' "$1" >/dev/null 2>&1; return $?; fi
-  # Heuristic fallback: non-empty, starts with { , balanced braces.
-  head -c1 "$1" | grep -q '{' || return 1
-  awk '{n+=gsub(/{/,"{"); n-=gsub(/}/,"}")} END{exit (n==0)?0:1}' "$1"
-}
-# Extract a flat top-level "key":"value" string (same shape _common.sh uses).
-jval() { sed -n "s/.*\"$2\"[[:space:]]*:[[:space:]]*\"\([^\"]*\)\".*/\1/p" "$1" | head -n1; }
-
-# ── plugin.json ──────────────────────────────────────────────────────────────
-PJ="$PLUGIN/.claude-plugin/plugin.json"
-if [ -f "$PJ" ] && json_ok "$PJ"; then ok "plugin.json valid JSON"; else bad "plugin.json missing/invalid ($PJ)"; fi
-if [ -f "$PJ" ]; then
-  [ "$(jval "$PJ" name)" = "omps" ] && ok "plugin.json name=omps" || bad "plugin.json name != omps (got '$(jval "$PJ" name)')"
-  [ -n "$(jval "$PJ" version)" ] && ok "plugin.json has version" || bad "plugin.json missing version"
-  [ -n "$(jval "$PJ" description)" ] && ok "plugin.json has description" || bad "plugin.json missing description"
-fi
-
-# ── hooks.json + every referenced wrapper exists ─────────────────────────────
-HJ="$PLUGIN/hooks/hooks.json"
-if [ -f "$HJ" ] && json_ok "$HJ"; then
-  ok "hooks.json valid JSON"
-  # Pull each hooks/<name>.sh token referenced in commands; assert the file exists.
-  refs=$(grep -o 'hooks/[A-Za-z0-9_-]*\.sh' "$HJ" | sort -u)
-  for r in $refs; do
-    if [ -f "$PLUGIN/$r" ]; then ok "hook wrapper present: $r"; else bad "hooks.json references missing wrapper: $r"; fi
-  done
-else
-  bad "hooks.json missing/invalid ($HJ)"
-fi
-
-# ── every skill dir has a SKILL.md ───────────────────────────────────────────
-if [ -d "$PLUGIN/skills" ]; then
-  for d in "$PLUGIN"/skills/*/; do
-    [ -e "$d" ] || continue
-    if [ -f "${d}SKILL.md" ]; then ok "skill ok: $(basename "$d")"; else bad "skill missing SKILL.md: $(basename "$d")"; fi
-  done
-else
-  bad "no skills/ dir"
-fi
-
-# ── skeleton-subset invariant: NO runtime state / binary / manifest in the PUBLISHED surface ──
-# [impl->REQ-DIST-PLUGIN-SKELETON]
-# Scan only the subset that actually gets published (what package-skeleton.sh copies) — never the
-# whole plugin dir, so gitignored dev-tree runtime noise (e.g. a live perch's `.claude/`, which the
-# packager never copies) doesn't false-fail the gate. A leak here means a non-skeleton file landed
-# INSIDE a published path (skills/, hooks/, plugin.json, bootstrap) — that ships, so it must fail.
-SUBSET_PATHS="$PLUGIN/.claude-plugin/plugin.json $PLUGIN/hooks $PLUGIN/skills $PLUGIN/bootstrap.sh $PLUGIN/bootstrap.ps1"
-scan=""
-for p in $SUBSET_PATHS; do [ -e "$p" ] && scan="$scan $p"; done
-leaks=$(find $scan -type f \( \
-     -name 'LIVE_AGENT_IDS.json' \
-  -o -name '*-commune.md' \
-  -o -name '*-signoff.md' \
-  -o -name 'cc' -o -name 'cc-*' -o -name 'cc.bat' -o -name 'cc.sh' \
-  -o -name '*.exe' -o -name '*.bin' -o -name '*.dll' \
-  -o -name 'manifest.json' \) 2>/dev/null)
-if [ -z "$leaks" ]; then
-  ok "published surface clean (no runtime/binary/manifest leak)"
-else
-  printf 'FAIL: non-skeleton files in the published surface (runtime state / binary / manifest belong in the spt-core registry, not cplugs):\n%s\n' "$leaks"
-  rc=1
-fi
-
-printf '\n=== SKELETON: %s ===\n' "$([ "$rc" -eq 0 ] && echo INSTALLABLE || echo INVALID)"
-exit "$rc"
diff --git a/ci/run-gates.sh b/ci/run-gates.sh
index a55dcb2..a11e741 100644
--- a/ci/run-gates.sh
+++ b/ci/run-gates.sh
@@ -1,74 +1,40 @@
 #!/bin/sh
-# Deterministic CI gates for spt-claude-code — each a binary pass/fail, no model in the loop.
-# Runnable by hand on any fleet host: this IS the manual fallback. [impl->REQ-CI-GATES]
-# [impl->REQ-CI-MANUAL]
-# Gates whose artifact doesn't exist yet SKIP with a logged note (no silent caps — a skip is
-# always announced so "green" never hides un-run coverage).
+# Deterministic OMP-native adapter gates. No model or network is required.
 set -u
 ROOT=$(CDPATH= cd "$(dirname "$0")/.." && pwd)
 cd "$ROOT" || exit 2
 rc=0
+
 gate() { printf '\n=== GATE: %s ===\n' "$1"; }
 fail() { printf 'FAIL: %s\n' "$1"; rc=1; }
-
-gate "shell-syntax (sh -n)"
-for f in $(find plugin tests ci -name '*.sh' 2>/dev/null | sort); do
-  if sh -n "$f"; then printf 'ok  %s\n' "$f"; else fail "syntax: $f"; fi
-done
-
-gate "unit tests (tests/*.sh)"
-for t in tests/*.sh; do
-  [ -e "$t" ] || continue
-  if sh "$t" >/dev/null 2>&1; then printf 'ok  %s\n' "$t"; else fail "unit: $t"; sh "$t" || true; fi
+run() {
+  name=$1
+  shift
+  gate "$name"
+  if "$@"; then printf 'ok  %s\n' "$name"; else fail "$name"; fi
+}
+
+gate "shell syntax"
+for file in ci/run-gates.sh ci/digest/build.sh ci/digest/digest-proof-int.sh \
+  ci/manifest/check-manifest.sh ci/publish/package-adapter.sh \
+  ci/publish/release-acquire-int.sh tests/adapter-archive.sh \
+  tests/ci-gates.sh tests/manifest-schema.sh tests/manifest-shortcut.sh \
+  tests/native-launch-manifest.sh; do
+  if sh -n "$file"; then printf 'ok  %s\n' "$file"; else fail "syntax: $file"; fi
 done
 
-gate "digest-extractor (cargo build + test)"
-if [ -f "$ROOT/ci/digest/build.sh" ]; then
-  if sh "$ROOT/ci/digest/build.sh"; then :; else fail "digest-extractor"; fi
-else
-  echo "SKIP: no digest extractor build yet"
-fi
+run "manifest schema" sh ci/manifest/check-manifest.sh
+run "manifest schema behavior" sh tests/manifest-schema.sh
+run "manifest cutover" sh tests/manifest-shortcut.sh
+run "native launch manifest" sh tests/native-launch-manifest.sh
+run "archive packaging" sh tests/adapter-archive.sh
+run "OMP helper build and tests" sh ci/digest/build.sh
 
-gate "psyche-runner (cargo build + test)"
-if [ -f "$ROOT/ci/psyche/build.sh" ]; then
-  if sh "$ROOT/ci/psyche/build.sh"; then :; else fail "psyche-runner"; fi
-else
-  echo "SKIP: no psyche runner build yet"
-fi
-
-gate "idle-translate (cargo build + test)"
-if [ -f "$ROOT/ci/idle-translate/build.sh" ]; then
-  if sh "$ROOT/ci/idle-translate/build.sh"; then :; else fail "idle-translate"; fi
-else
-  echo "SKIP: no idle-translate build yet"
-fi
-
-gate "traceable-reqs check (requirement coverage)"
+gate "traceable requirements"
 if command -v traceable-reqs >/dev/null 2>&1; then
-  if traceable-reqs check >/dev/null 2>&1; then echo "ok  coverage green"; else fail "traceable-reqs check"; traceable-reqs check || true; fi
-else
-  echo "SKIP: traceable-reqs not on PATH (install per docs/TRACEABILITY.md)"
-fi
-
-gate "skeleton-validate (cplugs installability)"
-if [ -x "$ROOT/ci/publish/validate-skeleton.sh" ] || [ -f "$ROOT/ci/publish/validate-skeleton.sh" ]; then
-  if sh "$ROOT/ci/publish/validate-skeleton.sh" >/dev/null 2>&1; then echo "ok  skeleton installable"; else fail "skeleton-validate"; sh "$ROOT/ci/publish/validate-skeleton.sh" || true; fi
-else
-  echo "SKIP: no skeleton validator yet"
-fi
-
-gate "manifest-schema"
-if [ -f "$ROOT/ci/manifest/check-manifest.sh" ]; then
-  if sh "$ROOT/ci/manifest/check-manifest.sh"; then :; else fail "manifest-schema"; fi
-else
-  echo "SKIP: no adapter manifest yet — activates when the CC adapter manifest lands"
-fi
-
-gate "docs-drift"
-if [ -f "$ROOT/ci/docs/check-docs.sh" ]; then
-  if sh "$ROOT/ci/docs/check-docs.sh"; then :; else fail "docs-drift"; fi
+  if traceable-reqs check; then echo "ok  traceable requirements"; else fail "traceable requirements"; fi
 else
-  echo "SKIP: no docs check yet"
+  fail "traceable requirements: traceable-reqs not on PATH"
 fi
 
 printf '\n=== RESULT: %s ===\n' "$([ "$rc" -eq 0 ] && echo PASS || echo FAIL)"
diff --git a/ci/setup/activate-int.sh b/ci/setup/activate-int.sh
deleted file mode 100644
index 7d5eca8..0000000
--- a/ci/setup/activate-int.sh
+++ /dev/null
@@ -1,60 +0,0 @@
-#!/bin/sh
-# Integration proof for the /sptc:setup ACTIVATION bridge (F-005): binary-present is NOT a no-op —
-# when the adapter is `deregistered`, setup RE-ACTIVATES it. This encodes, as deterministic CLI
-# assertions on a real spt-core (>= v0.7.0), the exact deregistered->active transition the setup
-# skill body performs in local-dev (file-form) mode: probe `adapter list`; if deregistered ->
-# `adapter add <manifest>` -> verify active + shipped profile resolves. The LLM is never in the
-# loop. [int->REQ-SETUP-ACTIVATE]
-#
-# Mutates the node-local adapter registry (add/remove), so it is gated behind SPTC_ACCEPTANCE=1 and a
-# present spt>=0.7.0 — never runs in the default `tests/*.sh` unit sweep. Idempotent: removes what it
-# adds. Run: SPTC_ACCEPTANCE=1 sh ci/setup/activate-int.sh   (exit 0 = pass).
-#
-# NOTE: this is the LOCAL file-form (dev) activation path. The END-USER `--release` acquisition leg
-# is proven separately by ci/publish/release-acquire-int.sh (REQ-DIST-ADAPTER-RELEASE).
-set -u
-ROOT=$(CDPATH= cd "$(dirname "$0")/../.." && pwd)
-MANIFEST="$ROOT/adapter/omp-spt.toml"
-
-if [ "${SPTC_ACCEPTANCE:-0}" != "1" ]; then echo "SKIP: set SPTC_ACCEPTANCE=1 to run (mutates the adapter registry)"; exit 0; fi
-command -v spt >/dev/null 2>&1 || { echo "SKIP: no spt on PATH"; exit 0; }
-ver=$(spt --version 2>/dev/null | awk '{print $NF}')
-case "$ver" in
-  0.6.*|0.5.*|0.4.*|0.3.*|0.2.*|0.1.*|0.0.*) echo "SKIP: spt $ver < 0.7.0 (adapter add is v0.7.0)"; exit 0 ;;
-esac
-[ -f "$MANIFEST" ] || { echo "SKIP: no manifest at $MANIFEST"; exit 0; }
-
-fail=0
-ok()  { echo "ok   $1"; }
-bad() { echo "FAIL $1"; fail=1; }
-# Clean up registry residue however we exit (leave no claude-spt registration behind).
-trap 'spt adapter remove claude-spt >/dev/null 2>&1 || true' EXIT INT TERM
-
-# 0. Seed a registration, then soft-remove it to reach the F-005 trigger state: a `deregistered`
-#    adapter (the residue a prior install/uninstall leaves — binary present, adapter NOT active).
-spt adapter add "$MANIFEST" >/dev/null 2>&1
-spt adapter remove claude-spt >/dev/null 2>&1
-pre=$(spt adapter list 2>&1)
-preline=$(printf '%s\n' "$pre" | grep '^claude-spt:')
-case "$preline" in
-  *deregistered*) ok "precondition: claude-spt is deregistered (F-005 trigger state)" ;;
-  "")             ok "precondition: claude-spt absent (also a non-active start state)" ;;
-  *active*)       bad "precondition not reached: claude-spt still active before re-activate ($preline)" ;;
-  *)              ok "precondition: claude-spt not active ($preline)" ;;
-esac
-
-# 1. RE-ACTIVATE — the setup bridge step: `adapter add` the local manifest.
-out=$(spt adapter add "$MANIFEST" 2>&1)
-case "$out" in *registered*) ok "re-activate: adapter add registered the manifest" ;; *) bad "adapter add rejected: $out" ;; esac
-
-# 2. Verify active — deregistered -> active is the transition setup guarantees.
-post=$(spt adapter list 2>&1)
-postline=$(printf '%s\n' "$post" | grep '^claude-spt:')
-case "$postline" in *active*) ok "verified: claude-spt is now active" ;; *) bad "claude-spt not active after re-activate ($postline)" ;; esac
-
-# 3. Profiles/strings went live with activation (the point of activating, not just registering).
-case "$post" in *claude-spt:ccs*) ok "shipped profile resolves post-activate: claude-spt:ccs" ;; *) bad "ccs profile not resolved post-activate" ;; esac
-lbl=$(spt adapter get-string claude-spt adapter_label 2>&1)
-[ "$lbl" = "Claude Code (spt)" ] && ok "strings live post-activate: adapter_label" || bad "adapter_label='$lbl'"
-
-[ "$fail" -eq 0 ] && { echo "SETUP-ACTIVATE-INT OK"; exit 0; } || { echo "SETUP-ACTIVATE-INT FAIL"; exit 1; }
diff --git a/ci/subnet/multi-subnet-bringup-int.sh b/ci/subnet/multi-subnet-bringup-int.sh
deleted file mode 100644
index 7077905..0000000
--- a/ci/subnet/multi-subnet-bringup-int.sh
+++ /dev/null
@@ -1,126 +0,0 @@
-#!/bin/sh
-# Validation for F-017 — the multi-subnet bringup gap, FIXED in spt-core v0.14.0 (the
-# endpoint-creation-flow milestone, REQ-RUN-MULTISUBNET-HOME / ADRs 0026-0027). This started life as
-# the W6 regression SEED that pinned the gap on <= 0.13.2; on v0.14.0 the expected outcomes FLIP from
-# "gap reproduces" to "fix confirmed". Still multi-subnet-gated (single-subnet auto-homes + never sees
-# any of this). Validates spt-core's REQ-RUN-MULTISUBNET-HOME (their registry, not ours) — kept
-# untagged here, like the original finding-repro seed.
-#
-# THE FIX (v0.14.0). `spt endpoint run` now HOMES an endpoint to one subnet at creation:
-#   - multi-subnet node, no --subnet, non-interactive  -> REFUSES clear (MULTI_SUBNET_HOME + the subnet
-#     list) INSTANTLY — replacing the old silent ~25s ENDPOINT_RUN_ONLINE_TIMEOUT (the F-017 gap).
-#   - --subnet <name>                                  -> homes there; the harness binds (UNBOUND ->
-#     ONLINE), no HOME_REFUSED.
-# The underlying home-assignment POLICY is unchanged + still correct: a NEW-endpoint `api bind` without
-# a home still HOME_REFUSEs (Case 2) — that policy is WHY `endpoint run` had to grow `--subnet`.
-#
-# Cases 1 & 2 are fast (a refuse + a bare bind probe, no harness spawn) and run on any multi-subnet
-# node. Case 3 is the full E2E of the fix: it spawns a REAL claude into a broker PTY (the daemon also
-# hosts a Psyche) and asserts the endpoint HOMES + BINDS (UNBOUND -> online) — gated behind
-# SPTC_ACCEPTANCE=1. All disposable, per-run-unique ids (REQ-HAZARD-PERCH-COLLISION — NEVER a live
-# agent's id); everything torn down on exit. Idempotent.
-# Run: sh ci/subnet/multi-subnet-bringup-int.sh                      (cases 1+2)
-#      SPTC_ACCEPTANCE=1 sh ci/subnet/multi-subnet-bringup-int.sh    (+ case 3 E2E)   exit 0 = pass.
-set -u
-ROOT=$(CDPATH= cd "$(dirname "$0")/../.." && pwd)
-A=claude-spt
-OWLERY="${LOCALAPPDATA:-$HOME/AppData/Local}/spt-core/owlery"
-
-command -v spt >/dev/null 2>&1 || { echo "SKIP: no spt on PATH"; exit 0; }
-
-# v0.14.0 is the carrying release (endpoint run gained --subnet + the MULTI_SUBNET_HOME refuse).
-if ! spt endpoint run --help 2>&1 | grep -q -- '--subnet'; then
-  echo "SKIP: spt 'endpoint run' has no --subnet (needs v0.14.0 — the F-017 fix). On <= 0.13.2 the gap is unfixed."; exit 0
-fi
-
-# Multi-subnet GATE — the fix (and the gap it replaced) is invisible on a single-subnet node.
-SUBNETS=$(spt endpoint list 2>/dev/null | grep -E '^SUBNET ' | awk '{print $2}')
-NSUB=$(printf '%s\n' "$SUBNETS" | grep -c .)
-if [ "${NSUB:-0}" -lt 2 ]; then
-  echo "SKIP: node holds ${NSUB:-0} subnet(s); F-017 only manifests on a multi-subnet node (>=2)"; exit 0
-fi
-HOME_SUB=$(printf '%s\n' "$SUBNETS" | head -1)
-echo "multi-subnet node: [$(printf '%s' "$SUBNETS" | tr '\n' ' ')] — home = $HOME_SUB"
-
-RUN=$$
-fail=0
-ok()  { echo "ok   $1"; }
-bad() { echo "FAIL $1"; fail=1; }
-
-MADE=""
-RUNPID=""
-cleanup() {
-  for id in $MADE; do spt endpoint purge "$id" --yes --force >/dev/null 2>&1 || true; done
-  [ -n "$RUNPID" ] && taskkill //PID "$RUNPID" //T //F >/dev/null 2>&1
-  if [ -n "${C3_ID:-}" ]; then
-    for p in $(wmic process where "name='claude-spt.exe' and commandline like '%$C3_ID%'" get processid 2>/dev/null | tr -dc '0-9 \n' | tr ' ' '\n' | grep -E '^[0-9]+$'); do
-      taskkill //PID "$p" //T //F >/dev/null 2>&1
-    done
-    spt endpoint shutdown "$C3_ID" >/dev/null 2>&1 || true
-    spt endpoint stop "$C3_ID" >/dev/null 2>&1 || true
-    spt endpoint purge "$C3_ID" --yes --force >/dev/null 2>&1 || true
-    rm -rf "$OWLERY/$C3_ID" >/dev/null 2>&1 || true
-  fi
-}
-trap cleanup EXIT INT TERM
-
-# ── Case 1 — THE FIX: spt-hosted `endpoint run` without --subnet REFUSES clear + INSTANTLY ────
-# (was the silent ~25s ENDPOINT_RUN_ONLINE_TIMEOUT). Non-interactive --start; expect no perch.
-C1_ID=f017fix-run-$RUN
-start=$(date +%s 2>/dev/null || echo 0)
-out=$(spt endpoint run --adapter "$A" --id "$C1_ID" --start 2>&1)
-end=$(date +%s 2>/dev/null || echo 0)
-case "$out" in
-  MULTI_SUBNET_HOME:*) ok "Case 1: endpoint run w/o --subnet -> MULTI_SUBNET_HOME refuse ([$out])" ;;
-  *ENDPOINT_RUN_STARTED*|*ENDPOINT_RUN:*) MADE="$MADE $C1_ID"; bad "Case 1: endpoint run w/o --subnet STARTED a bringup — should refuse on a multi-subnet node [$out]" ;;
-  *) bad "Case 1: unexpected endpoint-run result (expected MULTI_SUBNET_HOME): [$out]" ;;
-esac
-# The refuse must be IMMEDIATE — the gap it replaced was a ~25s hang. Allow generous slack (< 10s).
-if [ "$start" -gt 0 ] && [ "$end" -gt 0 ]; then
-  el=$((end - start))
-  [ "$el" -lt 10 ] && ok "Case 1: refuse was immediate (${el}s, not the old ~25s timeout)" \
-    || bad "Case 1: refuse took ${el}s — suspiciously close to the old ONLINE_TIMEOUT hang"
-fi
-[ -f "$OWLERY/$C1_ID/info.json" ] && { MADE="$MADE $C1_ID"; bad "Case 1: a perch was created despite the refuse"; } || ok "Case 1: no perch created (clean refuse, nothing to reap)"
-
-# ── Case 2 — underlying POLICY (unchanged): a NEW-endpoint bind needs a home ──────────────────
-C2_ID=f017fix-bind-$RUN
-out=$(spt api bind "$C2_ID" --set-session-id "sess-$RUN" 2>&1)
-case "$out" in
-  HOME_REFUSED:*) ok "Case 2a: bind w/o --subnet -> HOME_REFUSED (home-assignment policy intact) ([$out])" ;;
-  BOUND:*)        MADE="$MADE $C2_ID"; bad "Case 2a: bind w/o --subnet BOUND unexpectedly [$out]" ;;
-  *)              bad "Case 2a: unexpected bind result: [$out]" ;;
-esac
-out=$(spt api bind "$C2_ID" --set-session-id "sess-$RUN" --subnet "$HOME_SUB" 2>&1)
-case "$out" in
-  BOUND:*) MADE="$MADE $C2_ID"; ok "Case 2b: bind WITH --subnet $HOME_SUB -> BOUND ([$out])" ;;
-  *)       bad "Case 2b: bind WITH --subnet did not BIND: [$out]" ;;
-esac
-
-# ── Case 3 (E2E, gated) — `endpoint run --subnet` HOMES + the harness BINDS (UNBOUND -> online) ─
-if [ "${SPTC_ACCEPTANCE:-0}" = "1" ]; then
-  if spt adapter list 2>/dev/null | grep -q "$A"; then
-    C3_ID=f017fix-home-$RUN
-    runout=$(spt endpoint run --adapter "$A" --id "$C3_ID" --subnet "$HOME_SUB" --start 2>&1)
-    case "$runout" in
-      *ENDPOINT_RUN_STARTED*|*ENDPOINT_RUN:*) ok "Case 3: endpoint run --subnet $HOME_SUB STARTED ([$runout])" ;;
-      *) bad "Case 3: endpoint run --subnet did not start: [$runout]" ;;
-    esac
-    RUNPID=$(printf '%s' "$runout" | grep -oE 'pid=[0-9]+' | grep -oE '[0-9]+' | head -1)
-    # Poll ~40s for the harness to self-bind (UNBOUND -> bound/online). The gap = no perch ever bound.
-    bound=0
-    i=0; while [ "$i" -lt 20 ]; do
-      row=$(spt endpoint list 2>/dev/null | grep "$C3_ID" | head -1)
-      case "$row" in *alive=true*) bound=1; break ;; esac
-      sleep 2; i=$((i+1))
-    done
-    [ "$bound" -eq 1 ] && ok "Case 3: harness HOMED $HOME_SUB + BOUND (UNBOUND -> online, no HOME_REFUSED)" \
-      || bad "Case 3: endpoint never bound within ~40s (regressed to the no-perch gap?)"
-  else
-    echo "Case 3: SKIP (claude-spt not registered)"
-  fi
-else
-  echo "Case 3: SKIP (set SPTC_ACCEPTANCE=1 — spawns a real claude + Psyche, mutates perch state)"
-fi
-
-[ "$fail" -eq 0 ] && { echo "MULTI-SUBNET-BRINGUP-INT OK (F-017 fix confirmed on v0.14.0)"; exit 0; } || { echo "MULTI-SUBNET-BRINGUP-INT FAIL"; exit 1; }
diff --git a/docs-site/book.toml b/docs-site/book.toml
index 0f636e1..793fcff 100644
--- a/docs-site/book.toml
+++ b/docs-site/book.toml
@@ -1,9 +1,8 @@
-# mdBook config for the spt-claude-code docs-site. Built in CI, published to GitHub Pages from
-# THIS repo, drift-gated (docs/DOCS-STRATEGY.md). The shared experimplate theme is layered via
-# additional-css over the ayu theme (theme/theme.css). [impl->REQ-DOCS-SITE]
+# mdBook config for the native omp-spt docs site. Built in CI and published to GitHub Pages from
+# this repository. The shared theme is layered over ayu with theme/theme.css.
 [book]
-title = "claude-spt — Spacetime adapter for Claude Code"
-description = "Agent messaging, live agents, and an invisible spt-core installer, delivered as a Claude Code plugin."
+title = "omp-spt — Native Oh My Pi adapter for Spacetime"
+description = "Native OMP endpoints with Spacetime messaging, lifecycle, continuity, and live-agent roles."
 authors = ["perri"]
 src = "src"
 language = "en"
@@ -12,7 +11,7 @@ language = "en"
 default-theme = "ayu"
 preferred-dark-theme = "ayu"
 additional-css = ["theme/theme.css"]
-git-repository-url = "https://github.com/SaberMage/claude-spt"
+git-repository-url = "https://github.com/BigscreenVR/omp-spt"
 # Stable, never-renamed anchors (DOCS-STRATEGY #9): agents cache links.
 [output.html.fold]
 enable = false
diff --git a/docs-site/llms.txt b/docs-site/llms.txt
index 6707a8e..4d4b57d 100644
--- a/docs-site/llms.txt
+++ b/docs-site/llms.txt
@@ -1,9 +1,9 @@
-# claude-spt
+# omp-spt
 
-> Spacetime (spt) adapter for Claude Code: agent messaging, live agents, and an invisible spt-core installer, delivered as a Claude Code plugin. Built against spt-core's published public surface only.
+> Native Oh My Pi adapter for Spacetime (spt-core). Install one `adapter.spt` release from `BigscreenVR/omp-spt`, then host attachable `ReadyAgent` and `LiveAgent` endpoints in OMP's own TUI. No plugin is required.
 
 ## Docs
 
 - [Introduction](introduction.html)
 - [Quickstart](quickstart.html)
-- [Harness contract](reference/harness-contract.html)
+- [Native integration contract](reference/harness-contract.html)
diff --git a/docs-site/src/SUMMARY.md b/docs-site/src/SUMMARY.md
index 77a2228..e3df3fa 100644
--- a/docs-site/src/SUMMARY.md
+++ b/docs-site/src/SUMMARY.md
@@ -1,11 +1,11 @@
 <!-- The docs-site spine. Keep page order dependency-ordered (Rust Book logic): runnable first,
-     concepts next, reference last. Every entry must be a real, building page. [doc->REQ-DOCS-SITE] -->
+     concepts next, reference last. Every entry must be a real, building page. -->
 
-# claude-spt
+# omp-spt
 
 - [Introduction](./introduction.md)
 - [Quickstart](./quickstart.md)
 
 # Reference
 
-- [Harness contract](./reference/harness-contract.md)
+- [Native integration contract](./reference/harness-contract.md)
diff --git a/docs-site/src/introduction.md b/docs-site/src/introduction.md
index 20531a8..14e20ed 100644
--- a/docs-site/src/introduction.md
+++ b/docs-site/src/introduction.md
@@ -1,41 +1,52 @@
-<!-- [doc->REQ-DOCS-SITE] -->
 # Introduction
 
-`claude-spt` is the [Spacetime (`spt`)](https://sabermage.github.io/spt-releases) adapter for
-Claude Code. You install one Claude Code plugin — `sptc` — and get three things at once:
+`omp-spt` is the native [Oh My Pi](https://github.com/can1357/oh-my-pi) adapter for
+[Spacetime (`spt-core`)](https://sabermage.github.io/spt-releases). It gives named Spacetime
+endpoints a real OMP terminal session rather than translating OMP through another interface.
 
-- **Agent messaging and live agents** inside Claude Code: send messages between agents, run a
-  reachable "perch," and drive long-lived live-agent sessions, all delegated to the `spt` binary.
-- **An invisible `spt-core` installer.** The first time the plugin loads, it installs `spt-core`
-  for you if it is missing. No separate setup step.
-- **A casual on-ramp to spt-core.** The plugin is the friendly front door to the wider Spacetime
-  agent ecosystem — subnets, terminal hosting, seamless self-update — without leaving your editor.
+The adapter supports the two hostable agent roles that belong in an interactive OMP session:
+
+- **`ReadyAgent`** stays reachable for direct messages in its native OMP TUI.
+- **`LiveAgent`** uses the same native endpoint and also activates the live-agent Psyche lifecycle.
+
+There is no plugin installation step. Install OMP and `spt-core`, then install the
+`BigscreenVR/omp-spt` adapter release.
 
 ## Mental model
 
-Claude Code provides the **harness** (hooks, skills, your prompt). The `spt` binary provides the
-**core** (messaging, lifecycle, networking). `claude-spt` is the **thin adapter** between them: it
-maps Claude Code's hook events to the `spt` binary's harness-contract entry points and surfaces
-delivered messages back into your session.
+Three components share the work:
 
 ```text
-   Claude Code  ──hook events──▶   sptc adapter   ──spt api──▶   spt-core
-   (the harness)                  (this project)                (messaging,
-        ▲                          thin glue                     live agents,
-        └──────  additionalContext / skills  ◀── renders ◀────    networking)
+spt-core endpoint lifecycle
+        |
+        | launch, resume, attach
+        v
+native OMP process
+        |-- owns the broker PTY and attachable TUI
+        `-- loads adapter/strings/omp-spt.mjs
+                    |
+                    `-- bind, delivery, activity state, replies, shutdown
 ```
 
-Two ideas follow from that picture, and they shape everything else in these docs:
+- **`spt-core`** owns endpoint records, messaging, lifecycle coordination, subnet reachability,
+  adapter installation, and updates.
+- **Native OMP** owns the hosted process, interactive terminal, model turn, tools, and transcript.
+- **`omp-spt`** supplies the launch and transcript helpers plus the packaged OMP extension that
+  connects native OMP events to `spt-core`.
+
+The release artifact is one fat `adapter.spt` archive. It contains the supported adapter binaries,
+the manifest, and the shared `adapter/strings/omp-spt.mjs` extension, so installation and updates
+move as one unit.
+
+## What the extension does
 
-1. **The adapter is thin by design.** Logic and skill instructions live in the `spt` binary and
-   its adapter manifest (conducted by spt-core), not in the plugin. The plugin ships skeletons;
-   the operative content is delivered at run time. See
-   [Harness contract](./reference/harness-contract.md).
-2. **It is built against `spt-core`'s public surface only** — the published `spt-releases` binary,
-   install scripts, and docs. That constraint is the point: it proves the adapter contract is
-   buildable by anyone, from the published surface alone.
+When OMP starts a hosted session, the extension binds the OMP session id to the named Spacetime
+endpoint and starts message delivery. Incoming messages are queued into OMP turns. OMP's assistant
+response is sent back to the original sender, and the endpoint moves between busy and idle as the
+turn runs. When the TUI shuts down, the extension ends the bound session and releases its listener.
 
-## Status
+The result is still normal OMP. You attach to OMP's own TUI, and OMP remains in direct control of
+the broker PTY.
 
-This is an early, skeleton-honest build. Skills surface under the `/sptc:*` namespace; surfaces
-that are not yet operative say so in place. Start with the [Quickstart](./quickstart.md).
+Start with the [Quickstart](./quickstart.md). For event-by-event behavior, read the
+[Native integration contract](./reference/harness-contract.md).
diff --git a/docs-site/src/quickstart.md b/docs-site/src/quickstart.md
index 0a2933f..59ff7c4 100644
--- a/docs-site/src/quickstart.md
+++ b/docs-site/src/quickstart.md
@@ -1,53 +1,85 @@
-<!-- Sub-10-min, deterministic, no placeholders (DOCS-STRATEGY #1/#3). Every command is real and
-     runs as written. Skeleton-honest: it only claims what is operative today. [doc->REQ-DOCS-SITE] -->
+<!-- Sub-10-minute, deterministic bring-up (DOCS-STRATEGY #1/#3). Every command runs as written. -->
 # Quickstart
 
-Goal: install the `sptc` plugin, watch it bring up `spt-core` for you, and confirm your session is
-reachable — in under ten minutes. You need Claude Code and a shell (`bash` on macOS/Linux, Git Bash
-on Windows).
+Goal: install `omp-spt`, create a named endpoint, and attach to its native OMP TUI.
 
-## 1. Add the marketplace and install the plugin
+## 1. Install the prerequisites
 
-From Claude Code:
+You need [Oh My Pi](https://github.com/can1357/oh-my-pi) and
+[`spt-core`](https://sabermage.github.io/spt-releases). There is no plugin installation step.
 
-```text
-/plugin marketplace add SaberMage/cplugs
-/plugin install sptc@cplugs
+**PowerShell (Windows)**
+
+```powershell
+if (-not (Get-Command omp -ErrorAction SilentlyContinue)) { irm https://omp.sh/install.ps1 | iex }
+if (-not (Get-Command spt -ErrorAction SilentlyContinue)) { irm https://sabermage.github.io/spt-releases/install.ps1 | iex }
 ```
 
-Then **restart the Claude Code session** so the plugin's `SessionStart` hook runs and populates the
-session environment.
+**bash (macOS / Linux / Git Bash on Windows)**
 
-## 2. Let it install spt-core for you
+```bash
+command -v omp >/dev/null 2>&1 || curl -fsSL https://omp.sh/install | sh
+command -v spt >/dev/null 2>&1 || curl -fsSL https://sabermage.github.io/spt-releases/install.sh | sh
+```
 
-On that first start, the plugin's bootstrap installs `spt-core` if it is not already present —
-this is the invisible-installer step, nothing for you to run. Confirm it landed:
+Open a fresh shell if either installer updated your `PATH`, then verify both commands:
 
 ```bash
+omp --version
 spt --version
 ```
 
-If `spt` is not yet on your `PATH` in this shell, it was installed to `~/.local/bin/spt` (macOS /
-Linux) or `%LOCALAPPDATA%\spt-core\bin\spt.exe` (Windows); open a fresh shell and try again.
+`omp-spt` requires `spt-core` 0.29.0 or newer.
 
-## 3. Confirm your session is reachable
+## 2. Install the adapter
 
-Each Claude Code session resolves its own agent identity. Check it:
+```bash
+spt adapter add --release BigscreenVR/omp-spt
+```
+
+This installs one fat `adapter.spt` release. The archive includes the adapter binaries, manifest,
+and packaged OMP extension.
+
+## 3. Create and attach to an endpoint
+
+Choose a stable endpoint id. This example uses `librarian`:
 
 ```bash
-spt whoami
+spt endpoint run --adapter omp-spt --id librarian --create
 ```
 
-That prints this session's perch id (resolved from `$OWL_SESSION_ID` / `$SPT_AGENT_ID`). A printed
-id means the adapter wired your session into Spacetime's messaging fabric.
+For another name, use the canonical form
+`spt endpoint run --adapter omp-spt --id <id> --create` and replace `<id>`.
+
+The command launches OMP with `adapter/strings/omp-spt.mjs` and attaches your terminal directly to
+OMP's native TUI. Native attach is the default. `ReadyAgent` and `LiveAgent` are the supported
+hostable roles.
 
-## What works today, and what is coming
+During bring-up, the extension:
 
-This is an early build. The plumbing above — install, invisible `spt-core` bootstrap, identity —
-is operative now. The `/sptc:*` skills (send, ready, live, commune, and the rest) ship as
-**skeletons**: their operative instructions are delivered by the adapter at invocation time rather
-than baked into the plugin, and some are still being wired. Each skill says in place whether it is
-operative yet.
+1. binds the OMP session id to the Spacetime endpoint;
+2. marks the endpoint idle and starts delivery;
+3. submits each incoming message as an OMP turn;
+4. sends OMP's response to the original sender; and
+5. ends the binding when the native TUI shuts down.
+
+You now have a named endpoint in the standard Spacetime messaging and lifecycle model. Use the
+[`spt-core` documentation](https://sabermage.github.io/spt-releases) for endpoint rosters,
+messaging, subnets, and other public commands.
+
+## 4. Update later
+
+```bash
+spt adapter update omp-spt
+```
+
+OMP loads the packaged extension fresh on endpoint bring-up. Restart an already running endpoint
+to move it to the updated adapter:
+
+```bash
+spt endpoint stop librarian
+spt endpoint run --adapter omp-spt --id librarian
+```
 
-Next, read [Harness contract](./reference/harness-contract.md) to see exactly how Claude Code hook
-events map onto the `spt` binary.
+Next, read the [Native integration contract](./reference/harness-contract.md) for launch,
+delivery, reply, failure, and shutdown behavior.
diff --git a/docs-site/src/reference/harness-contract.md b/docs-site/src/reference/harness-contract.md
index a210143..ed3b96e 100644
--- a/docs-site/src/reference/harness-contract.md
+++ b/docs-site/src/reference/harness-contract.md
@@ -1,69 +1,89 @@
-<!-- Reference: the adapter's hook -> `spt api` mapping. Generated-from-truth target later; for now
-     hand-authored against tools/claude-spt/src/hook.rs. Keep in lockstep with hooks.json + hook.rs. [doc->REQ-DOCS-SITE] -->
-# Harness contract
-
-`claude-spt` is glue: it maps Claude Code **hook events** to the `spt` binary's harness-contract
-inbound surface (`spt api --adapter claude-spt <verb>`). The binary is harness-agnostic; this
-adapter is the Claude-Code-shaped edge of it.
-
-The authoritative contract lives on `spt-core`'s published surface — the
-[harness-contract + CLI reference](https://sabermage.github.io/spt-releases). This page documents
-the **adapter's** wiring: which Claude Code hook drives which `spt api` verb.
-
-## Hook → `spt api` mapping
-
-The plugin ships a **static** `hooks.json` that routes every Claude Code hook event through one thin
-wrapper, `hooks/dispatch.sh <EventName>`, which resolves the `claude-spt` program (from the adapter's
-`[strings].hook_cmd = "{adapter_dir}/claude-spt hook"`, looked up once per session) and runs
-`claude-spt hook <EventName>` with the Claude Code hook payload on stdin. The hook **logic lives in
-the program** — so it updates with `spt adapter update`, and the plugin's hook wiring stays fixed.
-
-| Claude Code hook   | handler                       | `spt api` verb (representative) | Purpose                                              |
-| ------------------ | ----------------------------- | ------------------------------- | --------------------------------------------------- |
-| `SessionStart`     | `claude-spt hook SessionStart`   | `seed` / `bind` / `boundary` | Bootstrap spt-core (via dispatch), register the perch (`bind` spt-hosted · `seed` harness-hosted · `boundary` on clear/compact), then relay an agent-facing brief (see below); non-blocking — never `listen`. |
-| `UserPromptSubmit` | `claude-spt hook UserPromptSubmit` | `state busy` + `poll`      | Mark the turn busy, drain delivered messages (incl. deferred) to the prompt as `additionalContext`, and inject a `/sptc:…` skill body when present. |
-| `PreToolUse`       | `claude-spt hook PreToolUse`     | `state busy` + `poll`        | Mid-turn delivery: drain messages deferred while busy so a live agent receives them *while working*. |
-| `Stop`             | `claude-spt hook Stop`           | `state` (idle)               | Mark the agent idle when a turn ends.               |
-| `SessionEnd`       | `claude-spt hook SessionEnd`     | `session-end`                | Tear down session state cleanly.                    |
-| `SubagentStart`    | `claude-spt hook SubagentStart`  | `worker-*`                   | Track a spawned subagent.                           |
-| `SubagentStop`     | `claude-spt hook SubagentStop`   | `worker-*`                   | Track subagent completion.                          |
-| `PostToolUse` (Write) | `claude-spt hook PostToolUse` | `state idle` + self-send     | Detect a `!!checkpoint!!` commune Write and self-send the agent-driven checkpoint signal (spt-hosted live agents). |
-
-## Two invariants the handler holds
-
-- **Payload comes from stdin, never from a `/`-leading argument.** On Windows under Git Bash /
-  MSYS, any argument beginning with `/` is silently rewritten to a Windows path. The dispatch wrapper
-  passes the payload straight through on **stdin** (its only argument is the event name) and the
-  program reads the Claude Code hook payload as JSON from stdin, so a `/sptc:…` token is never corrupted.
-- **Messages are self-delimiting `<EVENT>` envelopes.** `poll` output is rendered by splitting on
-  the canonical `<EVENT type="msg" from="…">body</EVENT>` envelope, so a multi-message drain parses
-  cleanly and each message keeps its sender for reply-correlation.
-
-## Identity
-
-Every session resolves its own perch id via `spt whoami`, off `$OWL_SESSION_ID` / `$SPT_AGENT_ID`.
-A session with no perch (never made reachable) simply delivers nothing — the per-prompt drain
-no-ops rather than erroring.
-
-## SessionStart briefs
-
-`SessionStart` also relays an **agent-facing brief** as `additionalContext`, composed from the
-adapter's `[strings.briefs]` (same file-backed/inline machinery as `[strings.skills]`). The hook
-only selects + composes + `{id}`-substitutes — it never authors the prose.
-
-| session state | trigger | brief |
-| --- | --- | --- |
-| has a perch | `bind` (`$SPT_ENDPOINT_ID`) or `boundary` (clear/compact) | **identity brief** — who it is (`{id}`), that its perch is already live (don't re-arm → `COLLISION`), and how to message (`spt send` + reply + the `spt endpoint list` roster). |
-| no perch, node has subnet peers | `seed` / fresh startup | **ring brief** — how to reach other agents without a perch (`spt ring <target> --timeout 60`) + the roster. |
-| no perch and no peers · subagent (`agent_type` set) | — | nothing. |
-
-The brief is **liveness-agnostic** (no live-vs-ready distinction) pending a published machine-readable
-liveness query on the spt surface. The peer gate is a line-count presence check on `spt subnet
-status` — it never parses the human-formatted column values.
-
-<!-- [doc->REQ-DIST-SESSIONSTART-BRIEF] -->
-
-> The operative skill instructions are **not** in this plugin. They are delivered by the adapter
-> manifest (conducted by spt-core) at invocation time; the `/sptc:*` `SKILL.md` files are
-> deliberately thin skeletons. This split keeps the marketplace artifact low-churn while logic and
-> instructions update through spt-core's signed adapter-update channel.
+<!-- Reference: native OMP ownership and the packaged extension lifecycle.
+     Keep in lockstep with adapter/omp-spt.toml and adapter/strings/omp-spt.mjs. -->
+# Native integration contract
+
+`omp-spt` hosts Spacetime endpoints as native Oh My Pi sessions. The authoritative generic
+adapter and CLI contract remains the
+[`spt-core` public documentation](https://sabermage.github.io/spt-releases). This page describes
+the OMP-specific ownership boundary and lifecycle.
+
+## Ownership boundary
+
+| Component | Owns |
+| --- | --- |
+| `spt-core` | Endpoint records, adapter resolution, messaging, subnet reachability, lifecycle coordination, and release updates. |
+| Native OMP | The broker PTY, attachable TUI, interactive agent turns, tools, and transcript. |
+| `omp-spt` launch helper | Locating and validating the real OMP executable, then starting or resuming OMP with the packaged extension. |
+| `adapter/strings/omp-spt.mjs` | Binding, delivery, activity state, reply correlation, listener recovery, and session shutdown inside OMP. |
+| `omp-spt` transcript helpers | Per-session history, digest extraction, end-of-session commune summaries, and LiveAgent Psyche turns. |
+
+This separation is deliberate. The launch helper gets out of the hosted process path after starting
+OMP, while OMP remains in direct control of the terminal.
+
+## Install and launch
+
+Install the release:
+
+```bash
+spt adapter add --release BigscreenVR/omp-spt
+```
+
+Create a named endpoint and attach:
+
+```bash
+spt endpoint run --adapter omp-spt --id librarian --create
+```
+
+The canonical form is `spt endpoint run --adapter omp-spt --id <id> --create`. Native attach is the
+default. The command needs no separate start flag.
+
+For a fresh endpoint, the resolved manifest starts the launch helper with the packaged extension.
+For an existing endpoint, the resume path selects the recorded OMP session and loads the same
+extension. Both paths leave the user in OMP's native TUI.
+
+## Extension lifecycle
+
+The extension receives the endpoint id from `spt-core` and responds to native OMP events:
+
+| OMP lifecycle point | Adapter action |
+| --- | --- |
+| Session start | Bind the endpoint to OMP's session id, retain the returned authentication token, mark the endpoint idle, and start its delivery listener. |
+| Incoming Spacetime message | Parse the self-delimiting message envelope, retain its sender, queue it, and submit it to OMP when no other agent turn is active. |
+| Context assembly | Preserve the complete message envelope in the OMP turn so sender and body remain available to the model. |
+| Agent start | Mark the endpoint busy. |
+| Agent end | Extract the assistant response after the delivered message, send it to the original sender from this endpoint id, mark the endpoint idle, and dispatch the next queued message. |
+| Session shutdown | Stop delivery and retry timers, return a failure outcome for pending messages, end the bound session, and clear the OMP status indicator. |
+
+Messages are processed one at a time in arrival order. A message received during an active turn
+waits in the extension queue rather than interrupting that turn. Every outcome is correlated with
+the sender carried by its original Spacetime envelope.
+
+## Identity and continuity
+
+One hosted TUI has one immutable endpoint and OMP session identity. The extension blocks in-TUI
+session switches while the Spacetime endpoint is active. End the hosted endpoint first when you
+want to select a different OMP session.
+
+`ReadyAgent` and `LiveAgent` use the same native OMP endpoint and extension. `LiveAgent` also
+activates the per-event Psyche role; `ReadyAgent` does not. History and digests are fetched from the
+JSONL transcript for the bound OMP session.
+
+## Failure behavior
+
+Delivery listener exits are retried with bounded backoff. If binding fails or the listener exhausts
+its restart budget, the adapter fails closed: it reports the problem in the OMP TUI, returns failure
+outcomes for pending messages, ends the Spacetime session, and shuts down the hosted TUI. A
+half-bound endpoint is never presented as healthy.
+
+## Updates and packaging
+
+Each release is one fat `adapter.spt` archive containing the supported adapter binaries and the
+shared `adapter/strings/omp-spt.mjs` extension. Update it with:
+
+```bash
+spt adapter update omp-spt
+```
+
+New endpoint bring-ups load the updated extension. A running endpoint keeps its current hosting
+path until it is restarted with `spt endpoint stop <id>` followed by
+`spt endpoint run --adapter omp-spt --id <id>`.
diff --git a/docs/CI.md b/docs/CI.md
index 3e11ec4..7e95bcb 100644
--- a/docs/CI.md
+++ b/docs/CI.md
@@ -1,95 +1,103 @@
-# CI model — agent-driven, autonomous, no-LLM-in-the-loop
-
-> spt-claude-code's CI is **wholly agent-driven and autonomous** on the existing Windows +
-> Linux fleet (hfenduleam + kitsubito). **GitHub-hosted runners are NOT used** — a stock
-> hosted runner physically can't run Claude Code (auth + interactivity), so only a real
-> harness on the fleet reaches the acceptance bar. **Deterministic gates** run by a fleet
-> runner-agent, triggered by a git post-push hook, reporting over **spt messaging**. No LLM
-> sits in the gate path — the gates are plain scripts; the "agent" is just the autonomous
-> runner that fires them and reports.
-
-## The gates (deterministic)
-<!-- [doc->REQ-CI-GATES] -->
-<!-- [doc->REQ-CI-OWL-DISCOVERY] -->
-<!-- [doc->REQ-CI-MANUAL] -->
-<!-- [doc->REQ-CI-TRIGGER] -->
-<!-- [doc->REQ-CI-BUS] -->
-<!-- [doc->REQ-CI-ACCEPTANCE] -->
-
-Every gate is a script with a binary pass / fail — no judgment, no model:
-
-1. **Build** — the project assembles clean.
-2. **Unit tests** — the suite passes.
-3. **`traceable-reqs check`** — requirement coverage gate; exit-1 fails the build (see
-   `docs/TRACEABILITY.md`).
-4. **Manifest-schema** — the CC adapter manifest validates against spt-core's **published**
-   `manifest.schema.json` (from `SaberMage/spt-releases`).
-5. **Docs-drift** — generated docs (API reference, `llms.txt`, schema, CLI help) are regenerated
-   and must match what's checked in; a diff fails (see `docs/DOCS-STRATEGY.md`).
-
-## Acceptance (the system-under-test is a real `claude` session)
-
-Acceptance is **scripted orchestration that spawns real `claude` / headless sessions as the
-system-under-test**, then asserts spt-state / `[digest]` output. The **LLM is the SUT, never
-the runner** — the orchestration is deterministic; only the thing it drives is a real harness.
-This is what a stock hosted runner can't do, and why the fleet is mandatory. (spt-core's
-GH-runner justification — heavy multi-platform Rust + signed releases + two-host net — does
-not carry here: the adapter binary is thin glue and delegates releases/signing to `spt`.)
-
-**Disposable-identity invariant (mandatory).** Every nested `claude` the harness spawns runs
-under a **throwaway perch id** (`SPT_AGENT_ID=sptc-ci-<n>`), never a live agent's name. A nested
-session that resolves a live id establishes a perch under that name and — perches being
-name-keyed, last-establish-wins — **tears down the live agent's perch and poll stream** (the
-self-inflicted collision diagnosed 2026-06-15; see `docs/KNOWN-HAZARDS.md` §2.1 /
-`REQ-HAZARD-PERCH-COLLISION`). `ci/acceptance/lib.sh` `sptc_ci_identity` enforces it.
-
-**Slice 1** (`ci/acceptance/run-acceptance.sh`) asserts a real `claude` **fires the
-UserPromptSubmit hook** via a hook-written digest marker — the harness-contract entry point
-working inside a real harness — independent of the spt bus or model text. It is **env-gated**
-(`SPTC_ACCEPTANCE=1`) so the deterministic gate run stays green on hosts without `claude`/auth.
-Bus-delivery acceptance (poll→additionalContext over real spt) is a later slice, gated on
-`REQ-MSG-ENVELOPE`.
-
-## Reporting bus = spt messaging (dogfood)
-
-The reporting bus is **legacy spt** (`$OWL send`): the runner reports gate/acceptance results
-over spt messaging to the responsible agent / channel. This dogfoods the product as its own CI
-nervous system.
-
-## Trigger: git push hook → ping a runner-agent over spt
-
-The trigger is **push-driven, not polling** (polling adds latency and wastes cycles).
-
-> **Implemented as `pre-push`, by design — not a deviation.** Git has **no client-side
-> `post-push` hook**; the only push-time client trigger is `pre-push` (a true post-receive lives
-> server-side, which the autonomous fleet is not). SCOPE's "post-push" is loose wording for
-> "push-driven." The hook (`ci/git-hooks/pre-push`) is non-fatal: a missing bus or unset runner
-> never blocks the push. (Confirmed correct by doyle, 2026-06-15.)
-
-1. The **git `pre-push` hook** fires at push time.
-2. The hook **`$OWL send`s a one-line "run gates for `<ref>`" message** to a fleet runner-agent
-   over spt messaging.
-3. The runner-agent **runs the deterministic gates** (and acceptance) on the fleet.
-4. The runner **reports the result back over spt** to the responsible agent / channel.
-
-### Discovering the `$OWL send` (spt messaging) binary robustly
-
-The bus binary's path **changes between versions** — legacy spt lives in a per-version
-`~/.claude/` or `~/.ccs/` plugins folder whose path moves each release. No further
-legacy-spt changes are anticipated, but the hook and runner **must locate it robustly**:
-resolve it at run time (search the known plugins/install roots / a configured path / `PATH`)
-rather than hard-coding a versioned location. A stale hard-coded path is the most likely cause
-of a silently dead trigger.
-
-## Manual fallback
-
-A **manual "run gates" command** must always exist — the same gate scripts, runnable by hand on
-any fleet host. Use it when the hook didn't fire, when reproducing a failure, or before a hook is
-wired at all.
-
-## Hosted-runner workflow (not used here)
-
-A hosted CI workflow (e.g. GitHub Actions) is **explicitly dropped** for this project: it can't
-run the real-harness acceptance bar. `docs/TRACEABILITY.md` carries a ready GitHub Actions
-snippet for the pure-deterministic `traceable-reqs check` gate if a hosted fallback is ever
-wanted, but the agent-driven fleet pattern is the primary and intended path.
+# CI and release acceptance
+
+`omp-spt` uses two verification layers:
+
+1. deterministic gates that run on every change; and
+2. release acceptance against a real native OMP endpoint.
+
+The first layer is repeatable and does not require a live model session. The second proves the user-visible hosting contract that deterministic tests cannot establish. A deterministic pass is necessary, but it is not release acceptance.
+
+## Deterministic gates
+
+Run these from the repository root:
+
+```sh
+sh tests/ci-gates.sh
+sh ci/run-gates.sh
+node tests/omp-extension.mjs
+```
+
+`tests/ci-gates.sh` guards the gate dispatcher itself. `ci/run-gates.sh` performs shell-syntax checks, validates `adapter/omp-spt.toml` against the vendored published schema, checks the native launch and session manifest, tests the fat archive contract, and runs the `omp-spt` helper's Rust tests and release build. It also runs `traceable-reqs check` when the command is installed. `tests/omp-extension.mjs` exercises extension delivery, serialized custody, correlated outcomes, busy/idle transitions, listener failure handling, immutable session binding, and shutdown.
+
+<!-- [doc->REQ-OMP-NATIVE-TUI] -->
+<!-- [doc->REQ-OMP-EXTENSION-CUSTODY] -->
+<!-- [doc->REQ-OMP-LISTENER-FAIL-CLOSED] -->
+<!-- [doc->REQ-OMP-SESSION-IMMUTABLE] -->
+<!-- [doc->REQ-OMP-MESSAGE-CONTEXT] -->
+<!-- [doc->REQ-OMP-READY-LIVE] -->
+
+These are binary pass/fail checks. A release run must treat any `SKIP` caused by a missing interpreter, Rust toolchain, platform binary, or `traceable-reqs` installation as an incomplete gate, provision the dependency, and rerun. The archive test may intentionally prove that the packer refuses missing platform binaries, but a release still needs both platform builds before packaging.
+
+## Native OMP release acceptance
+
+ADR-0013 sets the release boundary. Acceptance must use the exact candidate `adapter.spt`, a real `omp` installation, the native packaged extension, and disposable endpoint identities on one node. Do not reuse an operator's long-lived endpoint id.
+
+Install the tagged candidate on the acceptance node:
+
+```sh
+spt adapter add --release BigscreenVR/omp-spt --tag vX.Y.Z
+```
+
+Then record evidence for every item below.
+
+### 1. Fresh bringup and attached TUI
+
+```sh
+spt endpoint run --adapter omp-spt --id omp-spt-accept-fresh --create
+```
+
+The default action attaches the terminal. Pass only if the broker-held terminal displays the real interactive OMP TUI, the packaged `adapter/strings/omp-spt.mjs` extension binds `omp-spt-accept-fresh`, and the endpoint becomes reachable. Do not add a background-start flag: the attached native TUI is part of this proof.
+
+### 2. Same-node message, turn, correlated reply, and state
+
+From a second terminal on the same node:
+
+```sh
+printf 'Reply with exactly OMP-SPT-ACCEPTED after reading this message.' |
+  spt ring omp-spt-accept-fresh --timeout 120
+```
+
+Pass only if:
+
+- the delivery becomes one ordinary OMP user turn containing the sender stub and complete SPT event context;
+- the TUI visibly runs that turn;
+- `spt ring` prints the assistant's reply for that request, proving sender correlation; and
+- `spt endpoint list --json` shows the endpoint move from idle to busy for the turn and back to idle after the reply.
+
+This is an end-to-end custody check, not a check for model wording alone. A rejection or turn failure must return an explicit failure outcome to the sender rather than silently dropping the request.
+
+### 3. Immutable in-TUI binding and native resume
+
+Record the bound OMP session id. While the endpoint is running, attempt OMP's in-TUI new-session and resume/switch actions. Both must be blocked with an `omp-spt` warning, and the bound session id must remain unchanged.
+
+End the endpoint gracefully, then bind a new disposable endpoint explicitly to the recorded OMP session:
+
+```sh
+spt endpoint shutdown omp-spt-accept-fresh
+spt endpoint run --adapter omp-spt --id omp-spt-accept-resume --resume <omp-session-id>
+```
+
+Pass only if this launches OMP's native resume path into an attached TUI, preserves the prior transcript, and binds the new endpoint to the requested session. In-TUI switching stays blocked after resume. Native resume happens at endpoint launch, never by moving a running endpoint to another session.
+
+### 4. ReadyAgent and LiveAgent
+
+Exercise both hostable roles through spt-core's current ReadyAgent and LiveAgent flows:
+
+- **ReadyAgent:** the native OMP endpoint binds, listens, receives a same-node request, replies, and shuts down without requiring a daemon-driven Psyche turn.
+- **LiveAgent:** the same native OMP hosting path remains attached and reachable while the daemon drives the manifest's bounded `psyche-omp` role; a Psyche event completes successfully, and normal message/turn/reply behavior still works afterward.
+
+Pass only if `omp-spt` advertises exactly ReadyAgent and LiveAgent and both use the native OMP endpoint. A Worker or an alternate hosting process is not an accepted adapter role.
+
+### 5. Graceful shutdown
+
+```sh
+spt endpoint shutdown omp-spt-accept-resume
+```
+
+Pass only if the extension ends the SPT session, reaps its listener, clears its TUI status, and the endpoint is no longer advertised as online. There must be no false-online endpoint and no orphaned acceptance process.
+
+## Adapter release boundary
+
+Cross-node transport is outside the `omp-spt` release gate. Once the exact message contract succeeds through the adapter on one node, subnet routing adds no OMP-specific seam and belongs to spt-core. A cross-node check may be useful for spt-core qualification, but it must not replace or block the same-node adapter acceptance above.
+
+Release evidence must identify the candidate tag and asset, OMP and spt-core versions, disposable endpoint ids, fresh and resumed OMP session ids, gate outputs, state transitions, correlated reply, both role outcomes, and final shutdown result.
diff --git a/docs/DOCS-STRATEGY.md b/docs/DOCS-STRATEGY.md
index d55bd83..c75f34f 100644
--- a/docs/DOCS-STRATEGY.md
+++ b/docs/DOCS-STRATEGY.md
@@ -1,105 +1,217 @@
 # Documentation strategy
 
-> A **designed-in commitment**, not an afterthought — grounded in research on
-> critically-acclaimed developer docs (Stripe, Twilio, the Rust Book, FastAPI, Cloudflare,
-> Anthropic, Diátaxis, `llms.txt`, the Google developer style guide). Governs the **shipped
-> product docs** (authored as code lands). The planning docs (CONTEXT / ADRs / design docs) are
-> internal and separate.
->
-> **Where the docs live (the reframe):** docs live in **this same repo** under `docs-site/`.
-> CI builds them with **mdBook** and **publishes to GitHub Pages from this repo**, gated against
-> drift. (No separate releases/publish repo — source of truth and published site are one repo.)
-
-## The defining constraint: a dual audience
-
-These docs serve **two readers at once** — human developers *and* the **AI dev-agents that
-build on or integrate with this project**. This is the design constraint: every artifact is
-authored **once in clean markdown** and served in **two depths** (human-rendered + agent-export).
-The agent layer is **first-class, not optional** — make it so good that a dev-agent integrates
-correctly on the first try.
-
-## Principles (top techniques, prioritized)
-
-1. **Sub-10-minute killer quickstart** — runnable, deterministic, whole-working-thing-first, no
-   placeholders. Time-to-first-hello-world is the single most-cited conversion lever.
-2. **Diátaxis four-mode separation** — tutorial / how-to / reference / explanation, never mixed
-   (mixing is the most-cited cause of confusing docs).
-3. **Deterministic, real, copy-pasteable examples everywhere** — no `<YOUR_VALUE_HERE>`
-   placeholders; real values that run. Serves humans *and* agents.
-4. **Dual-depth agent exports** — `llms.txt` (slim curated index) + `llms-full.txt` (full
-   concatenated export), auto-generated in CI, plus markdown content negotiation (a `.md` suffix
-   alongside each `.html`, or `Accept: text/markdown`) which cuts agent token use ~90% vs HTML.
-5. **One canonical way to do X** — explicitly mark deprecated / alternate paths. Non-determinism
-   is fatal for agents.
-6. **Complete reference, auto-generated, all error variants** — generate API reference from the
-   code for your public surface, plus any machine-readable contract/schema. Generic placeholders
-   in reference are a failure mode.
-7. **Consistent conversational voice** — adopt the Google developer style guide: second person
-   ("you"), active voice, knowledgeable-friend tone.
-8. **Explain *why*, not just *what*** — conceptual docs + diagrams for the project's core model
-   and state machines.
-9. **Stable, never-renamed anchors / URLs** — agents cache links.
-10. **Docs-as-product, gated in CI** — generation (API reference, `llms.txt`, schema, CLI help)
-    is part of the build so docs can never drift from code. Drift is the #1 most-cited docs
-    failure; this kills it structurally.
-    <!-- [doc->REQ-DOCS-DRIFT] The drift gate (ci/docs/check-docs.sh) regenerates llms.txt
-         deterministically and fails the build on any diff vs the committed file; the book must
-         also build. This is the structural anti-drift commitment, enforced in run-gates. -->
-
-## Information architecture — by capability vertical
-
-Organize by capability, each vertical carrying the same four Diátaxis modes internally (the
-Cloudflare pattern):
-
-**The `/spt:*` skills · `/spt:setup` · the `cc` launcher · ccs profiles · subnet setup · the
-`[digest]` extractor.**
-
-> **Authoring the `/sptc:*` skills themselves** — the two-surface shape (thin plugin skeleton +
-> UPS-injected adapter body), templates, and the lean-by-default rules — lives in
-> [`SKILL-AUTHORING.md`](SKILL-AUTHORING.md).
-
-Global sequence (Rust Book logic): early runnable project → dependency-ordered concepts →
-capstone last. Per-vertical internal template (Django labels × Cloudflare ordering):
-`Overview (why + diagram) · Quickstart/Tutorial · How-to guides · Reference (generated) ·
-llms.txt`.
-
-## Killer quickstart targets
-
-Define one per audience — e.g. a **human dev** quickstart (the core primitive end-to-end in one
-command + minimal config, < 10 min, whole-thing-first then decomposed) and, if you have
-integrators, a **dev-agent integrator** quickstart (the minimal "build against this" hello-world
-for `<your integration surface>`). Zero placeholders; every value runs.
+> Public documentation is part of the shipped `omp-spt` product. Source lives in this repository
+> under `docs-site/`, mdBook renders it, and GitHub Pages publishes it from the same source of
+> truth. Planning records, ADRs, and contributor design notes remain separate from the public
+> learning path.
+
+## Audience and product boundary
+
+The documentation serves human operators and development agents integrating with
+[`BigscreenVR/omp-spt`](https://github.com/BigscreenVR/omp-spt). Author each fact once in clean
+Markdown, then make it available at two depths:
+
+- a navigable, human-rendered site; and
+- compact agent exports with stable links and the same canonical commands.
+
+The documented product is the native Oh My Pi adapter. OMP owns the hosted interactive session
+and TUI, spt-core owns endpoint orchestration and transport, and the packaged OMP extension joins
+those public contracts inside the native session. Do not document alternate harness paths under
+the `omp-spt` identity.
+
+## Principles
+
+1. **Get to a working native endpoint in under ten minutes.** The first tutorial installs the
+   adapter, launches OMP, and reaches the native TUI before explaining internals.
+2. **Keep Diátaxis modes separate.** Tutorials teach, how-to guides solve a task, reference states
+   exact contracts, and explanation pages develop the mental model.
+3. **Use deterministic, copy-pasteable examples.** Commands use `omp-spt`,
+   `BigscreenVR/omp-spt`, and concrete endpoint IDs such as `atlas`. Avoid placeholder-only
+   examples and hidden prerequisites.
+4. **Give one canonical path for each task.** Clearly label historical or alternative material
+   as non-current. Human readers and agents should make the same choice from the same page.
+5. **Document public surfaces, not private implementation details.** Link to the published
+   spt-core CLI and manifest reference for core semantics. Explain only the adapter behavior that
+   `omp-spt` owns.
+6. **Make reference complete.** Cover commands, manifest fields, extension-owned behavior,
+   lifecycle transitions, failure outcomes, archive contents, and supported release checks.
+7. **Write to the reader.** Use second person, active voice, short sentences, and exact nouns.
+8. **Explain ownership and invariants.** Readers need to know why OMP keeps the TUI, why one
+   endpoint keeps one session, and where spt-core takes over.
+9. **Keep anchors and URLs stable.** Redirect renamed pages and preserve durable section IDs when
+   their contracts still exist.
+10. **Gate documentation drift in CI.** Generated reference, agent exports, CLI snapshots, and
+    the mdBook build must be reproducible and checked against committed output.
+
+## Information architecture
+
+Order the public site by the user's journey. Put a runnable success first, then concepts in
+dependency order, then complete reference.
+
+### 1. Start here
+
+- **Introduction:** what `omp-spt` does and the OMP / spt-core ownership boundary.
+- **Requirements:** supported spt-core floor, supported hosts, and an installed native OMP.
+- **Quickstart:** install the release adapter, create endpoint `atlas`, and attach to its native
+  TUI.
+
+### 2. Install and update
+
+- Install from the `BigscreenVR/omp-spt` GitHub release.
+- Explain that the default release asset is one multi-platform `adapter.spt`.
+- Update the registered adapter and restart an endpoint when it must pick up the new hosting
+  payload.
+- Troubleshoot registration, version-floor, archive-selection, and executable-resolution errors.
+
+### 3. Run native OMP endpoints
+
+- Create and launch a fresh endpoint.
+- Attach to, detach from, stop, and relaunch the broker-held native TUI.
+- Resume an existing OMP session through endpoint launch.
+- Explain the immutable binding: one SPT endpoint owns one OMP session for its lifetime, so a
+  different session requires a stop and explicit relaunch.
+
+### 4. Use hostable roles
+
+- Describe `ReadyAgent` and `LiveAgent` as the only hostable roles.
+- Show how both roles use the same native OMP endpoint.
+- Explain the daemon-driven Psyche behavior that distinguishes `LiveAgent`.
+- State why OMP subagents are not advertised as separately hostable endpoints.
+
+### 5. Message an endpoint
+
+- Use the public spt-core send and roster surfaces.
+- Trace one inbound message through serialized extension delivery, one OMP turn, and the
+  correlated reply to its sender.
+- Document busy and idle activity, queued delivery, explicit failure replies, listener recovery,
+  fail-closed shutdown, and graceful session end.
+
+### 6. Preserve continuity and inspect records
+
+- Explain commune and signoff drops in project-local `.spt/`.
+- Document endpoint-qualified continuity filenames without treating them as OMP configuration.
+- Show the difference between opaque single-session history and the bounded digest view.
+- Keep resume, continuity, history, and digest examples tied to the same immutable session ID.
+
+### 7. Adapter and release reference
+
+- Manifest reference for `[adapter]`, `[update]`, `[identity]`, `[session]`, `[history]`,
+  `[digest]`, environment injection, and shared strings.
+- Extension reference for bind, message custody, context injection, correlated replies,
+  activity, session-switch refusal, recovery, and shutdown.
+- `adapter.spt` reference for the root manifest, `strings/omp-spt.mjs`, and supported host
+  binaries.
+- Release verification checklist and the explicit adapter / spt-core boundary.
+
+Each major capability can use the same internal sequence when it needs more than one page:
+`Overview -> Tutorial -> How-to -> Reference -> Explanation`. Do not force all five page types
+when one concise page is clearer.
+
+## Canonical quickstart examples
+
+Install the adapter from its release repository:
+
+```bash
+spt adapter add --release BigscreenVR/omp-spt
+```
+
+Create and launch a native endpoint:
+
+```bash
+spt endpoint run --adapter omp-spt --id atlas --create
+```
+
+Attach to the same native OMP TUI from another terminal:
+
+```bash
+spt rc atlas
+```
+
+Update the installed adapter:
+
+```bash
+spt adapter update omp-spt
+```
+
+These are the canonical names and command shapes. Endpoint launch uses native attach behavior;
+examples must not introduce a separate start switch.
+
+A native-resume tutorial must obtain a real OMP session ID in a preceding step and use it
+consistently for launch, history, digest, and continuity examples. Do not publish a fake reusable
+session ID that can never resolve on the reader's machine.
+
+## Native extension documentation
+
+Describe `adapter/strings/omp-spt.mjs` by observable responsibility:
+
+1. OMP starts natively in the terminal held by spt-core.
+2. The extension binds the OMP session to the endpoint ID supplied by spt-core.
+3. It receives SPT events, serializes them, and submits each through OMP's message API.
+4. It preserves the full event envelope as context and sends the completed assistant response
+   back to that event's sender.
+5. It reports busy and idle state, blocks in-TUI session changes, retries listener loss within a
+   bounded budget, and ends the SPT session on shutdown or unrecoverable delivery loss.
+
+Keep network routing, subnet transport, terminal custody, and adapter registry behavior in the
+spt-core ownership column. Keep model turns, transcript identity, and TUI behavior in the OMP
+ownership column. The extension page explains only the seam between them.
+
+## Release artifact documentation
+
+`adapter.spt` is the only public adapter release artifact. Document it as a fat archive that
+contains:
+
+- `manifest.toml` at the archive root;
+- shared `strings/omp-spt.mjs`; and
+- the `omp-spt` binary for each supported host target.
+
+spt-core selects and flattens the matching host payload during install. Public install and update
+guides should use the release repository, never require readers to unpack the archive or place the
+adapter binary on `PATH`.
+
+## Public spt-core references
+
+Treat the published spt-core documentation and CLI help as authoritative for:
+
+- adapter installation, update, and manifest semantics;
+- endpoint create, run, attach, stop, list, resume selection, history, and digest;
+- send, ready, message envelopes, correlated sender identity, and activity state;
+- daemon role hosting, terminal custody, subnets, and transport.
+
+The `omp-spt` docs should show how those surfaces apply to native OMP and link upstream for their
+full generic contract. If the published surface cannot express a required adapter behavior,
+record a product gap instead of teaching an internal command or storage layout.
 
 ## Agent-consumable docs
 
-- **`llms.txt` / `llms-full.txt`** — auto-emitted in CI; the slim index answers quick questions,
-  the full export feeds deep ingestion. Two-level (Cloudflare pattern): a curated root index that
-  fans out to per-vertical `llms.txt`; `llms-full.txt` is CI-concatenated page bodies
-  (generation-only, never hand-authored).
-- **Markdown content negotiation** + deterministic include/exclude tags so agent exports carry
-  the canonical path and drop human-only narrative.
-- **Machine-readable contract/schema** (e.g. JSON Schema) at a stable, discoverable path, if your
-  project has one — the schema *is* documentation.
-- **CLI help as first-class agent docs**, if you ship a CLI — `<cmd> --help` complete, exampled,
-  and ideally machine-readable (a `--json` / structured help mode). The CLI surface is a
-  documentation surface.
-
-## Site generator: mdBook + custom theme CSS
-
-**mdBook** is the generator. The **shared theme** lives in `docs-site/theme/` (a
-Starlight-inspired skin reused across consumer projects — re-point the accent to rebrand);
-**Astro Starlight is the styling north star** (copy its look / feel in the theme CSS, not its
-toolchain). Raw `.md` is published alongside each rendered page (`/x.html` ↔ `/x.md`) for the
-agent-export convention; `llms.txt` / `llms-full.txt` / any schema are static assets at site root.
-
-## CI commitments
-
-Generated reference, the schema, `llms.txt` / `llms-full.txt`, and CLI help exports are
-**generated and checked in CI** — a doc-drift gate. The mdBook build + GitHub Pages publish run
-in the same pipeline. Doc quality lives on the same footing as tests.
-
-## Anti-patterns to design against (most-cited failures)
-
-Doc / code drift (#1 — solved by CI gating); *what* without *why*; too much setup before first
-success; generic placeholders in reference; mixed Diátaxis modes; poor search / navigation;
-multiple non-canonical ways to do X (fatal for agents).
+- **`llms.txt`:** a curated, low-token index to the quickstart and capability pages.
+- **`llms-full.txt`:** a CI-generated concatenation of canonical page bodies for deep ingestion.
+- **Raw Markdown:** publish a `.md` peer for each rendered `.html` page, or serve
+  `text/markdown` through content negotiation.
+- **Machine-readable contracts:** publish generated manifest/schema material at stable paths.
+- **CLI help snapshots:** include complete public command help and failure variants where the
+  upstream tooling exposes them.
+
+Generated exports are build output. Never hand-edit them independently of their source pages.
+
+## Site and CI commitments
+
+mdBook remains the site generator. The theme lives in `docs-site/theme/`; raw Markdown, agent
+exports, and machine-readable contracts publish beside the rendered book.
+
+CI must build the book and regenerate every checked-in export. Release verification is layered:
+
+- On every change, run deterministic extension, manifest, session, digest/history, and
+  daemon-role checks.
+- For a release, prove a real fresh native endpoint, attachable TUI, same-node
+  message-to-turn-to-correlated-reply flow, activity transitions, native resume, blocked in-TUI
+  switching, graceful shutdown, and both hostable roles.
+- Stop at the adapter boundary. Once same-node delivery proves the adapter handoff, cross-node
+  transport is a spt-core concern rather than an `omp-spt` release gate.
+
+## Anti-patterns
+
+Avoid documentation drift, setup before first success, mixed tutorial and reference prose,
+placeholder-only examples, multiple canonical command paths, private spt-core internals,
+archive-unpacking instructions for normal users, ambiguous session ownership, and claims that
+network transport is implemented by the OMP extension.
diff --git a/docs/KNOWN-HAZARDS.md b/docs/KNOWN-HAZARDS.md
index d84ea1f..0e468b0 100644
--- a/docs/KNOWN-HAZARDS.md
+++ b/docs/KNOWN-HAZARDS.md
@@ -1,444 +1,76 @@
-# Known Hazards
-
-> A **conformance checklist, not advice.** Each hazard below is a first-class
-> `REQ-HAZARD-*` requirement in `traceable-reqs.toml`, and is **not "covered" until a test tags
-> it** (`unit`, plus `int` where the failure is cross-process / cross-node). This file exists to
-> make "we won't re-break X" mechanical: an entry without a passing tagged test is an open risk,
-> and `traceable-reqs check` will say so once the hazard is activated.
-
-A hazard earns a place here when it is an invariant you have *paid for once* (a real bug, an
-incident) or one you have *committed never to introduce*. State it so a test can prove it.
-
-## Entry format
-
-Each entry is one numbered subsection with these fields:
-
-- **Failure** — the concrete bad behavior: what goes wrong, under what sequence / timing / input.
-- **Invariant** — the property that MUST hold, phrased so a test can assert it (the thing the
-  `REQ-HAZARD-*` requires).
-- **Mapping / notes** — where this lives in *this* project, and anything that changes the shape
-  of the test (e.g. "in-process now, so use a lock instead of racing on disk").
-- **cite** — where the failure / fix is evidenced (an incident, a prior commit, a source path);
-  reference only — the binding evidence is the tagged test.
-
-Mirror each entry as a requirement:
-
-```toml
-[[requirements]]
-id = "REQ-HAZARD-EXAMPLE"
-title = "The invariant, stated so a test can prove it"
-required_stages = []   # activate (["unit"] or ["unit","int"]) when you cover it
-```
-
----
-
-## 1. Windows / MSYS shell environment
-
-### 1.1 MSYS `/`-prefix path conversion mangles slash-leading arguments
-
-- **Failure:** On Windows under Git-Bash / MSYS, any **command-line argument** beginning with `/`
-  is silently rewritten to an absolute Windows path before the target binary sees it. Observed
-  2026-06-15 during the UPS-fires validation: invoking `claude -p "/send hi"` from Git-Bash
-  delivered the prompt to Claude Code as `C:/Program Files/Git/send hi` — the `/send` token was
-  path-converted. Anything that passes a `/sptc:…` (or other `/`-leading) token as a **positional
-  argument** through a Git-Bash layer is corrupted the same way. (Legacy `claude_skill_owl`
-  documents the identical hazard in `new-alarm`.)
-- **Invariant:** sptc adapter glue MUST NOT depend on receiving `/`-leading content as a
-  Git-Bash positional argument. Message/prompt content is read from the **hook stdin JSON**
-  (`prompt`, message bodies), never reconstructed from a `/`-prefixed argv; any helper that must
-  take such an argument uses a stdin/`--message-file` transport or `MSYS_NO_PATHCONV=1`.
-- **Mapping / notes:** the hook wrappers (`plugin/sptc/hooks/*.sh`) are immune by construction —
-  they parse the CC hook payload from stdin (`json_str`), not from argv. The invariant is the
-  *commitment* to keep it that way (and to apply it to any future `/sptc:*` arg-taking surface).
-  A test asserts the stdin path is honored (no argv `/`-token dependency).
-- **cite:** UPS-fires validation 2026-06-15 (`ups.log`, run A); legacy `new-alarm` SKILL.md
-  MSYS note. Reference only — binding evidence is the tagged test under `REQ-HAZARD-MSYS-PATHCONV`.
-
----
-
-## 2. Live-agent perch / CI orchestration
-
-### 2.1 Nested-`claude` perch collision tears down the live agent's poll stream
-
-<!-- [doc->REQ-HAZARD-PERCH-COLLISION] -->
-
-- **Failure:** The CI acceptance harness spawns a real `claude` session as the system-under-test.
-  If that nested session loads the spt plugin (whose SessionStart establishes a perch) and resolves
-  the **same perch id as the live operator agent** (e.g. `perri`), the nested establish **displaces
-  the operator's perch** — perches are name-keyed, last-establish-wins — killing the operator's
-  `api poll` / live stream. Observed 2026-06-15 as the live poll Monitor exiting `exit-1` plus a
-  `sessions log seal failed: git failed` on revive (the collision teardown). Diagnosed by the
-  operator as self-inflicted, NOT a legacy-substrate bug.
-- **Invariant:** Every nested SUT the acceptance harness spawns MUST run under a **disposable
-  identity** distinct from any live agent — `SPT_AGENT_ID=sptc-ci-<n>` (and the matching
-  `OWL_SESSION_ID`), never a live agent name. The harness MUST set this for every spawn; it MUST
-  NOT inherit the operator's `SPT_AGENT_ID`/`OWL_SESSION_ID`. A test asserts the harness always
-  overrides both to a `sptc-ci-` id and never emits a live id.
-- **Mapping / notes:** `ci/acceptance/lib.sh` `sptc_ci_identity` mints the disposable id and
-  exports it into the SUT env; `ci/acceptance/run-acceptance.sh` spawns `claude -p` only through
-  that env. The deterministic guard lives in `tests/acceptance-harness.sh` (no real `claude`
-  needed — it asserts the env the harness would hand a spawn). Identity is the documented
-  name-keyed knob (`spt whoami` resolves from `$OWL_SESSION_ID`/`$SPT_AGENT_ID`); a separate data
-  dir is not part of the public surface, so isolation rides on identity.
-- **cite:** Operator diagnosis 2026-06-15 (perch collision, self-inflicted via nested `claude -p`
-  loading the spt plugin). Reference only — binding evidence is the tagged test under
-  `REQ-HAZARD-PERCH-COLLISION`.
-
-### 2.2 A non-interactive spt-spawned CC deadlocks on a permission prompt
-
-<!-- [doc->REQ-HAZARD-PSYCHE-PERMS-DEADLOCK] -->
-
-- **Failure:** spt-core spawns Claude Code **non-interactively** on two paths — the Psyche runner
-  (`claude-spt psyche`, launched **detached** with `Stdio::null`) and the `[session.self]` bringup
-  (broker-held **PTY**, no operator attached at spawn). If such a CC turn hits a tool-use that
-  requires permission approval, the interactive permission gate has **no operator / no stdin** to
-  approve it — the turn blocks indefinitely. For the Psyche this is silent (detached, stdio
-  discarded): the daemon believes it hosts a working companion that never produces a commune.
-- **Invariant:** Every CC process spt-core spawns non-interactively MUST bypass the permission gate
-  with `--dangerously-skip-permissions`. Concretely: each `claude-spt psyche` turn (seed **and**
-  every pulse) carries it, and **both** `[session.self]` bringup commands (base `claude`, the `ccs`
-  profile) carry it. The Psyche additionally runs **inside** a Read/Edit/Write tool sandbox
-  (`--tools Read,Edit,Write --disable-slash-commands`), so auto-approve is bounded, not blanket
-  trust (see `docs/adr/0003-*`).
-- **Mapping / notes:** `tools/claude-spt/src/psyche.rs` `sandbox_flags()` appends the flag (and
-  the tool cap) to both `seed_cmd` and `pulse_cmd`; the unit test
-  `every_turn_is_sandboxed_to_legacy_owl_parity` asserts it on every turn. The bringup leg is a
-  manifest property — `adapter/claude-spt.toml` `[session.self].command` and
-  `[profiles.ccs.session.self].command` must both contain `--dangerously-skip-permissions`; a unit
-  assertion over the manifest covers it. The legacy sibling `claude_skill_owl`
-  (`src/live/wrapper/claude.rs`) applies the identical flag to init/resume/final, which is why this
-  is a *committed-never-to-reintroduce* invariant rather than an observed incident here.
-- **cite:** `claude_skill_owl/src/live/wrapper/claude.rs` (init/resume/final all pass
-  `--dangerously-skip-permissions`); identified 2026-06-18 while reaching psyche parity. Reference
-  only — binding evidence is the tagged tests under `REQ-HAZARD-PSYCHE-PERMS-DEADLOCK`.
-
-### 2.3 A missed `/clear` boundary rotation pins the perch to a dead session id — silently and permanently
-
-<!-- [doc->REQ-HAZARD-SESSION-PIN-WEDGE] -->
-
-- **Failure:** On `/clear` (or `/compact`) CC rotates to a NEW session id, and the SessionStart
-  boundary hook must re-pin the perch to it. The rotation verb is auth-gated on the **departed**
-  session's proof (`AUTH_REFUSED … (need --token or matching --session-id)` without it), and the
-  departed session's env file is already gone when the hook fires. The pre-v0.10.4 hook had two
-  stacked defects: it resolved the perch id via `whoami --json` keyed by the NEW sid — a catch-22
-  (the new sid is unregistered until the rotation succeeds) that resolved `self:null` and **skipped
-  the rotation with zero diagnostics** — and even when the id resolved it presented **no auth
-  proof**. Either way the perch stays pinned to the dead sid, after which EVERY id-scoped api call
-  (`poll`/`state`/`boundary`) from the live session is silently `AUTH_REFUSED` (stderr-only): the
-  session looks perfectly healthy (brief renders, turns run) while local AND cross-node delivery is
-  permanently dead. **No self-heal exists**: later boundary attempts present the new sid and refuse
-  too, and spt-core's dead-owner re-pin correctly does NOT cover a live harness pid (squat
-  protection). Observed live: the ENLYZEAM `ball-b` wedge (F-024, root-caused 2026-07-02) —
-  operator clean-room repro: fresh session + `/clear` wedges with zero hook errors.
-- **Invariant:** (1) The boundary branch resolves the endpoint id from `$SPT_ENDPOINT_ID` FIRST
-  (the brief path's proven preference) — never whoami-by-new-sid alone. (2) The hook persists the
-  CURRENT session id at EVERY SessionStart to an adapter-owned state file
-  (`{adapter_dir}/state/session/<endpoint_id>.sid`) and presents it as `--session-id` proof at the
-  next rotation — NOT via `CLAUDE_ENV_FILE`, whose per-session lifetime is the exact failure mode.
-  (3) A rotation that cannot run (no id) or is refused (auth) logs LOUDLY to stderr with the
-  reason; a silent skip is forbidden.
-- **Mapping / notes:** `tools/claude-spt/src/hook.rs` — `sid_state_rel` + the boundary branch +
-  the post-registration persistence; `HookEnv::{spt_strict,log,read_adapter_state,write_adapter_state}`
-  seams (the plain `spt` seam discards stderr and exit — the refusal reason NEEDS the strict seam).
-  Recovery for an already-wedged perch: relaunch the endpoint WITHOUT `/clear` (resume re-binds the
-  recorded sid; live-proven on ENLYZEAM 2026-07-02).
-- **cite:** F-024 correction arc, `docs/SPT-CORE-FINDINGS.md` (empirics: whoami-by-dead-sid →
-  `self:null`; `AUTH_REFUSED:ball-b (need --token or matching --session-id)` shell-verified); doyle
-  ruling `F024D-BOUNDARY-RULING` 2026-07-02 (adapter-owned state file = the contract-clean carrier;
-  the reference pattern for the harness-contract boundary doc). Binding evidence = the tagged tests
-  under `REQ-HAZARD-SESSION-PIN-WEDGE`. Fix live-validated on-node: E2E-0104 GREEN (doyle verdict
-  2026-07-02 — rotation authenticates with the prior sid, `.sid` rolls forward in lockstep,
-  post-rotation delivery lands; the `[int->REQ-DIST-BOUNDARY-ROTATE]` record in
-  `docs/SPT-CORE-FINDINGS.md` F-024).
-
-### 2.4 The checkpoint wake races the `/clear` and lands in the OLD session
-
-<!-- [doc->REQ-HAZARD-CHECKPOINT-CLEAR-RACE] -->
-
-- **Failure:** The agent-driven checkpoint submits `/clear` then a wake directive. CC's `/clear` is
-  ASYNC — it tears down and rebuilds the session, re-running SessionStart (whoami, psyche-download,
-  brief assembly — network I/O, seconds). The pre-fix macro emitted both in ONE inject sequence with a
-  fixed `500ms` gap between the `/clear` submit and the wake. Two stacked problems: (1) 500ms is a
-  blind guess — a slow clear routinely exceeds it, so the wake is typed/submitted BEFORE the clear
-  settles and lands in the OLD (about-to-be-wiped) session, or the ordering inverts entirely (the
-  wake hits first). (2) A hard ceiling: the whole inject sequence must `{commit}` within the 5s
-  `INJECT_COMMIT_DEADLINE`, so the delay CANNOT be widened to cover a genuinely slow clear — a single
-  inject sequence is architecturally incapable of straddling a `/clear`. Field-observed: the followup
-  wake hit first.
-- **Invariant:** The clear and the wake are SPLIT into two inject sequences, synchronized on CC's own
-  clear-done signal (SessionStart firing with `source == clear`). (1) ARM: a `{"checkpoint":"v1",…}`
-  envelope stashes the wake in the translation binary's in-memory `pending_wake` and emits CLEAR-ONLY
-  (`ctrl+s · 50ms · /clear · 50ms · enter · commit`); the wake is withheld. (2) FIRE: the SessionStart hook,
-  on a `clear` boundary, UNCONDITIONALLY self-sends `{"checkpoint_fire":"v1"}`; the binary emits
-  WAKE-ONLY (`ctrl+s · 50ms · wake · 50ms · enter · commit`) iff a wake is armed, else no-ops. State lives
-  ONLY in translate memory (no marker file; the hook is stateless — it fires on every clear and the
-  binary decides). BOTH self-sends use `--force-native` so the signal is delivered through the
-  translation binary's stdin (where the markers parse), never spooled to the active-poll channel
-  (which surfaces the envelope as a plain message the agent reads instead of firing — the ENLYZEAM
-  misdelivery mode). Ordering is guaranteed by construction: the wake can only emit after SessionStart,
-  which only fires after `/clear` completes. Fires ONLY on `clear`, not `compact` (no checkpoint
-  variant leverages `/compact`).
-- **Accepted residual:** if the checkpoint's own clear fails to fire the signal (hook error), the
-  armed wake fires on the NEXT clear — possibly a slightly-wrong context. The every-clear-fire model
-  self-limits it (it won't sit forever); a translate-side generation/timeout could bound staleness if
-  it ever bites. Accepted for v1.
-- **Mapping / notes:** `tools/claude-spt/src/translate.rs` — `commands_for_clear` (ARM) +
-  `commands_for_wake` (FIRE) + `is_checkpoint_fire` + the stateful `dispatch_event` threading
-  `pending_wake` (the binary is one persistent process per endpoint, reaped on shutdown NOT on
-  `/clear`, so the armed wake survives the clear). `tools/claude-spt/src/hook.rs` —
-  `handle_post_tool_use` (`--force-native` on the arm self-send) + `handle_session_start` (the
-  `clear`-boundary fire: mark idle + self-send `checkpoint_fire` `--force-native`).
-- **cite:** `CHECKPOINT-CLEAR-RACE-PLAN.md`; supersedes the single-sequence macro described in
-  `REQ-DIST-CHECKPOINT-COMMUNE`. Binding evidence = the tagged tests under
-  `REQ-HAZARD-CHECKPOINT-CLEAR-RACE` (crate units: `arm_then_fire_orders_clear_before_wake`,
-  `fire_emits_wake_only_and_disarms`, `fire_with_no_armed_wake_is_a_noop`; hook units:
-  `clear_boundary_fires_checkpoint_fire_force_native`, `non_clear_starts_do_not_fire_checkpoint`; int:
-  the ARM-emit block in `ci/idle-translate/translate-proof-int.sh`).
-- **Second leg (v0.15.1, paid 2026-07-06): everything that fires POST-clear must ride ONE inject
-  sequence.** The boundary rename (v0.14.1) originally rode its own sequence immediately before the
-  wake's — two back-to-back sequences at the just-rebuilt boundary RACED (CC input processing lags
-  the PTY stream: the rename's enter registered as a soft newline, the next sequence's ctrl+s failed
-  to stash the residue, and the wake text submitted INSIDE the `/rename` argument — flynn: session
-  titled with the wake, NO wake turn, agent dormant ~9.5h; ~33% observed, 1 of 3 checkpoints).
-  Invariant: the fire emits rename + wake as ONE combined sequence with an explicit enter→ctrl+s
-  bridge delay between the halves (`commands_for_boundary`, `BOUNDARY_BRIDGE_MS`); the rename
-  delivery only STASHES. Never reintroduce a second post-clear inject sequence. Regression lock:
-  `checkpoint_boundary_is_one_combined_sequence_rename_then_wake` (crate unit).
-
----
-
-### 2.5 A spawned Psyche inherits its parent's identity env and rebinds a FOREIGN perch
-
-<!-- [doc->REQ-HAZARD-PSYCHE-IDENTITY-ENV] -->
-
-- **Failure:** The `[session.psyche_init]` child inherits the spawning session's environment —
-  including `OWL_SESSION_ID` / `SPT_AGENT_ID`, the parent's identity env. The Psyche's own harness
-  hooks then resolve "self" to the PARENT (or, worse, an unrelated top-level perch) and stamp/rebind
-  THAT perch's records. Field-observed on HFENDULEAM (F-028 C2 evidence): `f015b-probe-psyche`'s hook
-  rebound `hall-a`'s `info.json.session_id` to the psyche's own session via `authenticate()`'s
-  dead-owner re-pin — cross-perch identity contamination, silent.
-- **Invariant:** A Psyche NEVER carries its parent's identity env. BOTH psyche roles declare
-  `env_remove = ["OWL_SESSION_ID", "SPT_AGENT_ID"]` (v0.14.0 ephemeral: the gate `[session.psyche_init]`
-  AND the spawned `[session.psyche_resume]`); the spt-core runtime honors role-level `env_remove`
-  (shipped, f028) and strips them before spawn. This is the adapter's half of the f028 guard pair —
-  spt-core's halves (nested-inclusive self-resolve + cross-perch bind-honesty refuse) guard the daemon
-  side, but the adapter must not hand the child a foreign identity in the first place.
-- **Mapping / notes:** `adapter/claude-spt.toml` `env_remove` on BOTH `[session.psyche_init]` and
-  `[session.psyche_resume]` (the declarations); binding evidence = the env-scrub block in
-  `tests/manifest-shortcut.sh` (loops over both roles). If a future role spawns any other detached
-  child that runs harness hooks, it needs the same scrub.
-- **cite:** doyle's F-028 C2 adapter change brief (2026-07-03); spt-core runtime `env_remove` support
-  is public contract (`manifest.schema.json` `SessionRole.env_remove`).
-
-### 2.6 The psyche host loops silently at ~3 boots/sec when claude dies at spawn
-
-<!-- [doc->REQ-HAZARD-PSYCHE-HOST-THRASH] -->
-
-- **Failure:** The psyche host's resident loop had no pacing: each iteration polls the perch
-  (`spt ready --once`) then maybe runs a claude turn. A healthy iteration BLOCKS (the poll waits for
-  a pulse; a model turn takes seconds) — but when claude dies instantly at spawn (canonically: an
-  untrusted `{psyche_dir}` cwd puts CC at a workspace-trust prompt with null stdin, F-h/F-026) or
-  the poll returns success-instantly-empty, the loop spun ~3 iterations/sec, silently, forever.
-  Field-observed on HFENDULEAM: ordinal 5358 boot rows in ~30min. Doubly invisible to spt-core:
-  its residency pacing keys on wrapper DEATH (the wrapper stays resident), and its
-  `psyche_host_error` surface sees wrapper EXITS only (nothing exits). Even `spt endpoint shutdown`
-  left the looping wrapper running (core-side hardening for that is C3(b)/(c), theirs).
-- **Invariant:** The loop is PACED and TERMINAL under persistent instant cycles: a cycle finishing
-  sub-2s (`INSTANT_CYCLE_MS`) increments a streak — exponential backoff (500ms doubling, 5s cap) —
-  and at 8 consecutive (`GIVE_UP_AFTER`) the host prints `PSYCHE_HOST_GIVE_UP:<id>` to stderr and
-  exits **nonzero** (3), converting the invisible loop into the wrapper death spt-core's existing
-  `psyche_host_error`/residency machinery already handles. Any healthy cycle resets the streak
-  (recovery mid-thrash — e.g. the operator trusts the dir — must not accumulate toward give-up).
-- **Threshold coupling (doyle-ruled, binding):** spt-core's C3(b) backstop trips at ≥10 ledger
-  boundaries per 60s window. For the pure instant-death class the adapter always fires first —
-  ≤8 boundaries, <60s worst-case wall clock, strictly inside the core trip on both axes. Failure
-  modes that dodge the streak (e.g. just-over-threshold cycles resetting it — the reset
-  deliberately forgives) legitimately reach the core backstop: a core trip on a guarded wrapper is
-  CORRECT backstop behavior, not a bug. Do not retune these constants except in step with the
-  ruling (the coupling is asserted by `give_up_stays_inside_the_core_backstop_window`, derived
-  from the real constants).
-- **Second leg (v0.13.4, field 2026-07-04) — a REFUSED poll must die loud, not exit clean:** the
-  runner's per-pulse `spt ready <id> --once` can fail for CONFIG/ENV reasons the runner can never
-  satisfy — canonically the multi-subnet home guard (`READY_FAIL: … pass --subnet`; the daemon
-  fills carry no subnet, a core seam, F-017 sibling). Treating any non-success as "perch gone"
-  exited 0 silently and moved the invisible loop ONE LEVEL UP: the daemon rehosted the runner
-  ~every 5s forever (hall-bf-psyche, ordinal 6491, since the node's second subnet joined —
-  invisible to C3(b), see doyle's boot-records-vs-ledger item). Invariant: a poll failure whose
-  stderr carries `READY_FAIL` exits LOUD + NONZERO (`PSYCHE_POLL_FAIL`, exit 4) so
-  psyche_host_error stamps a real fault; a plain non-success (perch closed at session end) stays
-  the quiet lifecycle exit. Asserted by `ready_fail_refusal_is_loud_not_perch_gone` +
-  `plain_poll_death_stays_the_clean_perch_gone_exit`.
-- **RESOLVED-BY-DESIGN (v0.14.0, F-030 psyche-ephemeral redesign):** the resident loop this hazard
-  guards — and its second-leg poll-fail — are DELETED. The shim is run-to-completion (one `claude`
-  spawn per invocation, then exit): there is no loop and no per-pulse `spt ready --once`, so neither
-  the instant-cycle class nor the multi-subnet `READY_FAIL` churn can occur adapter-side. Crashloop is
-  now repeated ephemeral deaths, which core C3(b)'s ledger-rate backstop + the daemon's
-  `psyche_host_error` surface own by design (an ephemeral death is exactly what that surface consumes).
-  The subnet-less nested-resolution seam (a runner could never know its subnet) folds into the F-030
-  core wave. Kept for history per KH convention; the successor invariant is the shim's pure planner.
-- **Mapping / notes:** `tools/claude-spt/src/psyche.rs` — the ephemeral shim's stateless `plan()`
-  (successor evidence: `plan_is_stateless_one_turn_no_residency` — plans exactly one turn, nothing to
-  thrash), replacing the retired `thrash_guard` module + `poll_refused` classifier (both deleted with
-  the resident loop). The deferred give-up/poll-fail live ints die with the loop (nothing to trigger).
-- **cite:** doyle's C3 adapter-half brief (2026-07-03), formalizing our F-h finding; spt-core
-  halves = C3(b) ledger-rate trip @b2351a0 + shutdown tree-kill hardening; second leg = the
-  hall-bf field residual (doyle confirm run, 2026-07-04) + perri's multi-subnet READY_FAIL repro;
-  RESOLVED-BY-DESIGN = the v0.14.0 ephemeral redesign (PSYCHE-EPHEMERAL-PLAN.md, F-030 adapter half).
-
-### 2.7 A delivery answered with ZERO records faults + terminates the translation binary
-
-<!-- [doc->REQ-HAZARD-EMPTY-RESPONSE-COMMIT] -->
-
-- **Failure:** The broker opens an inject sequence for every event delivery it feeds the
-  translation binary and ends it ONLY on an explicit `{commit}` — a delivery the binary answers
-  with zero output lines leaves the sequence unterminated, the 5s `INJECT_COMMIT_DEADLINE`
-  expires, and the broker faults + TERMINATES the binary (permanently until respawn; the
-  published contract's "raw-inject fallback" consequence is stale — removed core-side v0.14.3).
-  The adapter had exactly this zero-record path: a `checkpoint_fire` with nothing armed answered
-  `Vec::new()`. Since the SessionStart hook self-sends `checkpoint_fire` on EVERY clear
-  (stateless by design, REQ-HAZARD-CHECKPOINT-CLEAR-RACE), every non-checkpoint `/clear`
-  killed the binary at the boundary — the deterministic half of the "force-native decay" ghost
-  (B6). Pinned 2026-07-04: iso captured stderr shows the ARM's commit ACCEPTED and the
-  `TRANSLATION_FAULT` following the unarmed duplicate fire ~5s later; whole-sequence-deadline
-  and parse-drop mechanisms were excluded by measurement (sequence budgets ≤~150ms vs 5s;
-  zero `TRANSLATION_BIN_BAD_LINE`; commit line bytes exact).
-- **Invariant:** EVERY event-typed delivery answers at least a bare `{"commit":true}` — a
-  deliberate no-op delivery still terminates its inject sequence. Scope is event-typed responses
-  ONLY: `init`/`input`/unknown stdin lines are protocol lines, not inject deliveries, and must
-  stay silent (an unsolicited `{commit}` outside a sequence is protocol noise; doyle-confirmed
-  scoping).
-- **Mapping / notes:** `tools/claude-spt/src/translate.rs` — `dispatch_event`'s unarmed-fire
-  branch and `dispatch_line`'s event-without-envelope branch each emit the bare commit. Binding
-  evidence = the three `REQ-HAZARD-EMPTY-RESPONSE-COMMIT` unit tests (two bare-commit asserts +
-  the no-stray-commit scoping assert). The live boundary-survival int graduates with the
-  wake-survival e2e once spt-core's C-1 (miss≠fault deadline semantics) lands. This was a JOINT
-  contract gap: the published contract nowhere states the empty-response rule and understates
-  the missed-commit penalty — both docs fixes ride core's C-1 chunk.
-- **cite:** doyle 3-discriminant collab + verdict (2026-07-04, work order @2915eb8); iso wtrace
-  captured stderr (4 injects, fault after the duplicate fire); operator's two-commit premise
-  check that reframed the hunt to the receive side.
-
-### 2.8 Raw PreToolUse stdout is DISCARDED by CC — a mid-turn drain becomes a silent message black hole
-
-<!-- [doc->REQ-HAZARD-PRETOOL-CONTEXT-ENVELOPE] -->
-
-- **Failure:** CC injects a hook's additionalContext from PLAIN stdout only on
-  `UserPromptSubmit`. On `PreToolUse`, plain stdout is logged and DISCARDED — context reaches
-  the agent only inside the `{"hookSpecificOutput":{"hookEventName":"PreToolUse",
-  "additionalContext":…}}` JSON envelope. The adapter's mid-turn delivery leg (F-021) emitted
-  raw text on both events, so every message drained during a busy turn was TAKEN from the spool
-  (`delivered=1`, honest core-side) and then thrown away by CC — invisible to the agent,
-  invisible to the sender, invisible in the spool. Field 2026-07-07 (doyle RCA): every
-  claude-spt session on the node was a silent message black hole; three doyle→perri messages
-  (including the outage evidence itself) were eaten mid-turn. The busy-path eat also MASKS
-  itself: a busy agent's rows are consumed within seconds by its constant PreToolUse stream,
-  so the idle-path/UPS legs never get a chance to surface them.
-- **Invariant:** Every PreToolUse emission — message drains, nudges, overflow pointers — rides
-  the `hookSpecificOutput` JSON envelope, never raw stdout. The cap decision is made on the
-  WRAPPED byte size (JSON escaping can double newline-heavy drains), and an over-cap drain
-  spills the RAW text with a WRAPPED pointer — a taken message must always surface somewhere
-  the agent can read.
-- **Mapping / notes:** `tools/claude-spt/src/hook.rs` — `wrap_pretool_context` +
-  `emit_capped_pretool`, wired in `handle_pre_tool_use`. UserPromptSubmit keeps raw-stdout
-  emission (that channel is the documented raw-context path and is live-proven).
-  `~/.claude/reference_docs/claude-code-hooks.md` is the per-event contract source — check it
-  BEFORE wiring any new hook output, per event, never by analogy from another event.
-- **cite:** doyle node-wide RCA + self-probe (2026-07-07); perri repro: the installed binary
-  driven directly emits correctly (binary exonerated), spool rows delivered=1 with zero
-  surfaced `<sptc_messages>`; recovered bodies read straight from `spool.db`.
-
-### 2.9 A poll frame truncated mid-frame is silently dropped WHOLE by the drain renderer
-
-<!-- [doc->REQ-HAZARD-DANGLING-FRAME-LOUD] -->
-
-- **Failure:** `render_frames` walks `spt api poll` output frame by frame (`<EVENT …>body</EVENT>`).
-  If the poll output ends mid-frame — opening tag present but no `>`, or a body with no closing
-  `</EVENT>` — the original loop `break`s and the dangling frame vanishes: the message was taken
-  from the spool (`delivered=1`) but nothing surfaces to the agent. Same silent-loss family as
-  §2.8, one seam upstream. Never observed in the field (the 2026-07-07 seed-#9 head-truncations
-  were core-side idle-inject pacing, spool rows complete, and could NOT have produced this shape),
-  but the drop path existed and was invisible by construction — hardened 2026-07-07 (doyle-ACKed)
-  before it could cost a real message.
-- **Invariant:** A dangling frame is never dropped silently. The renderer emits a loud
-  `<sptc_frame_integrity>` marker carrying the surviving partial content and a spool-recovery
-  pointer (`owlery/<id>/spool.db`, `messages` table) — a taken message must always surface
-  somewhere the agent can read (the §2.8 rule, applied to the framing seam).
-- **Mapping / notes:** `tools/claude-spt/src/hook.rs` — the dangling-frame arm in `render_frames`.
-  Rides both drain paths (UserPromptSubmit + PreToolUse) and the existing capped emits unchanged.
-- **cite:** perri code-walk during the seed-#9 seam exoneration (2026-07-07); doyle "ship it" ACK
-  same night.
-
-## 3. Distribution split (adapter × plugin version skew)
-
-### 3.1 A hook_cmd shape change with a stale dispatch.sh bricks the whole CC session
-
-<!-- [doc->REQ-HAZARD-HOOKCMD-DISPATCH-LOCKSTEP] -->
-
-- **Failure:** `spt adapter update` refreshes the adapter (manifest + binary) **immediately**, but
-  the cplugs plugin's `dispatch.sh` on disk only refreshes after a plugin reconcile + CC
-  `/reload-plugins`. Observed live 2026-07-01 (perri, the v0.9.0→0.9.2 on-node update): the stale
-  0.1.8 `dispatch.sh` execs `"$bin" <event>` (expecting the legacy ` hook`-suffixed hook_cmd) while
-  the new manifest's `[strings].hook_cmd` is a **bare** binary path → it ran `claude-spt PreToolUse`
-  → `unknown subcommand` → **nonzero exit on every hook event** → CC blocked EVERY tool call
-  (Bash/Read/Write/Glob/AskUserQuestion) **and looped the Stop hook** (the agent could not even end
-  its turn). Zero self-repair is possible from inside the session — every repair lever is itself a
-  blocked tool call; only the operator's `/reload-plugins` recovered it. The v0.9.1 dispatch fix
-  (strip legacy ` hook` suffix) protects the OTHER direction only (new dispatch × old manifest).
-- **Invariant:** a `hook_cmd` SHAPE change in either layer with the other layer stale MUST
-  **degrade, never brick**: (a) `dispatch.sh` tolerates BOTH shapes in BOTH directions (append the
-  `hook` token iff missing, strip iff doubled), and (b) `claude-spt` exits **0** (pass-through with
-  a stderr note) on an unrecognized event/subcommand token so a stale dispatch produces a noisy
-  no-op instead of a tool-blocking failure. Equivalently: pin the dispatch↔binary contract so the
-  shape can never change unilaterally.
-- **Mapping / notes:** the two halves live in `plugin/sptc/hooks/dispatch.sh` (cplugs-shipped,
-  slow channel) and `tools/claude-spt/src/{main,hook}.rs` (adapter-shipped, fast channel) — the
-  asymmetric ship cadence IS the hazard. A `claude-spt post-update` reconcile of the LIVE plugin
-  cache dir (including ccs instance roots `~/.ccs/instances/<x>/plugins/…`, suspected missed today —
-  unconfirmed) closes the window but cannot cover a mid-session CC that has already snapshotted its
-  hooks; the degrade-not-brick exit-0 half covers that remainder.
-- **cite:** live incident 2026-07-01 (perri session, this node; todlando concurs adapter-side —
-  off the spt-core triage doc). Memory: `v092-onnode-update-skew-brick.md`. Reference only —
-  binding evidence lands with the tagged tests under `REQ-HAZARD-HOOKCMD-DISPATCH-LOCKSTEP`
-  (registry entry present, stages `[]` until the guard slice activates).
-
-### 3.2 CC can boot a session on a STALE cached plugin version despite a newer one installed
-
-<!-- [doc->REQ-HAZARD-STALE-PLUGIN-RESOLUTION] -->
-
-- **Failure:** the harness's plugin resolution picked an OLD cached copy at session boot even
-  though the newer version was already installed. Observed live (F-024 domino #1, ENLYZEAM):
-  the node's plugin cache held BOTH sptc 0.1.8 and 0.1.9; `installed_plugins.json` showed 0.1.9
-  installed **24 minutes before** the 2026-06-29 boot of session `22ce8af0…` — yet that session
-  verifiably ran the **0.1.8** dispatch (the unquoted-`SPTC_HOOK_BIN` v0.9.0 regression, fixed in
-  0.1.9). The stale pick then compounds: the buggy dispatch corrupted the per-session
-  `CLAUDE_ENV_FILE`, which **survives every resume of that session** (the env file lives with the
-  session, so one bad boot poisons the session's whole lifetime), hooks died silently, and the
-  dead-hook era swallowed the `/clear` boundary — the first domino of the ball-b wedge. WHY CC's
-  resolver picked the stale copy is **unconfirmed** (CC-internals: resolution lag, a pin, or an
-  orphaned-dir artifact — cf. the orphaned old install dir left by the v0.9.2 update). The
-  adapter cannot control the harness's picker; it CAN control how survivable and how visible a
-  stale pick is.
-- **Invariant (defense-in-depth — the adapter stays safe under a stale pick):
-  (a) degrade-not-brick:** any shipped dispatch version × any adapter version must degrade,
-  never brick (§3.1's invariant is the binding half; a stale-RESOLVED plugin is simply another
-  way to arrive at the same skew).
-  **(b) minimize the stale-pickable set:** the post-update plugin reconcile must reach EVERY
-  plugin root the node's CLIs actually read — the `claude` config root AND each ccs instance root
-  (`~/.ccs/instances/<x>/…`, the v0.10.3 follow-up) — and superseded cached copies should be
-  purged (or at minimum flagged) rather than left resolvable; a picker cannot choose a stale copy
-  that no longer exists.
-  **(c) observability:** which plugin version actually ran must be a log line, not an ssh dig —
-  the dispatch (or the hook binary it execs) should surface its plugin version at least once per
-  session so version-of-truth checks can catch a stale pick immediately.
-- **Mapping / notes:** reconcile halves live in `tools/claude-spt/src/post_update.rs` (primary
-  CLI reconcile + the best-effort ccs follow-up, v0.10.2/v0.10.3 — REQ-DIST-CCS-PLUGIN-FOLLOWUP);
-  the degrade half is §3.1 / `REQ-HAZARD-HOOKCMD-DISPATCH-LOCKSTEP`; the purge and
-  version-surfacing halves are **unbuilt** (guard-slice work, activate on start). Operator
-  guidance meanwhile: after any adapter/plugin update, purge stale plugin-cache copies of sptc
-  from every plugin root on the node (doyle's F-024 advisory — a latent re-brick hazard while any
-  pre-0.10.2 copy remains), and treat "version installed" as unproven until the running session
-  demonstrates it.
-- **cite:** F-024 auth-wedge arc, `docs/SPT-CORE-FINDINGS.md` (doyle receipt
-  `F024-AUTHWEDGE-CONFIRMED`; perri ssh-verified the 0.1.8-dispatch-at-boot on ENLYZEAM). The
-  CC-side residual question (why the resolver lagged/pinned) stays open — perri court. Doc
-  evidence = this entry; impl/unit land with the guard slice.
+# Known hazards
+
+This is the OMP adapter's conformance checklist. Each entry states a failure
+mode, the invariant that prevents it, the evidence boundary, and its source.
+An invariant is not covered merely because it is described here: the active
+requirement must point at production behavior and a focused test.
+
+## 1. Delivery custody can be lost or mis-correlated
+
+<!-- [doc->REQ-OMP-EXTENSION-CUSTODY] -->
+
+- **Failure:** Two SPT deliveries overlap, the active sender is overwritten, or
+  OMP rejects a submitted message after the listener has already accepted it.
+  The wrong peer can receive the next answer, or one accepted message can
+  disappear with no terminal outcome.
+- **Invariant:** The extension serializes deliveries. From receipt until
+  completion it owns the sender, full event, submitted OMP turn, and terminal
+  outcome as one custody record. It advances only after sending either the
+  correlated answer or an explicit failure to that sender. Submission failure
+  is never treated as a successful empty answer.
+- **Mapping / notes:** The native OMP extension owns receipt, queueing,
+  `sendUserMessage`, turn completion, and reply. The ordinary OMP turn receives
+  a short message stub plus the full event context; peer content is never
+  submitted as a local slash command.
+- **cite:** ADR-0010 and the OMP extension lifecycle contract.
+
+## 2. A dead listener leaves a healthy-looking but unreachable endpoint
+
+<!-- [doc->REQ-OMP-LISTENER-FAIL-CLOSED] -->
+
+- **Failure:** The SPT listener exits while OMP remains open and bound. If the
+  extension retries forever or merely logs the exit, the endpoint can stay
+  advertised as online while no message can reach it.
+- **Invariant:** Unexpected listener exit triggers only a finite, deterministic
+  restart schedule. A successful restart resumes delivery with custody intact.
+  Exhausting the schedule performs SPT session-end and shuts down OMP loudly.
+  There is no infinite restart loop and no healthy advertisement after the
+  delivery path is gone.
+- **Mapping / notes:** Retry timers are extension-owned and cancellable during
+  normal shutdown. The exhausted path uses the same serialized teardown seam as
+  an explicit endpoint stop.
+- **cite:** ADR-0010; field issue HIGH-2/HIGH-4 successor invariant.
+
+## 3. In-TUI session switching breaks endpoint identity
+
+<!-- [doc->REQ-OMP-SESSION-IMMUTABLE] -->
+
+- **Failure:** A bound endpoint switches, branches, creates, or resumes another
+  OMP session from inside the TUI. The stable SPT endpoint id then points at a
+  different transcript than queued messages, replies, history, digest, and
+  durable mind state expect.
+- **Invariant:** One endpoint owns exactly one OMP session for its lifetime.
+  The extension blocks every in-TUI action that would change that session.
+  Selecting another session requires stopping the endpoint and relaunching it
+  with the explicit native-resume role, producing a new deliberate bind.
+- **Mapping / notes:** This is stricter than merely rebinding on a session
+  event. A rebind would preserve liveness while violating custody and history
+  identity, so it is not an allowed recovery.
+- **cite:** ADR-0011.
+
+## 4. The `omp` basename resolves to the wrong executable
+
+<!-- [doc->REQ-OMP-EXECUTABLE-RESOLUTION] -->
+
+- **Failure:** Another program owns the bare `omp` token, or an adapter helper
+  is advertised as a host binary. The broker can launch or bind the wrong
+  process, while process listings conceal which application actually owns the
+  endpoint.
+- **Invariant:** The manifest advertises only the genuine OMP host basename.
+  The native launch shim resolves and validates Oh My Pi before launch, rejects
+  collisions loudly, and then replaces itself or inherits the terminal
+  unchanged so native OMP remains the PTY owner.
+- **Mapping / notes:** `omp-spt` is the adapter helper/release binary, never a
+  hosted-harness match key. Fresh and resume launch use the same resolver.
+- **cite:** ADR-0009 and the retired bridge incident's executable-collision
+  finding.
diff --git a/docs/OMP-BRIDGE-FIELD-ISSUES.md b/docs/OMP-BRIDGE-FIELD-ISSUES.md
index 9f6921c..a38db8d 100644
--- a/docs/OMP-BRIDGE-FIELD-ISSUES.md
+++ b/docs/OMP-BRIDGE-FIELD-ISSUES.md
@@ -1,193 +1,53 @@
-# omp-spt bridge — field issues (doyle, 2026-07-09)
-
-Report from an spt-core maintainer (doyle @ HFENDULEAM) after the operator ran a
-live agent (`todlando`) under the experimental **omp-spt** adapter. The endpoint
-"only showed `READY:todlando` and nothing else", could not be stopped cleanly,
-and could not be switched back to `claude-spt`. This documents the root causes,
-grounded in this repo's code, so the bridge can be hardened.
-
-All line references are against `tools/claude-spt/src/bridge.rs` and
-`adapter/omp-spt.toml` at commit `f0109d1`.
-
-## Incident summary
-
-1. Operator started `todlando` under omp-spt (`[session.self]` →
-   `{adapter_dir}/claude-spt bridge --id todlando --node HFENDULEAM`).
-2. Broker PTY showed `READY:todlando` and nothing further — no turn activity, no
-   way to tell working vs. wedged.
-3. Operator detached + "stopped" the endpoint. Two processes survived as
-   orphans: the bridge (`claude-spt.exe bridge --id todlando`, pid 82460) and its
-   `spt ready todlando` child (pid 5956). The perch stayed registered → the
-   endpoint looked alive but was dead.
-4. Resuming from the last claude-spt session still launched the omp-spt bridge.
-5. Starting fresh after switching the harness adapter still launched omp-spt.
-
-Steps 3–5 required manual intervention on the spt-core side (kill the orphan
-tree, repair the endpoint's session ledger) to recover. Findings below explain
-each symptom.
-
----
-
-## HIGH-1 — Bridge binary basename collides with `claude-spt`
-
-**Symptom.** In `ps`/`tasklist` the omp-spt bridge appears as `claude-spt.exe` —
-indistinguishable from a genuine claude-spt process. During the incident this
-made it impossible to tell, at a glance, that the "claude-spt" process holding
-todlando's perch was actually the omp bridge. It directly caused the
-misdiagnosis.
-
-**Root.** `adapter/omp-spt.toml:693` (and `:722` for resume) ship:
-```
-command = "{adapter_dir}/claude-spt bridge --id {id} --node {node}"
-```
-The executable is named `claude-spt`, the exact basename of the upstream adapter.
-This contradicts the adapter's own design note (`omp-spt.toml:436`: *"the RPC
-bridge (S2) is `omp-spt`"*).
-
-**Fix.** Rename the shipped bridge binary to `omp-spt` (or `omp-spt-bridge`) and
-update `[session.self]`/`[session.resume]` `command` accordingly. A distinct
-basename makes the process self-identifying and removes the collision.
-
-## HIGH-2 — No teardown / signal handling → orphaned children on stop
-
-**Symptom.** Stopping the endpoint left the `omp --mode rpc` child and the
-`spt ready <id>` child running; the perch stayed `READY`. Recovery needed a
-manual `taskkill /T` of the bridge tree.
-
-**Root.** `bridge.rs` installs no signal/console-control handler and no OS job
-object — confirmed: no `SetConsoleCtrlHandler` / `JobObject` / `kill_on_drop` /
-`ctrlc` anywhere in `tools/claude-spt/src/`. The only child cleanup is the two
-`kill()` calls at the *graceful* end of the relay loop (`bridge.rs:241-242`).
-When the broker or operator terminates the bridge process (the normal "stop"),
-those lines never run. On Windows, killing a process does not kill its children,
-so both the omp child and the `spt ready` child are leaked. The leaked
-`spt ready` keeps the perch registered, so the dead endpoint still advertises as
-listening.
-
-**Fix.** Tie child lifetime to the bridge: on Windows assign the omp + `spt ready`
-children to a `JobObject` with `JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE`; on Unix use
-a process group + `kill_on_drop`. Install a console-control/signal handler that
-tears both children down and unbinds the perch. Consider a `[session.stop]`
-manifest seam so the broker drives an orderly unbind rather than a bare kill.
-
-## HIGH-3 — Headless design gives the operator zero visibility
-
-**Symptom.** The literal reported symptom: `READY:todlando` and nothing else,
-forever.
-
-**Root.** The bridge runs omp in `--mode rpc` (no TTY UI) and only *inherits*
-omp's stderr (`bridge.rs:132`). The sole thing printed to the broker PTY is the
-`spt ready` child's `READY:<id>` banner (its stderr is inherited,
-`bridge.rs:192`). All turn activity — message received, prompt dispatched, reply
-sent, errors — is emitted only under `OMP_SPT_DEBUG` via the `trace!` macro
-(`bridge.rs:48-54`). With debug off (the default), a working bridge, an idle
-bridge, a wedged bridge, and a bridge whose omp child has died all look
-identical: `READY:todlando`.
-
-**Fix.** Emit a minimal, always-on operational log to stdout: one line per
-inbound message (from, byte count), per reply (target, byte count), and per error
-(bind/state/send failure, omp exit). A periodic status/heartbeat line would let
-the operator distinguish idle from wedged.
-
-## HIGH-4 — Unbounded blocking reads, no timeouts → silent permanent wedge
-
-**Symptom.** A bringup or a turn can hang forever with no failure surfaced —
-consistent with "READY then nothing".
-
-**Root.** Every omp read is a blocking `read_line` with no deadline:
-- `wait_for_ready` (`bridge.rs:312`) loops until the `ready` frame or EOF.
-- `get_state_session_id` (`bridge.rs:326`) loops until the `get_state` response.
-- `drive_turn` (`bridge.rs:339`) loops until `agent_end`.
-
-If omp stalls before `ready` (auth prompt, wrong binary — see MEDIUM-3, model
-hang) the bridge blocks in startup forever: it never binds, never reaches
-`spt ready`, and never fails. If a *turn* never produces `agent_end`, the single
-relay thread wedges with the perch stuck `busy` (state set at `bridge.rs:226`,
-cleared only after `drive_turn` returns at `:228`).
-
-**Fix.** Bound every wait: a dedicated reader thread feeding a channel with
-`recv_timeout`, plus a ready-deadline and a per-turn deadline. On breach, fail
-loud (startup) or abort the turn and recover the perch to `idle`/offline.
-
-## MEDIUM-1 — Single-thread head-of-line relay; `steer`/`follow_up` unimplemented
-
-**Root.** The relay loop (`bridge.rs:211-239`) is strictly
-read-line → `drive_turn` (blocks to `agent_end`) → next line. While a turn runs,
-no further deliveries are drained, and the mid-turn `steer` / `follow_up`
-interrupts advertised in `OMP-ADAPTER-PLAN.md` are not wired. A long or hung turn
-stalls all delivery for the endpoint.
-
-**Fix.** Decouple delivery from turn execution; wire `steer` so a hung/rescoped
-turn can be interrupted.
-
-## MEDIUM-2 — Dead omp child detected only on the next message
-
-**Root.** `child_exited()` is checked only at the top of the loop, *after* a new
-`spt ready` line arrives (`bridge.rs:216`). While the perch is idle the bridge is
-blocked on `ready_out.lines()`; if the omp child dies there, the bridge doesn't
-notice. The perch stays online/idle and only discovers the dead child when the
-next message arrives (then returns an empty reply — see MEDIUM-5).
-
-**Fix.** Watch the omp child concurrently (the reader thread from HIGH-4 sees its
-EOF); on exit, mark the perch offline and tear down.
-
-## MEDIUM-3 — `omp` binary resolution is PATH-last with a known alias collision
-
-**Root.** `omp_bin()` (`bridge.rs:486-504`) resolves `OMP_SPT_OMP_BIN` → install
-paths → PATH `omp`. The code's own comment (`:482-485`) notes PATH `omp` may be
-the OneCLI **gateway alias**, not the coding agent. If the install paths are
-absent and only the gateway alias is on PATH, the bridge spawns the wrong binary,
-which does not speak `--mode rpc` → it wedges at `wait_for_ready` (HIGH-4) or
-exits to `FAILURE`. Nothing validates that the resolved binary is actually
-oh-my-pi.
-
-**Fix.** After spawn, validate the `ready` handshake within a deadline and/or
-probe `--version`; refuse loudly with the resolved path if it is not omp.
-
-## MEDIUM-4 — omp-spt bind traps the endpoint's adapter (spt-core interop)
-
-**Symptom.** After the broken omp session, the endpoint could not be resumed or
-restarted under claude-spt — every attempt relaunched omp-spt. Recovery required
-editing spt-core's session ledger by hand.
-
-**Root (interop).** The bridge binds via `spt api --adapter omp-spt bind`
-(`bridge.rs:167`), so spt-core records `omp-spt` in the endpoint's session ledger
-(`sessions.log`). spt-core's resume path re-stamps the endpoint to the
-*last-recorded* session adapter before spawning (REQ-RESUME-ADAPTER-FOLLOWS-SESSION),
-so a broken omp-spt session pins the endpoint on omp-spt. The adapter provides no
-supported stop/unbind/switch path back.
-
-**Fix.** Provide (and document) a clean unbind/switch so an operator can move an
-endpoint off omp-spt without ledger surgery. Ideally a failed bringup should not
-leave a poisoning ledger row — bind only once the omp `ready` + `get_state`
-handshake has actually succeeded (it already binds after `get_state`, but see
-HIGH-4: without a deadline the failure mode is a hang, not a clean no-bind).
-
-## LOW-1 — Errors universally swallowed
-
-Every `spt_call` result is discarded with `let _ =` (`bridge.rs:180, 226, 228,
-233, 437`). Bind/state/send failures are invisible unless `OMP_SPT_DEBUG` is set.
-This compounds HIGH-3. Surface failures on the always-on log.
-
-## LOW-2 — Empty reply sent on a failed turn
-
-`drive_turn` returns `None` on EOF-before-`agent_end`; the caller does
-`.unwrap_or_default()` (`bridge.rs:227`) and sends an **empty** reply to the
-sender, then flips the perch `idle`. A failed turn is indistinguishable from a
-successful empty answer. Distinguish turn failure from an empty result and report
-it.
-
----
-
-## Suggested priority
-
-1. HIGH-2 (orphan reaping) and HIGH-1 (binary rename) — these two caused the
-   unrecoverable-without-intervention state.
-2. HIGH-4 (timeouts) and HIGH-3 (visibility) — these turn a silent wedge into a
-   diagnosable, self-healing one.
-3. MEDIUM-4 (clean adapter switch) — so a bad session is recoverable by the
-   operator alone.
-
-The core Style-A architecture (drive omp over `--mode rpc` rather than scraping
-hooks) is sound; every issue above is in the bridge's process-lifecycle and
-observability plumbing, not the protocol mapping.
+# OMP integration field issues
+
+Status: **bridge experiment retired; native successors tracked** (2026-07-14)
+
+This record closes the field failures observed when `omp-spt` temporarily used
+a headless RPC child as the hosted endpoint. ADRs 0008–0013 removed that
+topology. The table preserves the paid-for findings without treating the bridge
+as a supported or repairable product surface.
+
+## Retired incident findings
+
+| Finding | Native disposition | Status |
+|---|---|---|
+| Helper executable was indistinguishable from another harness adapter | `omp-spt` is only the adapter helper; `host_binaries` advertises only `omp`, and the launch shim validates the real Oh My Pi executable | Closed by cutover |
+| Nested bridge/listener children survived endpoint stop | There is no nested bridge process tree; the extension owns listener teardown inside the native OMP process | Closed by cutover |
+| Attached operators saw logs rather than the agent interface | Native OMP owns the broker PTY for every endpoint | Closed by cutover |
+| Blocking RPC reads could wedge forever | RPC turn driving is removed; extension submission is event-driven and listener recovery is bounded | Closed by cutover |
+| One relay blocked all later deliveries | The extension serializes explicit custody and advances after a reply or reported failure | Closed by cutover |
+| Child death was discovered only on the next message | Listener exit is observed directly and starts bounded recovery | Closed by cutover |
+| Bare executable lookup could select a collision | Fresh/resume launch share a validating native resolver | Closed by cutover |
+| A failed turn emitted an empty reply | A failure outcome is explicit and correlated; it is never converted to an empty success | Closed by cutover |
+| Adapter binding trapped a session on the experimental topology | The experimental topology no longer exists; changing OMP sessions requires explicit endpoint relaunch | Closed by cutover |
+
+## Native release blockers
+
+These are the successor checks, not bridge follow-ups:
+
+1. **Custody:** every accepted delivery ends in a correlated answer or explicit
+   failure, including OMP submission rejection.
+2. **Listener lifecycle:** recovery is bounded; exhaustion performs session-end
+   and OMP shutdown, leaving no false-online endpoint.
+3. **Session identity:** in-TUI switching is blocked; native resume happens only
+   at endpoint launch.
+4. **Executable identity:** the resolver rejects a non-Oh-My-Pi `omp`, and the
+   adapter helper is never a host match key.
+5. **Operator surface:** fresh and resumed endpoints expose the native,
+   attachable OMP TUI.
+6. **Release boundary:** same-node message/turn/reply behavior is required;
+   cross-node transport is not re-tested by the adapter.
+
+## Public-contract status
+
+- **SPT seams:** complete on the published manifest plus `spt api` surface.
+- **Relative continuity path:** expressible and supported on spt-core v0.29.0;
+  `.spt/` resolves against the endpoint's recorded cwd, not the daemon cwd.
+- **OMP skill distribution:** **open public-contract gap.** No OMP-native
+  command/skill registration and release path has been proven for this adapter,
+  so no skills are shipped. The removed foreign plugin is not a fallback.
+- **Cross-node adapter acceptance:** intentionally absent; subnet transport is
+  owned and tested by spt-core.
+
+The retired RPC implementation and acceptance test carry no active requirement
+evidence.
diff --git a/docs/PARITY.md b/docs/PARITY.md
index a69ed18..f85bb59 100644
--- a/docs/PARITY.md
+++ b/docs/PARITY.md
@@ -1,103 +1,82 @@
-# Parity audit — claude-spt vs the legacy owl surface
-
-> The reconciliation record: the adapter's operative surface measured against the **LOCKED
-> parity-trim** in `SCOPE.md` (KEEP / ADD / DROP / TRANSFORM). This is the **"proven parity"**
-> gate the `sptc`→`spt` succession flip depends on (see `docs/RELEASE-RUNBOOK.md` +
-> `docs/KNOWN-HAZARDS.md`): the name flip happens only once this audit shows no unresolved
-> divergence AND legacy owl is retired. Audited 2026-06-15 against published spt v0.7.2.
->
-> Public-surface-only binds (AGENTS.md): a capability missing from the published `spt` surface is
-> a **finding**, never a reason to reach into spt-core source.
-
-<!-- [doc->REQ-PARITY-AUDIT] -->
-
-## Disposition matrix
-
-| Surface | SCOPE bucket | Adapter today | Status |
-|---|---|---|---|
-| `/live` | KEEP | operative — `skills/live.md` (base-manifest `[session.psyche_init]` + bare `api listen` + Monitor relay; Option A, no `:live` profile) | ✅ parity |
-| `/commune` | KEEP | operative — full-fat plugin SKILL (agent-self-driven, not injected) | ✅ parity |
-| `/ready` | KEEP | operative — `skills/ready.md` (injected) | ✅ parity |
-| `/send` | KEEP | operative — full-fat plugin SKILL (agent-self-driven, not injected) | ✅ parity |
-| `/list-agents` | KEEP (→ `spt endpoint list`) | operative — `skills/list-agents.md` (injected) | ✅ parity |
-| `/signoff` | KEEP (harness-hosted v1) | operative — full-fat plugin SKILL (agent-self-driven, not injected) | ✅ parity |
-| `/force-stop` | KEEP (topology-aware) | operative — `skills/force-stop.md` | ✅ parity |
-| `/spt:setup` | ADD | operative — `skills/setup.md` | ✅ parity |
-| `/spt:version` | ADD | operative — `skills/version.md` | ✅ parity |
-| profiles + strings + hints | ADD | wired (`:ccs`, `[strings]`, `[[hints]]`; live-capability is in base, not a profile) | ✅ parity |
-| subnet skill (status/create/show-code/join) | ADD (LOCKED) | operative — `skills/subnet.md` (wraps `spt subnet`) | ✅ parity (REQ-SKILL-SUBNET) |
-| ccs profile (`claude-spt:ccs`) | ADD (LOCKED) | operative — `[profiles.ccs]` overlay + CLAUDE_CONFIG_DIR-aware extractor | ✅ parity (REQ-CCS-PROFILES) |
-| `/whoami` skill | **DROP** (core `spt whoami` stays → M12 `endpoint list` alias) | removed (was carry-over) | ✅ dropped |
-| `/new-alarm` | accepted gap | dead stub, no manifest entry | ⏸️ DEFER + remove stub |
-| `/fork` | DROP | absent | ✅ confirmed absent |
-| `/amend-signoff` | DROP | absent | ✅ confirmed absent |
-| `/revive` | DROP (daemon owns liveness) | absent | ✅ confirmed absent |
-| `/clear-psyche` | DROP (= delete+recreate endpoint) | absent | ✅ confirmed absent |
-
-TRANSFORM bucket (already realised, not skills): capsule→spt-hosted+`cc` (`[session.self]` +
-`shortcut_basename="cc"`); echo-commune→`[digest]` extractor (`claude-spt digest`); psyche-sync→
-`/spt:setup`; doctor→setup-verify; working-perches→`api worker-start/stop` hooks. ✅
-
-## Open divergences and dispositions
-
-### subnet skills — LOCKED-ADD gap → BUILD
-The published surface carries the verbs (`spt subnet {create,join,show-code,status,…}`), and v1
-topology scope is **mandatory** (operator vetoed harness-hosted-only — cross-subnet/PTY proof is
-spt-core's central value prop, SCOPE). So this is a real gap to fill, not defer. → `REQ-SKILL-SUBNET`.
-
-### ccs profile — LOCKED-ADD gap → BUILT ✅
-<!-- [doc->REQ-CCS-PROFILES] -->
-SCOPE §ccs (LOCKED): ccs ships as a **profile template** under the adapter that retargets the spawn
-command template through `ccs`, with ccs's relocated log dir honored. Templates only — the user
-supplies their own ccs config/keys. **Operator ruling (2026-06-15):** the shipped profile is
-`claude-spt:ccs` invoking **bare `ccs`** (the account set via `ccs auth default <name>`), NOT
-`glm`/`kimi` — those were SCOPE *examples*; this profile IS the worked example of adapter-profile
-authoring **and** the operator's own SPT-ecosystem hook. Built + validated against the known-good
-sister project **claude_skill_owl**:
-- **Spawn seam.** `[profiles.ccs.session.self].command = "ccs"` leaf-replaces the base `claude`.
-  owl proves ccs is a drop-in for the `claude` binary on the same argv (`live/wrapper/claude.rs`
-  Tier-2 PULSE recovery latches `cli_binary = "ccs"`); `SPT_ENDPOINT_ID` rides inherited env through
-  the wrapper unchanged.
-- **Log-dir seam → in the extractor, not a manifest leaf.** ccs relocates CC's whole state tree
-  (incl. `projects/`) via the **`CLAUDE_CONFIG_DIR`** env var (`~/.ccs/instances/<account>/.claude`),
-  a per-account runtime value with no static catalog path. SCOPE's "per-profile `~/.ccs` log dir"
-  is therefore honored **in `claude-spt digest`** (dir-locate branch prefers `$CLAUDE_CONFIG_DIR/
-  projects` over the `--in` root) — the owl-validated `owlery::claude_projects_root` pattern. The
-  base `[digest]` config thus serves base **and** ccs sessions transparently; no `[profiles.ccs.
-  digest]` leaf. This env-aware resolver is REQ-CCS-PROFILES's `impl`/`unit` evidence (a `.toml`
-  profile leaf alone does not register as `impl`).
-- **Finding (refines SCOPE's model).** SCOPE conflated ccs *profiles* (glm/kimi = API-provider
-  env-swap, NO transcript relocation) with ccs *accounts* (isolated instances that DO relocate via
-  `CLAUDE_CONFIG_DIR`). The operator runs the account/default path, which relocates — so the digest
-  seam is real, but its mechanism is `CLAUDE_CONFIG_DIR`, not a fixed `~/.ccs` path. → `REQ-CCS-PROFILES`.
-
-### `/whoami` skill — DROP (honoring LOCKED)
-SCOPE DROPs the whoami **skill**; core `spt whoami` stays in the hot path (and becomes the
-`endpoint list` alias in M12). The adapter currently still ships a whoami skill (a carry-over from
-an early slice). Operator confirmed the drop 2026-06-15. Action: remove `[strings.skills].whoami` +
-the file body + the plugin stub; redirect the "who am i" hint to core `spt whoami`. No REQ rides
-whoami evidence (the file-backed-string + UPS-injection int examples repoint to `skills.ready`;
-the hook-parser unit examples repoint to a surviving skill name). Core `spt whoami` calls in the
-hooks (`session-start.sh`, `_common.sh`) are the CLI, not the skill — they STAY.
-
-### `/new-alarm` — ACCEPTED GAP (deferred-pending-arrangement-system)
-**Not missing — deliberately deferred.** doyle triage (2026-06-15): spt-core carries only the
-alarm *event shape* (spt-proto) + relay handling (psyrelay.rs) + a test fixture; the durable
-"fire-at-target-time" timer still lives in legacy owl in-memory, and an in-daemon durable scheduler
-is a deliberate deferral (DEFERRED.md:43 — deferred because the daemon had no
-one-shot consumer; building pre-consumer = untested dead code). The **operator has a superseding
-"arrangement" system** in mind that would replace the alarm port. Disposition: **do not build an
-adapter-side stopgap timer** (throwaway vs the coming model); **no REQ minted**; **remove the dead
-`/sptc:new-alarm` stub** from the published surface (deferred ≠ shipping a no-op skill). doyle loops
-me when the arrangement design surfaces.
-
-## Parity verdict
-**PROVEN (adapter surface).** All three open divergences are closed this slice: subnet skill added
-(`skills/subnet.md`, REQ-SKILL-SUBNET), ccs profile added (`[profiles.ccs]` + CLAUDE_CONFIG_DIR-aware
-extractor, REQ-CCS-PROFILES), whoami skill dropped. The full KEEP/ADD set is ✅ and the DROP set is
-confirmed absent. `/new-alarm` is an accepted, documented gap (deferred-pending-arrangement-system)
-and does **not** block the verdict.
-
-The `sptc`→`spt` succession flip remains separately gated (NOT unblocked by this verdict alone):
-it also requires **legacy owl retired** (KNOWN-HAZARDS / RELEASE-RUNBOOK) and rides the live-relay
-int held for spt-core M11 counter-15. This audit clears only the parity precondition.
+# OMP-native cutover and parity record
+
+> This is the current product record for
+> [`BigscreenVR/omp-spt`](https://github.com/BigscreenVR/omp-spt). It replaces the inherited
+> adapter-parity audit. Under ADR-0008, parity now means complete coverage of the native OMP
+> contract exposed through public spt-core surfaces.
+
+## Product boundary
+
+`omp-spt` supports native Oh My Pi endpoints only. The Claude Code adapter and its Claude
+plugin, `ccs` integration, `/sptc:*` namespace, hook-driven delivery, `cc-launcher`, and RPC
+bridge topology are retired lineage. They are superseded by ADR-0008 and are intentionally not
+current compatibility or parity goals.
+
+This cutover is clean: a missing native OMP capability is a parity finding, while a difference
+from retired lineage is not. Adapter work binds only to the published spt-core CLI, manifest,
+messaging, lifecycle, and release contracts. It does not depend on private spt-core internals.
+
+## Native surface record
+
+| Capability | Current `omp-spt` contract | Source of truth |
+|---|---|---|
+| Install | `spt adapter add --release BigscreenVR/omp-spt` acquires the default `adapter.spt` release asset and registers `omp-spt`. | Public `spt adapter` release-install surface and `[update]` manifest contract |
+| Update | `spt adapter update omp-spt` refreshes the installed adapter. A running endpoint keeps its existing hosting path until it is stopped and relaunched. | Public `spt adapter update` surface and `adapter/omp-spt.toml` |
+| Fresh endpoint launch | `spt endpoint run --adapter omp-spt --id atlas --create` creates and launches a native OMP endpoint. Native attach is the default; no separate start mode is part of this adapter contract. | `[session.self]` and ADR-0009 |
+| Attach | `spt rc atlas` attaches to the broker-held terminal and displays the same native OMP TUI that owns the hosted session. | Public spt-core endpoint attach surface and ADR-0009 |
+| Hostable roles | The adapter hosts `ReadyAgent` and `LiveAgent`. Both use native OMP; `LiveAgent` also activates the daemon-driven Psyche role. OMP subagents are not independent SPT endpoints. | `hostable_types` and `[session.psyche_*]` in `adapter/omp-spt.toml` |
+| Messaging and correlated replies | The packaged OMP extension serializes inbound SPT messages, submits each as one OMP turn, preserves the sender envelope as context, and returns that turn's final assistant response to the originating sender. Submission failures and turns without a response produce explicit failure replies. | `adapter/strings/omp-spt.mjs` and ADR-0010 |
+| Lifecycle and activity | The extension binds the native OMP session to the endpoint, reports busy and idle transitions, retries a failed listener with a bounded budget, fails closed if delivery cannot recover, and ends the SPT session during OMP shutdown. | `adapter/strings/omp-spt.mjs` and ADR-0010 |
+| Native resume and immutable binding | `[session.resume]` launches OMP with its native resume selector. Once bound, one endpoint owns exactly one OMP session for its lifetime. In-TUI switching and resume are blocked; using another session requires stopping the endpoint and relaunching with an explicit resume target. | `[session.resume]`, ADR-0011 |
+| Continuity | Commune and signoff drops live under the project-local `.spt/` directory and remain endpoint-qualified. They belong to SPT continuity, not OMP configuration. | `[session]` and ADR-0012 |
+| Digest and history | History returns the opaque JSONL for exactly one OMP session. The digest extractor reads that session and emits a bounded, turn-oriented summary through the public spt-core digest contract. | `[history]` and `[digest]` in `adapter/omp-spt.toml` |
+| Distribution | Releases publish one multi-platform `adapter.spt` containing the root manifest, shared `strings/omp-spt.mjs`, and supported host binaries. spt-core selects the host payload during install and update. | `ci/publish/package-adapter.sh` and `[update]` |
+
+## Ownership boundary
+
+The native endpoint has one ownership chain:
+
+```text
+public spt-core command
+        |
+        v
+spt-core broker-held terminal
+        |
+        v
+native OMP TUI + packaged omp-spt extension
+        |
+        +-- session bind and immutable identity
+        +-- serialized message delivery and correlated reply
+        +-- busy/idle activity and lifecycle shutdown
+```
+
+spt-core owns endpoint orchestration, the terminal, messaging transport, and network topology.
+OMP owns the interactive session and TUI. The packaged extension is the adapter seam inside OMP;
+it binds those two public contracts without introducing a second hosted process model.
+
+## Release verification boundary
+
+Every change is covered at the deterministic adapter boundary: extension behavior, manifest
+shape, native session launch and resume templates, digest/history behavior, and daemon-role
+behavior. A release also requires a real native OMP endpoint to prove:
+
+1. fresh bringup and an attachable native TUI;
+2. same-node message receipt, one OMP turn, and a correlated reply;
+3. busy and idle activity transitions;
+4. native resume and refusal of in-TUI session switching;
+5. graceful shutdown; and
+6. `ReadyAgent` and `LiveAgent` behavior.
+
+Cross-node messaging is not an adapter release gate. Once same-node delivery proves that
+`omp-spt` hands the published message contract to spt-core correctly, subnet transport is wholly
+inside the spt-core boundary and exposes no additional OMP adapter seam. This boundary is fixed
+by ADR-0013.
+
+## Verdict
+
+The scoped native OMP surface is the parity target. Install and update, native launch and attach,
+the two hostable roles, message/reply custody, lifecycle and activity, immutable native resume,
+continuity, digest/history, and the release boundary form one coherent product contract.
+
+Retired adapter behavior does not gate `omp-spt` releases and must not be reintroduced as an
+alternate path.
diff --git a/docs/RELEASE-RUNBOOK.md b/docs/RELEASE-RUNBOOK.md
index 393c92b..7b4e72c 100644
--- a/docs/RELEASE-RUNBOOK.md
+++ b/docs/RELEASE-RUNBOOK.md
@@ -1,262 +1,232 @@
 # Release runbook
 
-> How an spt-claude-code release ships. The spine is fixed (changelog · bump · regenerate
-> docs · tag · publish · docs publish). **Release here is LIGHT: signing is DELEGATED to the
-> `spt` binary — there is NO two-key signing ceremony in this project.** spt-claude-code is a
-> thin adapter; the heavy signed-release machinery lives in spt-core, not here.
-
-<!-- [<doc>->REQ-EXAMPLE-REL] (illustration; escaped per docs/TRACEABILITY.md) -->
-
-## Publish targets
-
-An spt-claude-code release lands in **two places**, by volatility:
-
-1. **The `SaberMage/cplugs` marketplace** — the thin **skeleton plugin** (namespaced
-   `/spt:*` skill skeletons, `hooks.json`, the SessionStart bootstrap, `plugin.json`). This
-   is low-churn: it only changes on **structural** plugin changes, not on logic/instruction
-   updates.
-2. **The spt-core adapter registry** — the volatile bulk: the CC adapter **manifest**
-   (`[digest]` extractor, profiles, strings, hints) **+ binary**. This publish is
-   **spt-core-conducted** (the same framework that conducts adapter updates), not a plugin
-   file push.
-
-## One-time setup
-
-No signing-key ceremony in this project. **Signing is delegated to the `spt` binary**, which
-handles adapter manifest/binary integrity through spt-core's own signed-update framework. Keep
-no release keys here. The only setup is marketplace/registry publish credentials for the two
-targets above (a `cplugs` push token + whatever the spt-core adapter-registry publish step
-requires).
-
-## Per release
-
-1. **Bump** the version (the plugin `plugin.json` version and/or the adapter manifest version —
-   note these are distinct numbers; see Notes) if needed; **regenerate generated docs**
-   (the mdBook `docs-site/` build + `llms.txt` / schema / CLI-help exports); land everything
-   green.
-2. **Write the user-facing changelog** — add a `## [<version>] - <date>` section at the top of
-   `CHANGELOG.md` with **Added / Changed / Fixed** subsections. This section becomes the public
-   release body verbatim, so it is the changelog every user reads. Rules:
-   - **User-facing UX only.** What a person using the product notices or does differently. Name
-     the actual commands / flags / surfaces they touch (`/spt:*` skills, `cc`, `/spt:setup`).
-   - **No internal lingo** — no requirement ids, internal module names, commit hashes, or
-     milestone / hazard codes. A reader who has never seen the source must understand every line.
-   - **Use spt nomenclature** (operator rule, 2026-07-03) — product terms (Psyche, live agent,
-     perch, endpoint, node, subnet) ARE the user-facing language; never substitute an invented
-     softer synonym (e.g. "companion" for Psyche). "No internal lingo" bans *implementation*
-     vocabulary, not the product's own names.
-   - **No code, environment, or test-environment specifics** (operator rule, 2026-07-02) — no
-     source paths, env vars, hook/event names, state-file layouts, machine or endpoint names, and
-     no debugging/incident narrative. The finding log and commit messages hold the forensics; the
-     release notes hold only what changes for the user.
-   - **Succinct** — a few sentences per change describing the before/after a user experiences,
-     plus the recovery step if one exists. Never a wall of text; if a change needs paragraphs to
-     explain, that explanation belongs in the docs, linked, not in the notes.
-   - **No manual word-wrap** (operator rule, 2026-07-03) — do NOT hardcode newlines to wrap a
-     bullet or blockquote across multiple physical lines. GitHub renders the release body and
-     word-wraps it for you; a hand-wrapped line becomes a forced break in the rendered notes. Write
-     each bullet / blockquote / paragraph as **one physical line** and let the display wrap it. Only
-     structural newlines belong in a section: blank lines between paragraphs/subsections, the `###`
-     headers, and the boundary between separate `-` bullets. (To unwrap an already-wrapped file:
-     `python ci/publish/unwrap-changelog.py CHANGELOG.md`, then re-push each body from its section —
-     the release body is the section verbatim minus its `## [<version>]` header, so
-     `gh release edit v<X> --notes-file <section-body>` per release.)
-   - **Flag breaking changes** prominently under Changed.
-   - The release **fails loudly** if the tagged version has no `## [<version>]` section — the
-     changelog is not optional.
-3. **Parked-work exclusion check** (pre-tag guard — **the tag tree IS the release**). A release
-   ships **whatever is in the tagged commit's tree**, not "what you meant to change." Before tagging,
-   confirm the release HEAD carries **no gated-publish / parked work** that this release is not
-   intentionally shipping. This is not hypothetical: **v0.13.2 was cut from a HEAD that still carried
-   the parked ephemeral-psyche redesign** (its `[session.psyche_resume]` table + run-to-completion
-   shim), publish-gated on a future core floor. It shipped early and bricked live endpoints on cores
-   without the driver — forcing a revert, a `*-parked` branch rescue, and a clean re-cut (v0.13.3).
-   The discipline:
-   - **Know your parked work.** Gated-publish work is tracked in the session commune and lives on
-     branches named `*-parked` (e.g. `psyche-ephemeral-parked`). It is often **also an ancestor of
-     `main`** (committed, then reverted) — so "it's reverted on main" does **not** guarantee it's
-     absent from an arbitrary HEAD. Verify the *tree*, not the history.
-   - **Assert its signature is absent** (unless THIS release intentionally publishes it, with the
-     floor bump + changelog to match). For the ephemeral-psyche case the signature is the manifest
-     table: `git show <release-HEAD>:adapter/claude-spt.toml | grep -q 'session.psyche_resume' &&
-     echo "PARKED WORK PRESENT — do not tag" || echo "clean"`. Generalize per parked feature:
-     grep the tag tree for the feature's defining seam.
-   - **When a release DOES ship formerly-parked work**, it is deliberate: the `min_spt_core` floor
-     moves to the enabling core release **and** the changelog names the new user-facing behavior.
-     Absent both, a present-in-tree parked seam is an accident — stop and re-cut from a clean HEAD.
-   - *(Follow-on: a `ci/publish/` guard that refuses to pack when the tree carries a registered
-     parked seam without an explicit override would make this a gate rather than a checklist item.)*
-4. **Tag**: `git tag <vX.Y.Z> && git push origin <vX.Y.Z>`. This triggers:
-   - the **docs-publish workflow** — build `docs-site/` and publish to GitHub Pages (drift-gated;
-     see `docs/DOCS-STRATEGY.md`).
-5. **Publish** (light — signing delegated to `spt`):
-   - **Skeleton plugin** → push to the `SaberMage/cplugs` marketplace **only when the plugin
-     skeleton structurally changed** (new/removed skill skeleton, hook wiring, bootstrap, or
-     `plugin.json`). Most releases do not bump the marketplace.
-   - **Manifest + binary** → publish through the **spt-core adapter registry**; the `spt`
-     binary performs signing/integrity as part of spt-core's adapter-update framework. You do
-     **not** run a separate signing step.
-
-## cplugs skeleton publish — concrete mechanics
-
-<!-- [doc->REQ-DIST-PLUGIN-SKELETON] -->
-The concrete cplugs marketplace steps, captured from the sister project's
-`claude_skill_owl/docs/DEPLOY.md`. **Take only the SKELETON SUBSET.** spt-claude-code's cplugs
-target is the **thin skeleton** — `/spt:*` skill skeletons, `hooks.json`, the SessionStart
-bootstrap, `plugin.json`. **No binary, no manifest in cplugs** — the binary + adapter manifest
-ride the **spt-core adapter registry** (spt-conducted; the *other* publish target above), so
-none of owl's binary-lifecycle machinery applies here.
-
-> **Now scripted (`ci/publish/`).** The validate + stage mechanics below are codified:
-> `ci/publish/validate-skeleton.sh` is a binary installability gate (valid `plugin.json` with
-> `name=sptc`; valid `hooks.json` whose referenced wrappers all exist; every skill has a
-> `SKILL.md`; **no runtime-state / binary / manifest leak in the published surface**) — it runs in
-> `ci/run-gates.sh` (the `skeleton-validate` gate) and is unit-tested by `tests/skeleton-validate.sh`.
-> `ci/publish/package-skeleton.sh` codifies the per-bump copy below — validates first, **dry-run by
-> default**, stages only the skeleton subset, never pushes (the marketplace commit/push stays the
-> operator's step).
-
-**One-time marketplace setup:**
-
-```bash
-# Clone the marketplace repo
-git clone https://github.com/SaberMage/cplugs.git ~/.claude/plugins/marketplaces/cplugs
-# Register a "cplugs" entry in ~/.claude/plugins/known_marketplaces.json
-#   source: { source: "github", repo: "SaberMage/cplugs" }
+`omp-spt` has one release topology: this repository builds one multi-platform `adapter.spt`, and the GitHub release for `BigscreenVR/omp-spt` publishes that file under the default asset name `adapter.spt`.
+
+<!-- [doc->REQ-DIST-ADAPTER-RELEASE] -->
+
+The archive contains the complete adapter:
+
+```text
+manifest.toml
+strings/omp-spt.mjs
+x86_64-pc-windows-msvc/omp-spt.exe
+x86_64-unknown-linux-gnu/omp-spt
 ```
 
-**Per skeleton bump** (only when the skeleton *structurally* changes — see "Per release"):
-
-```bash
-# 1. Bump plugin.json version. The plugin manager compares this to the cached copy and
-#    SKIPS the update entirely if they match — a stale version = a silent no-update.
-# 2. Copy skeleton files (NO binary) into the marketplace clone:
-MARKET=~/.claude/plugins/marketplaces/cplugs/plugins/sptc
-cp -r skills/*  "$MARKET/skills/"
-cp -r hooks/*   "$MARKET/hooks/"
-cp .claude-plugin/plugin.json "$MARKET/.claude-plugin/"
-# 3. Commit + push the cplugs repo:
-cd ~/.claude/plugins/marketplaces/cplugs && git add plugins/sptc/ \
-  && git commit -m "sptc: <change>" && git push
+spt-core keeps the shared root and flattens the current node's recognized target directory into the installed adapter directory. There are no per-platform release assets. Installing this one asset completes adapter installation; there is no secondary publication target or session reload action.
+
+User commands are:
+
+```sh
+spt adapter add --release BigscreenVR/omp-spt
+spt adapter update omp-spt
+```
+
+## Release prerequisites
+
+The release operator needs:
+
+- write access to `BigscreenVR/omp-spt` and an authenticated `gh` CLI;
+- Rust and Cargo for the `tools/omp-spt` crate;
+- Node.js for the native extension tests;
+- Python with TOML and `jsonschema` support for manifest validation;
+- `traceable-reqs` for the required coverage gate;
+- Zig plus `cargo-zigbuild` when cross-building the Linux binary from Windows; and
+- a disposable acceptance node with compatible `spt` and real `omp` installations.
+
+The release commit must contain the intended `adapter/omp-spt.toml`, `adapter/strings/omp-spt.mjs`, helper source, tests, and changelog. The tag tree is the release source of truth.
+
+## 1. Set the version and release notes
+
+Set `[adapter].version` in `adapter/omp-spt.toml` to `X.Y.Z`. The Git tag and GitHub release tag must be `omp-spt-vX.Y.Z`.
+
+Add `## [X.Y.Z] - YYYY-MM-DD` at the top of the current `omp-spt` section in `CHANGELOG.md`. Release notes must describe user-visible changes, required spt-core or OMP version changes, breaking behavior, and recovery steps. Do not include requirement ids, source paths, test-machine details, commit hashes, or incident forensics.
+
+Each release-note paragraph, blockquote, and bullet should be one physical line so GitHub performs display wrapping. If needed, the repository includes the verified normalizer:
+
+```sh
+python ci/publish/unwrap-changelog.py CHANGELOG.md
 ```
 
-**Pointer flip** (the authoritative install-state update):
+Prepare `<release-notes-file>` from that version's changelog body, excluding the `## [X.Y.Z] - YYYY-MM-DD` heading.
+
+## 2. Run deterministic gates
 
-```bash
-claude plugin install sptc@cplugs   # un-orphans + rewrites installed_plugins.json atomically
-# then, inside Claude Code:
-/reload-plugins
+From the repository root:
+
+```sh
+sh tests/ci-gates.sh
+sh ci/run-gates.sh
+node tests/omp-extension.mjs
 ```
 
-**Gotchas (these DO apply to the skeleton):**
-- **Never hand-patch `installed_plugins.json`** (`jq`/`sed` are brittle; CC may silently reject).
-  Use the `claude plugin install` CLI — it's the atomic pointer flip + orphan-marker cleanup.
-- **No legacy manual-install dir alongside the marketplace install.** A `~/.claude/plugins/<name>/`
-  regular dir coexisting with the marketplace cache install makes `/plugin` report the plugin
-  **not installed** (CC enumerates both; the untracked one wins the conflict). Keep the two exclusive.
-- **Restart the Claude Code session after install** so the SessionStart hook re-runs and repopulates
-  the plugin's env (`$OWL`/`$LIVE` equivalents) in Bash subprocesses.
+All commands must pass. For a release, a dependency-related `SKIP` is not a pass. Install the missing dependency and rerun. See `docs/CI.md` for the deterministic coverage and the separate real-endpoint acceptance bar.
 
-**Explicitly NOT ours** (owl ships a live self-migrating binary; the thin skeleton has none, so
-skip all of it): `owl.exe` binary sync · the cache targeted-prune + keep-PREVIOUS-version logic ·
-the seamless binary handoff (owl Phase 18.4/18.5) · `DEPLOY.ps1`'s build/handoff orchestration.
+## 3. Build both platform binaries
 
-> **RULED (operator, 2026-06-14) — cplugs plugin name = `sptc`.** CC ties the skill prefix to the
-> `plugin.json` name (no override), so skills surface as `/sptc:*`. **Succession:** once parity is
-> proven, flip `plugin.json` name `sptc`→`spt` (skills → `/spt:*`) and retire/rename legacy owl's
-> cplugs `spt` plugin in the same coordinated move — two plugins cannot share the `spt` name. The
-> flip is a single substitution `s/sptc/spt/` (plugin dir, `plugin.json` name, marketplace path).
+The verified packer requires exactly one Windows binary and one Linux binary.
 
-## adapter manifest publish — the `adapter.spt` release asset
+Build and test the native Windows release binary:
 
-<!-- [doc->REQ-DIST-ADAPTER-RELEASE] -->
-The CC adapter manifest (publish target #2) ships to end users as an **`adapter.spt`** GitHub
-**release asset** on this monorepo, acquired with **`spt adapter add --release SaberMage/claude-spt`**
-(doyle's `--release` source; needs **spt v0.7.3+ / counter 15** — not in 0.7.2). No dedicated
-adapter repo: the asset is packed straight from `adapter/`.
-
-Since v0.6.1 the asset is **ONE multi-platform fat `adapter.spt`** (ADR-0024 W1, spt-core ≥ 0.13.2):
-a single archive bundles every supported platform's binaries, and install auto-resolves the host's.
-This RETIRED the F-014 per-OS stopgap — there is no longer a default-vs-per-OS-asset split.
-
-- **Pack:** `sh ci/publish/package-adapter.sh` (DRY-RUN) → `--apply` writes the single
-  `dist/adapter.spt`. It validates the manifest, refuses a `min_spt_core_version < 0.13.2` (a fat
-  archive needs it), requires **both** platforms' built tool binaries, and tars the archive **ROOT** =
-  `manifest.toml` (renamed from `claude-spt.toml` — `adapter add` is root-only + exact-name) +
-  `strings/` **shared at root**, plus each recognized target-triple's binaries under a `<triple>/` dir.
-  Never uploads (operator's step).
-<!-- [doc->REQ-DIST-ADAPTER-PEROS] -->
-- **Fat layout (REQ-DIST-ADAPTER-PEROS).** Recognized triples = **`x86_64-pc-windows-msvc`** (win
-  `.exe`) + **`x86_64-unknown-linux-gnu`** (linux ELF) — the ONLY two spt-core classifies in a fat
-  archive. On install it places the shared root + **flattens this node's `<triple>/*` into the install
-  dir**, so the bare-name command token (`claude-spt` — its digest/psyche/post-update/translate subcommands) still resolves at `<install_dir>/`
-  (REQ-INSTALL-11). **Footgun:** an unrecognized top-level dir is silently treated as a shared-root
-  entry and lands flat — the packer guards this (refuses any stray top-level dir); for a platform
-  beyond the two triples, ship a *separate* single-triple asset via `--asset`, never a third dir here.
-- **Build both platforms first** (the packer needs both binary sets present):
-  - **Windows (native):** `sh ci/digest/build.sh && sh ci/idle-translate/build.sh` →
-    `tools/*/target/release/*.exe`. (`ci/digest/build.sh` builds the consolidated `claude-spt` crate
-    — digest/psyche/post-update; `ci/psyche/build.sh` is a shim that defers to it — ADR-0006/U2.)
-  - **Linux cross-built FROM Windows (proven 2026-06-16):** bare `cargo build --target
-    x86_64-unknown-linux-gnu` fails (`error: linker 'cc' not found` — the crate compiles, only the
-    link needs a Linux linker), so use **`cargo-zigbuild`** (zig supplies the cross-linker):
-    ```sh
-    # one-time: install zig (a self-contained binary) + cargo-zigbuild
-    cargo install cargo-zigbuild
-    # download zig (e.g. 0.14.1) to a dir OUTSIDE the repo (do NOT keep it under tools/ — it's a
-    # traceable-reqs scan root and zig's bundled libc C-headers trip the scanner), put zig.exe on PATH:
-    #   e.g. ~/.sptc-zig/zig-x86_64-windows-0.14.1/zig.exe  →  export PATH="$HOME/.sptc-zig/...:$PATH"
-    rustup target add x86_64-unknown-linux-gnu
-    cargo zigbuild --release --target x86_64-unknown-linux-gnu --manifest-path tools/claude-spt/Cargo.toml
-    ```
-    → `tools/claude-spt/target/x86_64-unknown-linux-gnu/release/claude-spt` carrying a real
-    `ELF x86-64 GNU/Linux` binary (verified). Then `sh ci/publish/package-adapter.sh --apply` packs the
-    win + linux binaries into one `dist/adapter.spt` (ONE tool binary per triple since the D3 fold).
-- **Publish:** attach the single `dist/adapter.spt` to the GitHub release on `SaberMage/claude-spt`.
-  End users `spt adapter add --release SaberMage/claude-spt` (default asset `adapter.spt`, or
-  `--tag <ver>` to pin) — the fat archive auto-resolves the host's binaries, no `--asset` needed. The
-  `[update] avenue = "gh_release"` self-update fetches the same default `adapter.spt`, host-agnostic.
-  - **F-015 note (Windows):** a binary-changing update still can't overwrite a binary a running live
-    agent locks — but spt-core ≥ 0.13.2's W3 fix runs the live psyche from a `<perch>/.live-bin`
-    own-copy, so the install-dir binary stays lock-free (validated 2026-06-22). Strings/hook-only
-    releases always land fine.
-  - **Local dogfood before upload (recommended):** extract `dist/adapter.spt`, flatten this node's
-    triple into a dir (`cp <triple>/* .`), then `spt adapter {translate,digest}-proof claude-spt --dir
-    <dir> --manifest <dir>/manifest.toml` — proves the flattened binaries resolve + run without any
-    upload or registry mutation.
-  - **`/sptc:setup` coupling.** The fat default is host-agnostic, so setup needs no os-detection /
-    `--asset` — a bare `adapter add --release` suffices. (The current setup body still detects os/arch
-    + passes `--asset`; harmless, simplifying it to the bare default is a follow-on.)
-- **Binary (install-dir resolution — REQ-INSTALL-11).** A `--release`/`--github` acquisition extracts
-  the `.spt` archive's `manifest.toml` + `strings/` **+ the tool binary** into the adapter install dir
-  (`…/adapters/_github/<safe>/`). The command templates reference `claude-spt` (digest/psyche/post-update
-  via the command strings; translate via `{adapter_dir}/claude-spt translate`), which spt-core resolves
-  **from that install dir** (v0.8.0 Feature B / REQ-INSTALL-11) — **no PATH placement needed**
-  (dogfood-proven on v0.8.1; F-006 RESOLVED, interim retired). The pack MUST carry the binary (the
-  resolution source). Note:
-  a plain local-dev `spt adapter add <manifest.toml>` copies manifest + strings only (no binaries in the
-  install dir), so local-dev runtime still relies on the built binary being on PATH (e.g. the CI ints
-  prepend `target/release`); the install-dir path is the end-user `--release` story.
-- **Acquisition only:** `--release` does **not** establish an `[update]` self-update route (our
-  manifest declares no `[update]` → COPY-mode registration). Re-acquire a newer version by re-running
-  `--release --tag <newer>`. The signed `file_pull` self-update channel is a separate, later concern.
-
-## Update path (dual, kept in sync)
-
-Users receive updates two ways, and both must stay consistent:
-- **File-pull (the real channel)** — spt-core conducts manifest + binary updates seamlessly;
-  this is how logic and instruction churn reaches users. Version-of-truth = the
-  manifest/binary version spt-core tracks (`spt adapter list` / `/spt:version`).
-- **`claude plugin update` (cautionary, skeleton sync)** — only resyncs the low-churn
-  marketplace skeleton on the rare structural bump. It is NOT the version-of-truth.
-
-## Notes
-
-- **Distinct numbers — never conflate them:** the **plugin (marketplace) version** (in
-  `plugin.json`, bumps rarely) and the **adapter manifest/binary version** (spt-core-tracked,
-  the user-visible version-of-truth). They move on independent schedules — the plugin can sit
-  static across many manifest updates.
-- **Trust model:** adapter manifest/binary integrity is the `spt` binary's responsibility via
-  spt-core's signed-update framework — spt-claude-code defines no separate trust ceremony.
-  (Claude Code has no plugin-file integrity check, which is why the skeleton plugin is safe to
-  in-place-edit; only old version dirs orphan on update and are GC'd after 7 days.)
+```sh
+sh ci/digest/build.sh
+```
+
+This writes:
+
+```text
+tools/omp-spt/target/release/omp-spt.exe
+```
+
+Build the Linux release binary. On Windows, use Zig as the cross-linker:
+
+```sh
+rustup target add x86_64-unknown-linux-gnu
+cargo install cargo-zigbuild
+cargo zigbuild --release \
+  --target x86_64-unknown-linux-gnu \
+  --manifest-path tools/omp-spt/Cargo.toml
+```
+
+This writes:
+
+```text
+tools/omp-spt/target/x86_64-unknown-linux-gnu/release/omp-spt
+```
+
+`cargo install cargo-zigbuild` is one-time setup. Zig itself must also be on `PATH`. A native Linux builder may produce the same target path with its normal Cargo toolchain.
+
+## 4. Pack the single release asset
+
+The repository packer is dry-run by default:
+
+```sh
+sh ci/publish/package-adapter.sh
+```
+
+Review the plan, then create the artifact:
+
+```sh
+sh ci/publish/package-adapter.sh --apply
+```
+
+The applied command writes only:
+
+```text
+dist/adapter.spt
+```
+
+`ci/publish/package-adapter.sh` validates the manifest, enforces a fat-archive-compatible spt-core floor, requires both platform binaries, renames `adapter/omp-spt.toml` to root-level `manifest.toml`, copies the shared `strings/` directory, and self-validates the final tar listing. It rejects unrecognized top-level directories because spt-core would otherwise treat them as shared entries. Do not add another target directory or publish an alternate `.spt` asset without changing the spt-core archive contract first.
+
+For an independent listing check:
+
+```sh
+tar -tzf dist/adapter.spt
+```
+
+The listing must match the four release entries shown at the top of this runbook, allowing the normal directory entries emitted by `tar`.
+
+## 5. Tag and stage the GitHub release
+
+Push the exact release commit and tag:
+
+```sh
+git tag "omp-spt-vX.Y.Z"
+git push origin "omp-spt-vX.Y.Z"
+```
+
+Create a tagged prerelease so the exact hosted asset can be acceptance-tested without making it the latest stable release:
+
+```sh
+gh release create "omp-spt-vX.Y.Z" dist/adapter.spt \
+  --repo BigscreenVR/omp-spt \
+  --verify-tag \
+  --prerelease \
+  --latest=false \
+  --title "omp-spt vX.Y.Z" \
+  --notes-file <release-notes-file>
+```
+
+The uploaded file name must remain exactly `adapter.spt`. Do not upload per-platform variants.
+
+## 6. Verify acquisition and native acceptance
+
+On a disposable acceptance node, first prove tagged acquisition and installed strings with the repository's opt-in integration:
+
+```sh
+OMP_SPT_ACCEPTANCE=1 \
+OMP_SPT_RELEASE_TAG=omp-spt-vX.Y.Z \
+sh ci/publish/release-acquire-int.sh
+```
+
+The integration downloads from `BigscreenVR/omp-spt`, verifies that `omp-spt` registers active from the GitHub release directory, and resolves the packaged adapter label. It temporarily removes the local `omp-spt` registration, so do not run it on a node hosting an endpoint you need to preserve.
+
+Reinstall the tagged candidate, then complete every native endpoint check in `docs/CI.md`:
+
+```sh
+spt adapter add --release BigscreenVR/omp-spt --tag omp-spt-vX.Y.Z
+spt endpoint run --adapter omp-spt --id omp-spt-accept-fresh --create
+```
+
+Release acceptance requires evidence for fresh native bringup, attached OMP TUI, same-node message-to-turn-to-correlated-reply flow, idle/busy/idle state, blocked in-TUI session switching, native launch-time resume, graceful shutdown, and both ReadyAgent and LiveAgent behavior.
+
+Cross-node transport is not an `omp-spt` release gate. Do not delay the adapter release on a subnet routing check after same-node delivery has proved the adapter boundary.
+
+If any acceptance item fails, leave the release marked as a prerelease, fix the source, and cut a new version. Do not replace a tested tag or asset in place.
+
+## 7. Promote and verify the default install path
+
+After all acceptance evidence passes, promote the release:
+
+```sh
+gh release edit "omp-spt-vX.Y.Z" \
+  --repo BigscreenVR/omp-spt \
+  --prerelease=false \
+  --latest
+```
+
+Verify that the latest release is the intended stable tag and has one uploaded release asset named `adapter.spt`:
+
+```sh
+gh release view --repo BigscreenVR/omp-spt \
+  --json tagName,isPrerelease,assets
+```
+
+Finally, on the disposable acceptance node, prove the shared unpinned install command resolves that latest release:
+
+```sh
+spt adapter add --release BigscreenVR/omp-spt
+spt adapter version omp-spt
+```
+
+The reported adapter version must be `X.Y.Z`.
+
+## 8. Verify the update path
+
+On a disposable node that still has the prior stable `omp-spt`, run:
+
+```sh
+spt adapter update omp-spt
+spt adapter version omp-spt
+```
+
+The update must install `X.Y.Z` from the same default `adapter.spt`. A running endpoint keeps the extension and helper it loaded at bringup; restart it to exercise the new release:
+
+```sh
+spt endpoint stop <id>
+spt endpoint run --adapter omp-spt --id <id>
+```
+
+The second command attaches the native OMP TUI by default. No additional installation source or reload command is part of the update.
+
+## Release record
+
+Retain:
+
+- release commit and `omp-spt-vX.Y.Z` tag;
+- deterministic gate outputs with no release-blocking skips;
+- hashes for `dist/adapter.spt` and both input binaries;
+- `gh release view` output showing stable tag `omp-spt-vX.Y.Z` and asset `adapter.spt`;
+- tagged and unpinned acquisition results;
+- the full native acceptance evidence required by `docs/CI.md`; and
+- the `spt adapter update omp-spt` result and final reported version.
diff --git a/docs/adr/0001-distribution-splits-by-volatility.md b/docs/adr/0001-distribution-splits-by-volatility.md
index 8062ba0..8988a76 100644
--- a/docs/adr/0001-distribution-splits-by-volatility.md
+++ b/docs/adr/0001-distribution-splits-by-volatility.md
@@ -6,7 +6,15 @@
 
 ## Status
 
-accepted (2026-06-14)
+**Historical sister-lineage record — superseded for `omp-spt` by
+[ADR-0008](0008-omp-native-product-boundary.md) on 2026-07-14.**
+
+Preserved only as sister-project lineage for its original rationale and details. References to
+Claude or Claude Code, `ccs`, `sptc`, plugins, `cc-launcher`, and their associated bridge or hook
+behavior—including commands and imperative language—are historical context, not supported
+`omp-spt` instructions.
+
+Original sister-project status: **accepted (2026-06-14)**.
 
 ## Context
 
diff --git a/docs/adr/0002-hook-wiring-hand-written-hooks-json-shells-spt-api.md b/docs/adr/0002-hook-wiring-hand-written-hooks-json-shells-spt-api.md
index ae3895a..6c9c9e6 100644
--- a/docs/adr/0002-hook-wiring-hand-written-hooks-json-shells-spt-api.md
+++ b/docs/adr/0002-hook-wiring-hand-written-hooks-json-shells-spt-api.md
@@ -4,7 +4,16 @@
 
 ## Status
 
-accepted (2026-06-15) · grounds the F-001 resolution (`docs/SPT-CORE-FINDINGS.md`)
+**Historical sister-lineage record — superseded for `omp-spt` by
+[ADR-0008](0008-omp-native-product-boundary.md) on 2026-07-14.**
+
+Preserved only as sister-project lineage for its original rationale and details. References to
+Claude or Claude Code, `ccs`, `sptc`, plugins, `cc-launcher`, and their associated bridge or hook
+behavior—including commands and imperative language—are historical context, not supported
+`omp-spt` instructions.
+
+Original sister-project status: **accepted (2026-06-15)**; grounded the F-001 resolution
+(`docs/SPT-CORE-FINDINGS.md`).
 
 ## Context
 
diff --git a/docs/adr/0003-psyche-is-a-constrained-auto-approving-companion.md b/docs/adr/0003-psyche-is-a-constrained-auto-approving-companion.md
index de2a4e2..3d6c896 100644
--- a/docs/adr/0003-psyche-is-a-constrained-auto-approving-companion.md
+++ b/docs/adr/0003-psyche-is-a-constrained-auto-approving-companion.md
@@ -4,7 +4,15 @@
 
 ## Status
 
-accepted (2026-06-18)
+**Historical sister-lineage record — superseded for `omp-spt` by
+[ADR-0008](0008-omp-native-product-boundary.md) on 2026-07-14.**
+
+Preserved only as sister-project lineage for its original rationale and details. References to
+Claude or Claude Code, `ccs`, `sptc`, plugins, `cc-launcher`, and their associated bridge or hook
+behavior—including commands and imperative language—are historical context, not supported
+`omp-spt` instructions.
+
+Original sister-project status: **accepted (2026-06-18)**.
 
 ## Context
 
diff --git a/docs/adr/0004-checkpoint-via-self-send-loopback.md b/docs/adr/0004-checkpoint-via-self-send-loopback.md
index b81610d..86cbe04 100644
--- a/docs/adr/0004-checkpoint-via-self-send-loopback.md
+++ b/docs/adr/0004-checkpoint-via-self-send-loopback.md
@@ -2,7 +2,15 @@
 
 ## Status
 
-proposed (2026-06-24)
+**Historical sister-lineage record — superseded for `omp-spt` by
+[ADR-0008](0008-omp-native-product-boundary.md) on 2026-07-14.**
+
+Preserved only as sister-project lineage for its original rationale and details. References to
+Claude or Claude Code, `ccs`, `sptc`, plugins, `cc-launcher`, and their associated bridge or hook
+behavior—including commands and imperative language—are historical context, not supported
+`omp-spt` instructions.
+
+Original sister-project status: **proposed (2026-06-24)**.
 
 ## Context
 
diff --git a/docs/adr/0005-name-unification.md b/docs/adr/0005-name-unification.md
index 3b9492c..41fa1fd 100644
--- a/docs/adr/0005-name-unification.md
+++ b/docs/adr/0005-name-unification.md
@@ -3,8 +3,17 @@
 
 ## Status
 
-accepted (2026-06-24); repo rename executed 2026-06-25 (U3 — `SaberMage/spt-claude-code` →
-`SaberMage/claude-spt` via `gh repo rename`; all owner-qualified refs flipped).
+**Historical sister-lineage record — superseded for `omp-spt` by
+[ADR-0008](0008-omp-native-product-boundary.md) on 2026-07-14.**
+
+Preserved only as sister-project lineage for its original rationale and details. References to
+Claude or Claude Code, `ccs`, `sptc`, plugins, `cc-launcher`, and their associated bridge or hook
+behavior—including commands and imperative language—are historical context, not supported
+`omp-spt` instructions.
+
+Original sister-project status: **accepted (2026-06-24)**; repo rename executed 2026-06-25
+(U3 — `SaberMage/spt-claude-code` → `SaberMage/claude-spt` via `gh repo rename`; all
+owner-qualified refs flipped).
 
 ## Context
 
diff --git a/docs/adr/0006-one-command-update-and-consolidated-binary.md b/docs/adr/0006-one-command-update-and-consolidated-binary.md
index 69bb8f9..f2913f3 100644
--- a/docs/adr/0006-one-command-update-and-consolidated-binary.md
+++ b/docs/adr/0006-one-command-update-and-consolidated-binary.md
@@ -2,7 +2,17 @@
 
 ## Status
 
-accepted (2026-06-24) — extends ADR-0001 (distribution splits by volatility). Some pieces depend on spt-core capabilities not yet shipped (the "doyle asks" below); those parts are decided in shape but gated on delivery.
+**Historical sister-lineage record — superseded for `omp-spt` by
+[ADR-0008](0008-omp-native-product-boundary.md) on 2026-07-14.**
+
+Preserved only as sister-project lineage for its original rationale and details. References to
+Claude or Claude Code, `ccs`, `sptc`, plugins, `cc-launcher`, and their associated bridge or hook
+behavior—including commands and imperative language—are historical context, not supported
+`omp-spt` instructions.
+
+Original sister-project status: **accepted (2026-06-24)**; extended ADR-0001 (distribution splits
+by volatility). Some pieces depended on then-unshipped spt-core capabilities (the "doyle asks"
+below); those parts were decided in shape but gated on delivery.
 
 **D1 realized (v0.9.0, 2026-06-28).** Ask #1 ("fold in `claude-spt hook <event>` if generic hook
 dispatch lands") shipped — but NOT as the proposed `spt api run-hook`. doyle RESOLVED it as
diff --git a/docs/adr/0007-native-omp-tui-hosts-spt-extension.md b/docs/adr/0007-native-omp-tui-hosts-spt-extension.md
index 7c7d1c9..897fa06 100644
--- a/docs/adr/0007-native-omp-tui-hosts-spt-extension.md
+++ b/docs/adr/0007-native-omp-tui-hosts-spt-extension.md
@@ -2,7 +2,7 @@
 
 ## Status
 
-accepted (2026-07-13) — supersedes the interactive-hosting choice in `OMP-ADAPTER-PLAN.md`; the RPC bridge remains a headless integration surface.
+superseded by ADR-0009 (2026-07-14) — the native OMP TUI decision remains; the retained RPC-bridge topology does not.
 
 ## Context
 
@@ -12,7 +12,7 @@ Issue #2 requires `spt endpoint run --adapter omp-spt ...` to expose the harness
 
 Run native interactive `omp` as `[session.self]` and `[session.resume]`. Load a packaged OMP extension that binds the OMP session to the SPT endpoint, listens for SPT messages, submits each message through `sendUserMessage`, tracks busy/idle state, and sends the final assistant response back to the sender.
 
-The extension uses OMP's public extension API. It does not render or proxy the terminal: OMP remains the PTY leader and owns its complete native TUI. The old RPC bridge remains in the binary for explicitly headless callers, but endpoint bringup no longer routes through it.
+The former RPC bridge is not a supported endpoint topology; every omp-spt endpoint runs native OMP in a broker-held terminal that remains attachable even while unattended.
 
 <!-- [doc->REQ-OMP-NATIVE-TUI] -->
 
diff --git a/plugin/omps/.claude-plugin/plugin.json b/plugin/omps/.claude-plugin/plugin.json
deleted file mode 100644
index eb844dd..0000000
--- a/plugin/omps/.claude-plugin/plugin.json
+++ /dev/null
@@ -1,9 +0,0 @@
-{
-  "name": "omps",
-  "version": "0.1.11",
-  "description": "Spacetime (spt) adapter for Claude Code — agent messaging, live agents, and spt-core bootstrap. Thin skeleton; logic rides the spt binary + adapter manifest (spt-core-conducted).",
-  "author": {
-    "name": "perri"
-  },
-  "keywords": ["spt", "spacetime", "messaging", "agents", "live", "claude-spt"]
-}
diff --git a/plugin/omps/bootstrap.ps1 b/plugin/omps/bootstrap.ps1
deleted file mode 100644
index 6bd3d07..0000000
--- a/plugin/omps/bootstrap.ps1
+++ /dev/null
@@ -1,15 +0,0 @@
-# omps SessionStart bootstrap (PowerShell/Windows) — install spt-core on demand if absent.
-# Verbatim against the published contract: spt-releases harness-contract/install-on-demand.md.
-# The invisible-installer pattern: a user who installs the omps plugin gets spt-core for free.
-# [impl->REQ-DIST-BOOTSTRAP-INSTALL]
-if (-not (Get-Command spt -ErrorAction SilentlyContinue)) {
-    Write-Output "spt-core not found - installing..."
-    irm https://sabermage.github.io/spt-releases/install.ps1 | iex
-    # Windows PATH registration doesn't affect the current process — use the absolute path first.
-    $spt = Join-Path $env:LOCALAPPDATA 'spt-core\bin\spt.exe'
-} else {
-    $spt = 'spt'
-}
-
-& $spt --version
-# After this initial bootstrap, `spt update` handles signed self-updates automatically.
diff --git a/plugin/omps/bootstrap.sh b/plugin/omps/bootstrap.sh
deleted file mode 100644
index 2b82097..0000000
--- a/plugin/omps/bootstrap.sh
+++ /dev/null
@@ -1,18 +0,0 @@
-#!/bin/sh
-# omps SessionStart bootstrap (POSIX) — install spt-core on demand if absent.
-# Verbatim against the published contract: spt-releases harness-contract/install-on-demand.md.
-# The invisible-installer pattern: a user who installs the omps plugin gets spt-core for free.
-# [impl->REQ-DIST-BOOTSTRAP-INSTALL]
-set -eu
-
-if ! command -v spt >/dev/null 2>&1; then
-  echo "spt-core not found - installing..." >&2
-  curl -fsSL https://sabermage.github.io/spt-releases/install.sh | sh
-  # PATH is not yet reloaded in this shell — use the absolute install path for the first call.
-  SPT="$HOME/.local/bin/spt"
-else
-  SPT="spt"
-fi
-
-"$SPT" --version
-# After this initial bootstrap, `spt update` handles signed self-updates automatically.
diff --git a/plugin/omps/hooks/dispatch.sh b/plugin/omps/hooks/dispatch.sh
deleted file mode 100644
index a99ca94..0000000
--- a/plugin/omps/hooks/dispatch.sh
+++ /dev/null
@@ -1,66 +0,0 @@
-#!/bin/sh
-# omps hook dispatch — STATIC-FOREVER (D1, ADR-0006 ask #1 → resolve-not-execute).
-#
-# This is the ONLY hook shell the cplugs plugin still ships. It carries NO hook logic — that all moved
-# into the consolidated `claude-spt` binary (`claude-spt hook <event>`), which rides `spt adapter
-# update`. This wrapper only RESOLVES that binary and execs it, so it never needs to change again when
-# hook behaviour changes. hooks.json wires every CC event to `sh dispatch.sh <CCEventName>`.
-#
-# Resolution rides spt-core v0.16.0's two pure primitives (no new spt-core execution): the adapter
-# `[strings].hook_cmd = "{adapter_dir}/claude-spt hook"` is lazily {adapter_dir}-substituted at
-# `spt adapter get-string` read time → the absolute `<install_dir>/claude-spt hook` command. We resolve
-# it ONCE per session (cached in $SPTC_HOOK_BIN via $CLAUDE_ENV_FILE on SessionStart) and reuse it per
-# hook. Session-scoped keys (session_id, …) are NOT available via get-string — the binary reads those
-# from the CC hook payload on stdin (passed through untouched: this wrapper never reads stdin).
-#
-# Bootstrap stays HERE, not in the binary: the binary lives in the adapter install dir, which does not
-# exist until spt-core + the adapter are installed. So SessionStart installs spt-core on demand first;
-# and if the adapter is not yet registered (pre-/omps:setup), get-string yields nothing and we no-op
-# (exit 0) — exactly the pre-readiness no-op the old per-hook wrappers had. [impl->REQ-DIST-HOOK-BINARY]
-event="$1"
-
-# Resolve the spt binary (PATH first, then known install locations) — only needed to get-string the
-# hook command; the binary itself is resolved from {adapter_dir}, not PATH.
-spt_bin() {
-  if command -v spt >/dev/null 2>&1; then printf 'spt'; return 0; fi
-  for p in \
-    "$HOME/.local/bin/spt" \
-    "$LOCALAPPDATA/spt-core/bin/spt.exe" \
-    "$HOME/AppData/Local/spt-core/bin/spt.exe"; do
-    [ -x "$p" ] && { printf '%s' "$p"; return 0; }
-  done
-  printf 'spt'
-}
-
-# SessionStart only: invisible-installer (install spt-core if absent — no-op when present). Redirect
-# stdin from /dev/null so this never consumes the CC hook payload the binary will read.
-if [ "$event" = "SessionStart" ]; then
-  sh "$CLAUDE_PLUGIN_ROOT/bootstrap.sh" </dev/null >/dev/null 2>&1 || true
-fi
-
-# Resolve the binary PATH: cached env first, else the lazily-substituted adapter string.
-bin="${SPTC_HOOK_BIN:-}"
-if [ -z "$bin" ]; then
-  bin=$("$(spt_bin)" adapter get-string claude-spt hook_cmd </dev/null 2>/dev/null) || true
-fi
-
-# Adapter not registered yet (pre-/omps:setup) → no perch to serve → no-op.
-[ -z "$bin" ] && exit 0
-
-# Normalize to the bare binary PATH: tolerate a manifest value that still carries a trailing ` hook`
-# token (older v0.9.0 hook_cmd = "{adapter_dir}/claude-spt hook"); the `hook` subcommand is appended
-# below as a literal, so the cached value is JUST the binary path — no embedded space.
-bin="${bin% hook}"
-
-# Cache the resolved binary path for later per-prompt hooks (skip get-string). QUOTED — CC sources
-# $CLAUDE_ENV_FILE per Bash/hook invocation, so an unquoted value with a space (a path with a space,
-# OR the old ` hook` suffix) would be parsed as `VAR=val cmd` → run `cmd` (the v0.9.0 `hook: command
-# not found` regression) AND lose the value. Quoting makes it one assignment, space-safe.
-if [ "$event" = "SessionStart" ] && [ -n "${CLAUDE_ENV_FILE:-}" ] && [ -z "${SPTC_HOOK_BIN:-}" ]; then
-  printf 'SPTC_HOOK_BIN="%s"\n' "$bin" >> "$CLAUDE_ENV_FILE"
-fi
-
-# Exec the binary: `"$bin"` is the program (quoted → space-safe), `hook` the subcommand (literal),
-# then the CC event + the seed pid. CC stdin (the hook payload) is inherited untouched — the binary
-# reads it directly. $PPID is the seed pid (Rust std has no portable getppid on Windows).
-exec "$bin" hook "$event" --host-pid "$PPID"
diff --git a/plugin/omps/hooks/hooks.json b/plugin/omps/hooks/hooks.json
deleted file mode 100644
index 7b3d86e..0000000
--- a/plugin/omps/hooks/hooks.json
+++ /dev/null
@@ -1,37 +0,0 @@
-{
-  "hooks": {
-    "SessionStart": [
-      { "hooks": [ { "type": "command", "command": "sh \"$CLAUDE_PLUGIN_ROOT/hooks/dispatch.sh\" SessionStart", "shell": "bash" } ] }
-    ],
-    "UserPromptSubmit": [
-      { "hooks": [ { "type": "command", "command": "sh \"$CLAUDE_PLUGIN_ROOT/hooks/dispatch.sh\" UserPromptSubmit", "shell": "bash" } ] }
-    ],
-    "PreToolUse": [
-      { "hooks": [ { "type": "command", "command": "sh \"$CLAUDE_PLUGIN_ROOT/hooks/dispatch.sh\" PreToolUse", "shell": "bash" } ] }
-    ],
-    "Stop": [
-      { "hooks": [ { "type": "command", "command": "sh \"$CLAUDE_PLUGIN_ROOT/hooks/dispatch.sh\" Stop", "shell": "bash" } ] }
-    ],
-    "SessionEnd": [
-      { "hooks": [ { "type": "command", "command": "sh \"$CLAUDE_PLUGIN_ROOT/hooks/dispatch.sh\" SessionEnd", "shell": "bash" } ] }
-    ],
-    "SubagentStart": [
-      { "hooks": [ { "type": "command", "command": "sh \"$CLAUDE_PLUGIN_ROOT/hooks/dispatch.sh\" SubagentStart", "shell": "bash" } ] }
-    ],
-    "SubagentStop": [
-      { "hooks": [ { "type": "command", "command": "sh \"$CLAUDE_PLUGIN_ROOT/hooks/dispatch.sh\" SubagentStop", "shell": "bash" } ] }
-    ],
-    "PostToolUse": [
-      { "matcher": "Write", "hooks": [ { "type": "command", "command": "sh \"$CLAUDE_PLUGIN_ROOT/hooks/dispatch.sh\" PostToolUse", "shell": "bash" } ] }
-    ],
-    "PostToolUseFailure": [
-      { "hooks": [ { "type": "command", "command": "sh \"$CLAUDE_PLUGIN_ROOT/hooks/dispatch.sh\" PostToolUseFailure", "shell": "bash" } ] }
-    ],
-    "Notification": [
-      { "matcher": "*", "hooks": [ { "type": "command", "command": "sh \"$CLAUDE_PLUGIN_ROOT/hooks/dispatch.sh\" Notification", "shell": "bash" } ] }
-    ],
-    "StopFailure": [
-      { "hooks": [ { "type": "command", "command": "sh \"$CLAUDE_PLUGIN_ROOT/hooks/dispatch.sh\" StopFailure", "shell": "bash" } ] }
-    ]
-  }
-}
diff --git a/plugin/omps/skills/commune/SKILL.md b/plugin/omps/skills/commune/SKILL.md
deleted file mode 100644
index d3bc26d..0000000
--- a/plugin/omps/skills/commune/SKILL.md
+++ /dev/null
@@ -1,22 +0,0 @@
----
-name: commune
-description: |
-  Push a context update to your Psyche so it can brief your resume across a reset. Use when the
-  user says "commune" or "update psyche", or — as a live agent — after a significant body of work,
-  before a /clear or /compact. Pass --checkpoint to ALSO auto-clear and wake yourself from the
-  freshest commune (an agent-driven context reset, no operator needed).
-allowed-tools: [Bash, Write]
----
-
-<!-- [doc->REQ-DIST-CHECKPOINT-COMMUNE] [doc->REQ-DIST-SKELETON-THIN] -->
-
-# /omps:commune
-
-**Live agents only.** No perch (`spt whoami` is empty)? Run **`/omps:live`** first — a ready agent has
-no Psyche and nothing to rebuild from.
-
-The operative commune + `--checkpoint` mechanics are delivered by the adapter (thin skeleton — the
-prose rides `spt adapter update`; ADR-0001/ADR-0006), not baked here: a live agent already carries them
-in its **SessionStart brief** (the `live-ops` block) and in the **`/omps:live` go-live body**. In short:
-write `.claude/<id>-commune.md` as one atomic context delta (task + status, decisions, next steps);
-add the `!!checkpoint!!` trigger to also self-reset (a PAIR of markers brackets a custom wake directive).
diff --git a/plugin/omps/skills/force-stop/SKILL.md b/plugin/omps/skills/force-stop/SKILL.md
deleted file mode 100644
index 0df17ff..0000000
--- a/plugin/omps/skills/force-stop/SKILL.md
+++ /dev/null
@@ -1,19 +0,0 @@
----
-name: force-stop
-description: |
-  Force-stop an SPT agent — a ready agent, or a live agent and its Psyche. Use when the user
-  says "stop listening", "kill live agent", "force stop", or "tear down perch". Session-aware: a
-  live target tears its Psyche down too.
-argument-hint: "[<id>]"
-allowed-tools: [Bash]
----
-
-# /omps:force-stop
-
-> **Skeleton — thin by design.** Operative instructions for this skill are delivered by the
-> `omps` adapter at invocation time. Look out for the UserPromptSubmit additionalContext.
->
-> **Operative.** If injection ever no-ops (spt absent / adapter unregistered), check
-> SPT's installation status using the skill `omps:setup`. Otherwise, avoid additional steps.
-
-Tears down an agent's endpoint (graceful shutdown, or a lighter stop).
diff --git a/plugin/omps/skills/list-agents/SKILL.md b/plugin/omps/skills/list-agents/SKILL.md
deleted file mode 100644
index 8f81a9f..0000000
--- a/plugin/omps/skills/list-agents/SKILL.md
+++ /dev/null
@@ -1,17 +0,0 @@
----
-name: list-agents
-description: |
-  List SPT agents and endpoints reachable from this node. Use when the user says "list agents",
-  "who's live", "who's listening", or wants a roster of active perches.
-allowed-tools: [Bash]
----
-
-# /omps:list-agents
-
-> **Skeleton — thin by design.** Operative instructions for this skill are delivered by the
-> `omps` adapter at invocation time. Look out for the UserPromptSubmit additionalContext.
->
-> **Operative.** If injection ever no-ops (spt absent / adapter unregistered), check
-> SPT's installation status using the skill `omps:setup`. Otherwise, avoid additional steps.
-
-Shows the roster of spt endpoints, with this session's own pinned distinctly.
diff --git a/plugin/omps/skills/live/SKILL.md b/plugin/omps/skills/live/SKILL.md
deleted file mode 100644
index 49974ec..0000000
--- a/plugin/omps/skills/live/SKILL.md
+++ /dev/null
@@ -1,38 +0,0 @@
----
-name: live
-description: |
-  Run a live agent session. For past sessions, restores a summarized context.
-
-  EXPLICIT START phrases (route to /omps:live <id>):
-  - "live as"
-  - "start live"
-  - "go live"
-  - "start a live agent"
-
-  AUTO-RESUME phrases (route to /omps:live --auto, resumes most-recently-active live agent):
-  - continue live work
-  - resume live work
-  - continue live agent
-  - resume live agent
-  - live agent continue
-  - live agent resume
-  - live work continue
-  - live work resume
-
-  Does NOT route here (too ambiguous — require BOTH "live" AND ("agent" or "work")):
-  - "keep going"
-  - "resume work"
-  - "continue" (bare)
-argument-hint: "[<id>] [--auto]"
-allowed-tools: [Bash, Monitor, Read]
----
-
-# /omps:live
-
-> **Skeleton — thin by design.** Operative instructions for this skill are delivered by the
-> `omps` adapter at invocation time. Look out for the UserPromptSubmit additionalContext.
->
-> **Operative.** If injection ever no-ops (spt absent / adapter unregistered), check
-> SPT's installation status using the skill `omps:setup`. Otherwise, avoid additional steps.
-
-Upgrades THIS session to a LiveAgent (Psyche-backed).
diff --git a/plugin/omps/skills/ready/SKILL.md b/plugin/omps/skills/ready/SKILL.md
deleted file mode 100644
index b5cff4f..0000000
--- a/plugin/omps/skills/ready/SKILL.md
+++ /dev/null
@@ -1,19 +0,0 @@
----
-name: ready
-description: |
-  Make this Claude Code session reachable for inter-agent messages (register a perch and
-  listen). Use when the user says "listen as", "ready as", or wants to receive messages from
-  other agents.
-argument-hint: "[<id>]"
-allowed-tools: [Bash, Read, Monitor]
----
-
-# /omps:ready
-
-> **Skeleton — thin by design.** Operative instructions for this skill are delivered by the
-> `omps` adapter at invocation time. Look out for the UserPromptSubmit additionalContext.
->
-> **Operative.** If injection ever no-ops (spt absent / adapter unregistered), check
-> SPT's installation status using the skill `omps:setup`. Otherwise, avoid additional steps.
-
-Registers a perch and listens, so other agents can reach this session.
diff --git a/plugin/omps/skills/send/SKILL.md b/plugin/omps/skills/send/SKILL.md
deleted file mode 100644
index e4a4ea1..0000000
--- a/plugin/omps/skills/send/SKILL.md
+++ /dev/null
@@ -1,39 +0,0 @@
----
-name: send
-description: |
-  Send a message to another SPT agent. Use when the user says "send to", "message",
-  "tell <agent>", or when you need to reach or reply to another agent yourself.
-argument-hint: "<target>"
-allowed-tools: [Bash]
----
-
-<!-- [doc->REQ-DIST-SKELETON-THIN] -->
-
-# /omps:send
-
-Deliver a message to another agent (**body read from stdin**). The operative reach is delivered by the
-adapter, not baked here (thin skeleton — the prose rides `spt adapter update`): a perched session
-already carries send/reply in its **SessionStart brief** (the `messaging-perch` block). In short:
-
-- **Send:** `printf '%s' "<body>" | spt send <target>` — `SENT` = live, `QUEUED` = spooled (success, do
-  not retry).
-- **Reply:** `printf '%s' "<body>" | spt send <sender>` (sender = the `from` on the `<EVENT>` you got).
-- No perch yet? `/omps:ready` (or `/omps:live`) first, or send-and-wait without one via
-  `printf '%s' "<body>" | spt ring <target> --timeout 60`.
-
-## Shortform — no Bash needed
-
-<!-- [doc->REQ-TAG-PEER-MESSAGING] -->
-
-A perched agent can message peers by embedding a tag in its **own turn output** — no `spt send`, no
-Bash tool:
-
-- **Peer message:** `@<t1,t2,t3 body @>` — `@<` opens; the comma-separated target list runs to the
-  first space (no spaces inside the list); the body runs to the first `@>`. The adapter sends `body`
-  to each target and confirms back into your context (which delivered, which had no perch). Multiple
-  `@<…@>` blocks in one output all fire. A bare `@@id` does nothing (only the explicit block sends).
-- **Commune:** start an output with `>>commune<<` and the rest is written as your commune (same as the
-  `/omps:commune` Write path). A `>>commune<<` output is never scanned for `@<…@>`, so it may quote the
-  syntax freely.
-
-Full guidance: `spt how-to send`.
diff --git a/plugin/omps/skills/setup/SKILL.md b/plugin/omps/skills/setup/SKILL.md
deleted file mode 100644
index 956413f..0000000
--- a/plugin/omps/skills/setup/SKILL.md
+++ /dev/null
@@ -1,74 +0,0 @@
----
-name: setup
-description: |
-  Install or repair spt-core AND activate the claude-spt adapter for this Claude Code session
-  (mid-session installer + post-install activation).
-allowed-tools: [Bash]
----
-
-# /omps:setup
-
-> **Self-contained by necessity.** Unlike other `/omps:*` skills, `setup` cannot rely on
-> UPS-injection of its body: it runs precisely when spt-core may be **absent**, so the injection
-> source is unavailable. The operative steps therefore live in this SKILL.md (the floor); the
-> adapter body mirrors them for the spt-present repair path.
-
-Covers the mid-session install + activation gap (ADR-0001): a user who installs the plugin mid-session
-has not had a SessionStart bootstrap fire, so `/omps:setup` runs the same invisible-installer
-bootstrap to fetch + verify spt-core on demand **and then activates the claude-spt adapter**. A
-present binary is not enough: an unregistered/`deregistered` adapter has no profiles/strings/hints/
-`[digest]`, so the `/omps:*` surface is inert until activation.
-
-**Do this:**
-
-1. **Binary.** If spt-core is absent (`command -v spt && spt --version` reports nothing), run the
-   published install-on-demand bootstrap (spt-releases `harness-contract/install-on-demand.md`):
-   - **POSIX:** `curl -fsSL https://sabermage.github.io/spt-releases/install.sh | sh`
-   - **Windows (PowerShell):** `irm https://sabermage.github.io/spt-releases/install.ps1 | iex`
-
-   `PATH` is not reloaded in this shell after a fresh install — verify with the absolute path:
-   `"$HOME/.local/bin/spt" --version`. After this, `spt update` handles signed self-updates.
-
-2. **Activate the adapter.** Run `spt adapter list` and find `claude-spt`:
-   - Listed and **not** `deregistered` → already active; report it and skip to step 3.
-   - Missing or `deregistered` → activate it:
-     - **Local dev / dogfooding a repo checkout** (an `adapter/claude-spt.toml` is present near cwd):
-       `spt adapter add ./adapter/claude-spt.toml` (the file-form accepts any path + filename).
-     - **End-user (plugin only):** `spt adapter add --release SaberMage/claude-spt` — fetches the
-       single multi-platform `adapter.spt` (one archive bundling every supported platform's binaries
-       beside a shared manifest; install auto-resolves the host's), extracts to the durable home,
-       registers. No `--asset` / os-detection needed — the fat archive is host-agnostic (ADR-0024 W1).
-       `--tag <ver>` pins a version. Recommended (from the monorepo, no dedicated repo); needs spt
-       **v0.13.2+** (the version that reads a fat archive).
-
-3. **Verify activation.** Re-run `spt adapter list` — `claude-spt` must read **active**
-   (no `deregistered`). The `[digest]`/`[session]` templates invoke `claude-spt-digest` +
-   `claude-spt-psyche` by **bare name**, and spt-core resolves them **from the adapter install dir**
-   (the `from …/adapters/_github/<safe>/` path in `spt adapter list`), where `--release` activation
-   already extracted them beside the manifest. **No PATH copy needed** (REQ-INSTALL-11, spt v0.8.0
-   Feature B; verified live on v0.8.1 — digest + daemon-hosted Psyche both resolve from the install
-   dir). If either ever fails to start, confirm both `.exe`s are present in that install dir — their
-   absence is a packaging defect, not a PATH problem. *(Legacy F-006 interim PATH-copy: retired.)*
-
-4. **ccs wiring (optional — SCOPE setup #7).** Detect `~/.ccs`:
-   - Present → ccs is installed. The shipped `claude-spt:ccs` profile leaf-replaces the session
-     command with `ccs` (drop-in for `claude`) → run live/ready agents on ccs backends
-     (glm/kimi/custom) via `--adapter claude-spt:ccs` (e.g. `/omps:live`, `/omps:ready`,
-     `spt endpoint run --adapter claude-spt:ccs`). Check `command -v ccs`; if `~/.ccs` exists but `ccs`
-     isn't on PATH, point the user at their ccs bin dir. No action needed if unwanted (base
-     `claude-spt` is unaffected).
-   - Absent → ccs is an optional CLI router for driving alternate model backends (glm/kimi/custom) in
-     place of `claude`. To enable: install ccs (its docs), then re-run `/omps:setup`. Skip if unwanted.
-
-5. **Subnet onboarding (optional — SCOPE setup #3/#4).** A subnet is the private group of paired
-   machines that makes `/omps:send`, `/omps:ready`, and live agents work cross-machine (local use
-   needs none). Check: `spt subnet status`.
-   - In a subnet → to invite a machine: `spt subnet show-code` (6-digit code + URI + QR); on the
-     joiner: `spt subnet join <name> --code <code>`.
-   - Not in one → offer create (`spt subnet create <name>` — seed-holder; prints code/URI/QR) or join
-     (`spt subnet join <name> --code <code>`). Skip if single-machine.
-   - Full verb guidance → **/omps:subnet**. **Elevation:** create/join/show-code are
-     OS-elevation-gated — Windows: elevated (UAC) shell; Linux desktop: pkexec/polkit or sudo
-     terminal; Linux TTY: inline sudo; headless: print the command for the user to run elevated.
-
-Idempotent and safe to re-run — the same bootstrap + activation the SessionStart hook performs.
diff --git a/plugin/omps/skills/signoff/SKILL.md b/plugin/omps/skills/signoff/SKILL.md
deleted file mode 100644
index e764c07..0000000
--- a/plugin/omps/skills/signoff/SKILL.md
+++ /dev/null
@@ -1,20 +0,0 @@
----
-name: signoff
-description: |
-  Gracefully shut down your live session, saving a final context summary. Use when the user says
-  "sign off" or "graceful stop", or when you (a live agent) are done and want to go offline cleanly.
-allowed-tools: [Bash, Write]
----
-
-<!-- [doc->REQ-DIST-SKELETON-THIN] -->
-
-# /omps:signoff
-
-**Live agents only.** No perch (`spt whoami` is empty)? Nothing to sign off.
-
-The operative steps are delivered by the adapter, not baked here (thin skeleton — the prose rides
-`spt adapter update`; ADR-0001/ADR-0006): a live agent carries them in its **SessionStart brief** (the
-`live-ops` block) and the **`/omps:live` go-live body**. In short: optionally write a brief closing
-summary, then `spt endpoint shutdown` (your own perch) — stops the listener, fires the final context
-save, takes your Psyche down. `/omps:ready` or `/omps:live` brings you back; lighter no-save stop is
-`spt endpoint stop`.
diff --git a/plugin/omps/skills/subnet/SKILL.md b/plugin/omps/skills/subnet/SKILL.md
deleted file mode 100644
index aa0b889..0000000
--- a/plugin/omps/skills/subnet/SKILL.md
+++ /dev/null
@@ -1,19 +0,0 @@
----
-name: subnet
-description: |
-  Manage subnet membership — create a subnet, show a pairing code to invite a machine, or join
-  an existing one. Use when the user wants to pair machines, set up a subnet, or reach agents
-  across machines. Cross-machine /omps:send and live agents depend on it.
-argument-hint: "[status|create|show-code|join]"
-allowed-tools: [Bash]
----
-
-# /omps:subnet
-
-> **Skeleton — thin by design.** Operative instructions for this skill are delivered by the
-> `omps` adapter at invocation time. Look out for the UserPromptSubmit additionalContext.
->
-> **Operative.** If injection ever no-ops (spt absent / adapter unregistered), check
-> SPT's installation status using the skill `omps:setup`. Otherwise, avoid additional steps.
-
-Pairs machines into a private network so agents reach each other across nodes.
diff --git a/plugin/omps/skills/version/SKILL.md b/plugin/omps/skills/version/SKILL.md
deleted file mode 100644
index a5855e0..0000000
--- a/plugin/omps/skills/version/SKILL.md
+++ /dev/null
@@ -1,17 +0,0 @@
----
-name: version
-description: |
-  Report the spt-core-tracked adapter version (the version-of-truth, not the marketplace plugin
-  version). Use when the user asks the spt or adapter version, or runs /omps:version.
-allowed-tools: [Bash]
----
-
-# /omps:version
-
-> **Skeleton — thin by design.** Operative instructions for this skill are delivered by the
-> `omps` adapter at invocation time. Look out for the UserPromptSubmit additionalContext.
->
-> **Operative.** If injection ever no-ops (spt absent / adapter unregistered), check
-> SPT's installation status using the skill `omps:setup`. Otherwise, avoid additional steps.
-
-Reports the version-of-truth: the spt-core-tracked binary + adapter manifest.
diff --git a/tests/acceptance-harness.sh b/tests/acceptance-harness.sh
deleted file mode 100644
index 0dafb7f..0000000
--- a/tests/acceptance-harness.sh
+++ /dev/null
@@ -1,46 +0,0 @@
-#!/bin/sh
-# Unit tests for the CI acceptance harness — deterministic pieces only, NO real `claude` spawned.
-# Run: sh tests/acceptance-harness.sh   (exit 0 = pass).
-. "$(dirname "$0")/../ci/acceptance/lib.sh"
-fail=0
-
-# ── Perch-collision guard: identity is ALWAYS overridden to a disposable id, never a live name.
-# [unit->REQ-HAZARD-PERCH-COLLISION]
-# Simulate inheriting the operator's identity, then mint — both vars must be displaced.
-SPT_AGENT_ID=perri OWL_SESSION_ID=perri
-sptc_ci_identity 7   # bare call (no $() — must mutate THIS shell)
-[ "$SPTC_CI_ID" = "sptc-ci-7" ] && echo "ok   mints disposable id" || { echo "FAIL id: got [$SPTC_CI_ID]"; fail=1; }
-[ "$SPT_AGENT_ID" = "sptc-ci-7" ] && echo "ok   SPT_AGENT_ID overridden" || { echo "FAIL SPT_AGENT_ID=[$SPT_AGENT_ID] not overridden"; fail=1; }
-[ "$OWL_SESSION_ID" = "sptc-ci-7" ] && echo "ok   OWL_SESSION_ID overridden" || { echo "FAIL OWL_SESSION_ID=[$OWL_SESSION_ID] not overridden"; fail=1; }
-[ "$SPT_AGENT_ID" != "perri" ] && echo "ok   live id displaced" || { echo "FAIL still resolves live id"; fail=1; }
-
-# is_disposable: accepts a minted id, rejects any live name.
-sptc_ci_is_disposable "sptc-ci-7" && echo "ok   accepts disposable" || { echo "FAIL rejected disposable"; fail=1; }
-sptc_ci_is_disposable "perri" && { echo "FAIL accepted live id 'perri'"; fail=1; } || echo "ok   rejects live id"
-sptc_ci_is_disposable "" && { echo "FAIL accepted empty id"; fail=1; } || echo "ok   rejects empty id"
-
-# ── Scaffold: builds settings.json + a stdin-reading (never argv) UPS hook fixture.
-work=$(mktemp -d) || { echo "FAIL mktemp"; exit 1; }
-trap 'rm -rf "$work"' EXIT INT TERM
-proj="$work/p"; digest="$work/d.txt"
-sptc_ci_mkproject "$proj" "$digest" >/dev/null
-[ -f "$proj/.claude/settings.json" ] && echo "ok   scaffold writes settings.json" || { echo "FAIL no settings.json"; fail=1; }
-[ -f "$proj/.claude/hooks/ups-digest.sh" ] && echo "ok   scaffold writes UPS hook" || { echo "FAIL no UPS hook"; fail=1; }
-grep -q 'UserPromptSubmit' "$proj/.claude/settings.json" && echo "ok   settings wires UserPromptSubmit" || { echo "FAIL UPS not wired"; fail=1; }
-# Fixture hook reads stdin, not a /-leading argv (KH 1.1 immunity).
-grep -q 'input=$(cat)' "$proj/.claude/hooks/ups-digest.sh" && echo "ok   fixture reads stdin (MSYS-safe)" || { echo "FAIL fixture not stdin-driven"; fail=1; }
-
-# Fixture actually produces the digest marker when fed a real CC-shaped payload on stdin.
-printf '%s' '{"session_id":"x","prompt":"hello-probe"}' | sh "$proj/.claude/hooks/ups-digest.sh"
-sptc_ci_assert "fixture emits digest marker" "UPS_FIRED:hello-probe" "$digest" >/dev/null \
-  && echo "ok   fixture emits digest marker" || { echo "FAIL fixture no marker"; fail=1; }
-
-# ── Assert helper: negative case (missing needle) must FAIL, not false-pass.
-if sptc_ci_assert "neg" "NOPE" "$digest" >/dev/null; then echo "FAIL assert false-passed"; fail=1; else echo "ok   assert fails on missing needle"; fi
-
-# ── Orchestrator is env-gated: without SPTC_ACCEPTANCE it skips cleanly (rc 0), spawns no claude.
-out=$(SPTC_ACCEPTANCE=0 sh "$(dirname "$0")/../ci/acceptance/run-acceptance.sh" 2>&1); orc=$?
-{ [ "$orc" -eq 0 ] && printf '%s' "$out" | grep -q 'SKIP acceptance'; } \
-  && echo "ok   orchestrator env-gate skips clean" || { echo "FAIL env-gate: rc=$orc out=[$out]"; fail=1; }
-
-[ "$fail" -eq 0 ] && { echo "ACCEPTANCE-HARNESS OK"; exit 0; } || { echo "ACCEPTANCE-HARNESS FAIL"; exit 1; }
diff --git a/tests/adapter-archive.sh b/tests/adapter-archive.sh
index c38a8ff..8eef944 100644
--- a/tests/adapter-archive.sh
+++ b/tests/adapter-archive.sh
@@ -1,45 +1,57 @@
 #!/bin/sh
-# Unit test for the adapter.spt packer (ci/publish/package-adapter.sh).
-# Asserts the MULTI-PLATFORM fat-archive invariants `spt adapter add --release` depends on (ADR-0024
-# W1, spt-core >= 0.13.2): one .spt holds the SHARED manifest.toml (named exactly) + strings/ at the
-# archive ROOT, plus each recognized target-triple's binaries under a <triple>/ dir mirroring the
-# flat-root tree. spt-core classifies on the top-level triple dir and flattens this node's triple into
-# the install dir, so a bare-name command token still resolves. [unit->REQ-DIST-ADAPTER-RELEASE]
-# [unit->REQ-DIST-ADAPTER-PEROS]
+# Deterministic unit test for the adapter.spt packer. Fixture binaries exercise the multi-platform
+# archive layout without depending on workstation build artifacts; the opt-in release-acquisition
+# integration gate remains responsible for proving real published platform assets.
+#
+# The archive must contain shared manifest.toml + strings/ at its root and one omp-spt binary under
+# each recognized target triple so spt-core can flatten the selected platform at install time.
 set -u
 ROOT=$(CDPATH= cd "$(dirname "$0")/.." && pwd)
 PACKER="$ROOT/ci/publish/package-adapter.sh"
 WIN_TRIPLE=x86_64-pc-windows-msvc
 LINUX_TRIPLE=x86_64-unknown-linux-gnu
-BINS="omp-spt"  # the ONE consolidated tool binary (built from tools/claude-spt; renamed at v0.1.1, HIGH-1)
+BINS="omp-spt"
 rc=0
 fail() { printf 'FAIL: %s\n' "$1"; rc=1; }
 
-# The fat archive needs BOTH platforms' release binaries. Probe both triples.
-have_all=1
-for b in $BINS; do
-  [ -f "$ROOT/tools/claude-spt/target/release/$b.exe" ] || have_all=0
-  [ -f "$ROOT/tools/claude-spt/target/$LINUX_TRIPLE/release/$b" ] || have_all=0
+for tool in awk cp dirname grep head mkdir mktemp rm sed sort tar tr; do
+  command -v "$tool" >/dev/null 2>&1 || { echo "FAIL: required tool unavailable: $tool"; exit 1; }
 done
+if ! sh "$ROOT/tests/manifest-schema.sh"; then
+  echo "FAIL: manifest-schema prerequisite failed"
+  exit 1
+fi
 
-if [ "$have_all" -ne 1 ]; then
-  # Missing a platform → assert the packer's REFUSE guard fires (no silent pass), then skip the
-  # archive-build assertion (no hidden coverage gap). Both platforms are required for a fat archive.
-  if sh "$PACKER" --apply >/dev/null 2>&1; then
-    fail "packer should refuse (exit!=0) when a platform's binaries are absent"
-  else
-    echo "ok   packer refuses --apply when a platform's binaries absent (guard works)"
-  fi
-  echo "SKIP: archive-build assertion — need BOTH platforms (win native + linux cross-build) present"
-  exit "$rc"
+# Build isolated deterministic fixture binaries beneath target/. The packer's relative-subdir test
+# seams keep both fixtures separate from real release assets.
+TARGET="$ROOT/tools/omp-spt/target"
+mkdir -p "$TARGET" || { echo "FAIL: cannot create fixture parent $TARGET"; exit 1; }
+TMP=$(mktemp -d "$TARGET/adapter-archive-fixture.XXXXXX") || { echo "FAIL: mktemp"; exit 1; }
+trap 'rm -rf "$TMP"' EXIT INT TERM
+REL=${TMP#"$TARGET/"}
+[ "$REL" != "$TMP" ] || { echo "FAIL: fixture is not beneath target/"; exit 1; }
+WIN_RELSUB="$REL/windows-release"
+LINUX_RELSUB="$REL/linux-release"
+mkdir -p "$TARGET/$WIN_RELSUB" "$TARGET/$LINUX_RELSUB" \
+  || { echo "FAIL: cannot create fixture binary directories"; exit 1; }
+printf '%s\n' 'deterministic windows omp-spt fixture' > "$TARGET/$WIN_RELSUB/omp-spt.exe"
+
+# A missing fixture platform must fail loudly rather than green-skip.
+if OMP_SPT_WIN_RELSUB="$WIN_RELSUB" \
+   OMP_SPT_LINUX_RELSUB="$REL/missing-linux-release" \
+   ADAPTER_SPT_OUT="$TMP/missing-platform.spt" \
+   sh "$PACKER" --apply >/dev/null 2>&1; then
+  fail "packer should refuse when a platform binary is absent"
+else
+  echo "ok   packer refuses when a platform binary is absent"
 fi
 
-# Both platforms present → build a real fat archive to a temp file and assert its structure.
-TMP=$(mktemp -d "${TMPDIR:-/tmp}/sptc-archtest.XXXXXX") || { echo "FAIL: mktemp"; exit 1; }
-trap 'rm -rf "$TMP"' EXIT
+printf '%s\n' 'deterministic linux omp-spt fixture' > "$TARGET/$LINUX_RELSUB/omp-spt"
 OUT="$TMP/adapter.spt"
 
-if ADAPTER_SPT_OUT="$OUT" sh "$PACKER" --apply >/dev/null 2>&1; then
+# [unit->REQ-DIST-ADAPTER-RELEASE]
+if OMP_SPT_WIN_RELSUB="$WIN_RELSUB" OMP_SPT_LINUX_RELSUB="$LINUX_RELSUB" \
+   ADAPTER_SPT_OUT="$OUT" sh "$PACKER" --apply >/dev/null 2>&1; then
   echo "ok   packer --apply succeeded"
 else
   fail "packer --apply exited non-zero"
@@ -65,6 +77,13 @@ for b in $BINS; do
     && echo "ok   $LINUX_TRIPLE/$b present" \
     || fail "$LINUX_TRIPLE/$b missing from archive"
 done
+# Prove the test exercised its fixtures rather than any real target/release binaries on this host.
+[ "$(tar -xOzf "$OUT" "$WIN_TRIPLE/omp-spt.exe")" = "deterministic windows omp-spt fixture" ] \
+  && echo "ok   Windows archive member came from deterministic fixture" \
+  || fail "Windows archive member did not come from deterministic fixture"
+[ "$(tar -xOzf "$OUT" "$LINUX_TRIPLE/omp-spt")" = "deterministic linux omp-spt fixture" ] \
+  && echo "ok   Linux archive member came from deterministic fixture" \
+  || fail "Linux archive member did not come from deterministic fixture"
 # Negative: the SHARED files must NOT sit under a triple (would not be shared), and no nested wrapper.
 if echo "$LIST" | grep -qE "^$WIN_TRIPLE/(manifest\.toml|strings/)"; then
   fail "manifest/strings duplicated under a triple — they must be shared at root only"
@@ -81,7 +100,7 @@ fi
 
 # A fat archive REQUIRES min_spt_core_version >= 0.13.2 — the packer must refuse a lower floor.
 # (Smoke the guard by reading the dry-run plan's advertised floor.)
-plan=$(sh "$PACKER" 2>&1)
+plan=$(OMP_SPT_WIN_RELSUB="$WIN_RELSUB" OMP_SPT_LINUX_RELSUB="$LINUX_RELSUB" sh "$PACKER" 2>&1)
 echo "$plan" | grep -qE "min_spt_core 0\.(1[3-9]|[2-9][0-9])" \
   && echo "ok   packer advertises a fat-capable floor (>= 0.13.2)" \
   || fail "packer floor advertisement missing/too low; plan=[$plan]"
diff --git a/tests/bridge-acceptance.sh b/tests/bridge-acceptance.sh
deleted file mode 100644
index a199e1c..0000000
--- a/tests/bridge-acceptance.sh
+++ /dev/null
@@ -1,132 +0,0 @@
-#!/bin/sh
-# omp-spt bridge acceptance (S2 ready-agent) — the end-to-end proof that a message to the perch is
-# driven into omp and answered, WITHOUT a live model (deterministic, zero billing). [impl->REQ-SKILL-LIVE]
-#
-# It exercises the REAL bridge (`claude-spt bridge`) against the REAL `spt` binary, substituting a
-# deterministic fake-omp (the compiled `examples/fake-omp` example) for `omp --mode rpc` via
-# $OMP_SPT_OMP_BIN. Asserts on side-effects (the plan's discipline — never model text):
-#   1. the SPT message reaches omp as a `{"type":"prompt"}` frame (the fake-omp prompt-log), and
-#   2. the bridge sends a reply back to the sender (the bridge trace).
-#
-# LIVE + spt-mutating (creates/purges a DISPOSABLE perch), so it is GATED OFF by default — set
-# OMP_SPT_ACCEPTANCE=1 to run. On a multi-subnet node set OMP_SPT_TEST_SUBNET (e.g. Phils-Den);
-# on a single-subnet node / CI leave it unset. Run: OMP_SPT_ACCEPTANCE=1 sh tests/bridge-acceptance.sh
-set -u
-
-if [ "${OMP_SPT_ACCEPTANCE:-0}" != "1" ]; then
-  echo "SKIP bridge-acceptance (set OMP_SPT_ACCEPTANCE=1 to run the live, spt-mutating E2E)"
-  exit 0
-fi
-
-ROOT=$(CDPATH= cd "$(dirname "$0")/.." && pwd)
-CRATE="$ROOT/tools/claude-spt"
-fail=0
-
-# ── Resolve binaries ─────────────────────────────────────────────────────────
-# Build the bridge + the fake-omp example (idempotent; the example never ships in adapter.spt).
-( cd "$CRATE" && cargo build --release && cargo build --release --example fake-omp ) >/dev/null 2>&1 \
-  || { echo "FAIL cargo build"; exit 1; }
-exe() { [ -f "$1.exe" ] && echo "$1.exe" || echo "$1"; }
-BIN=$(exe "$CRATE/target/release/omp-spt")
-FAKE=$(exe "$CRATE/target/release/examples/fake-omp")
-# spt: PATH first, then the known install location (mirrors the bridge's own spt_bin resolution).
-if command -v spt >/dev/null 2>&1; then SPT=spt
-elif [ -f "$LOCALAPPDATA/spt-core/bin/spt.exe" ]; then SPT="$LOCALAPPDATA/spt-core/bin/spt.exe"
-else echo "FAIL spt binary not found"; exit 1; fi
-
-# ── Disposable identity + scratch ──────────────────────────────────────────────
-# Never the operator's perch (name-keyed, last-establish-wins). A fixed uniquifier keeps replays clean.
-ID="omp-spt-acc-1"
-TX="omp-spt-acc-tx"
-work=$(mktemp -d) || { echo "FAIL mktemp"; exit 1; }
-LOG="$work/prompts.log"; ERR="$work/bridge.err"
-SUBNET_ARG=""
-[ -n "${OMP_SPT_TEST_SUBNET:-}" ] && SUBNET_ARG="--subnet $OMP_SPT_TEST_SUBNET"
-
-cleanup() {
-  [ -n "${BPID:-}" ] && kill "$BPID" 2>/dev/null
-  "$SPT" endpoint purge "$ID" --force >/dev/null 2>&1
-  rm -rf "$work"
-}
-trap cleanup EXIT INT TERM
-
-MARKER="PING-MARKER-acc-$$"
-REPLY="pong-acc"
-
-# ── Run: resident bridge (fake omp) → send a message → assert ──────────────────
-# shellcheck disable=SC2086
-SPT_ENDPOINT_ID="$ID" OMP_SPT_OMP_BIN="$FAKE" FAKE_OMP_LOG="$LOG" FAKE_OMP_REPLY="$REPLY" OMP_SPT_DEBUG=1 \
-  "$BIN" bridge --id "$ID" $SUBNET_ARG 2> "$ERR" &
-BPID=$!
-sleep 3   # bind + `spt ready` bringup
-
-printf '%s' "$MARKER" | "$SPT" send "$ID" --from "$TX" >/dev/null 2>&1
-sleep 3   # deliver → drive fake-omp → reply
-
-# 1. Inbound: the SPT message reached omp as a prompt frame.
-if [ -f "$LOG" ] && grep -q "$MARKER" "$LOG"; then
-  echo "ok   inbound: spt message forwarded to omp as a prompt ($MARKER)"
-else
-  echo "FAIL inbound: '$MARKER' not in fake-omp prompt log"; fail=1
-  echo "---- bridge stderr ----"; tail -8 "$ERR" 2>/dev/null
-fi
-
-# 2. Outbound: the bridge replied to the sender (always-on oplog line, HIGH-3 — no debug needed).
-if grep -q "reply out: to=$TX" "$ERR" 2>/dev/null; then
-  echo "ok   outbound: bridge replied to sender ($TX)"
-else
-  echo "FAIL outbound: no 'reply out: to=$TX' on the operational log"; fail=1
-fi
-
-# 3. Registration: the perch was bound (oplog breadcrumb).
-if grep -q "bound: id=$ID" "$ERR" 2>/dev/null; then
-  echo "ok   bind established the perch"
-else
-  echo "FAIL no 'bound: id=$ID' on the operational log"; fail=1
-fi
-
-# ── HIGH-4: a hung turn breaches the deadline, sender gets a failure notice ──────
-kill "$BPID" 2>/dev/null; sleep 1
-"$SPT" endpoint purge "$ID" --force >/dev/null 2>&1
-ERR2="$work/bridge-mute.err"
-# shellcheck disable=SC2086
-SPT_ENDPOINT_ID="$ID" OMP_SPT_OMP_BIN="$FAKE" FAKE_OMP_MUTE=1 OMP_SPT_TURN_TIMEOUT_S=3 \
-  "$BIN" bridge --id "$ID" $SUBNET_ARG 2> "$ERR2" &
-BPID=$!
-sleep 3
-printf 'hang me' | "$SPT" send "$ID" --from "$TX" >/dev/null 2>&1
-sleep 6   # 3s deadline + notice dispatch
-
-if grep -q "turn FAILED: no answer within 3s" "$ERR2" 2>/dev/null; then
-  echo "ok   hung turn breached the 3s deadline (perch recovered, not wedged)"
-else
-  echo "FAIL no turn-deadline breach on the log"; fail=1
-  echo "---- mute-bridge stderr ----"; tail -8 "$ERR2" 2>/dev/null
-fi
-if grep -q "failure notice out: to=$TX" "$ERR2" 2>/dev/null; then
-  echo "ok   sender was told the turn failed (LOW-2: never a silent empty reply)"
-else
-  echo "FAIL no failure notice was sent"; fail=1
-fi
-
-# ── HIGH-2: hard-killing the bridge leaves no orphaned children (Windows job object) ──
-if command -v powershell >/dev/null 2>&1; then
-  WPID=$(powershell -NoProfile -Command "(Get-Process omp-spt -ErrorAction SilentlyContinue | Select-Object -First 1).Id" | tr -d '\r')
-  if [ -n "$WPID" ]; then
-    powershell -NoProfile -Command "taskkill /F /PID $WPID" >/dev/null 2>&1
-    sleep 2
-    SURV=$(powershell -NoProfile -Command "(Get-Process fake-omp -ErrorAction SilentlyContinue | Measure-Object).Count" | tr -d '\r')
-    if [ "${SURV:-1}" -eq 0 ]; then
-      echo "ok   hard kill reaped the child tree (no fake-omp orphan)"
-    else
-      echo "FAIL $SURV fake-omp orphan(s) survived a hard kill"; fail=1
-      powershell -NoProfile -Command "Stop-Process -Name fake-omp -Force -ErrorAction SilentlyContinue"
-    fi
-  else
-    echo "SKIP orphan check (bridge already gone)"
-  fi
-else
-  echo "SKIP orphan check (non-Windows: job-object teardown is Windows-only today)"
-fi
-
-[ "$fail" -eq 0 ] && { echo "BRIDGE-ACCEPTANCE OK"; exit 0; } || { echo "BRIDGE-ACCEPTANCE FAIL"; exit 1; }
diff --git a/tests/ci-gates.sh b/tests/ci-gates.sh
index 67b5877..58a9dc2 100644
--- a/tests/ci-gates.sh
+++ b/tests/ci-gates.sh
@@ -1,25 +1,27 @@
 #!/bin/sh
-# Unit tests for CI helpers (pure/deterministic; no real bus or push needed).
-# Run: sh tests/ci-gates.sh   (exit 0 = pass).
-. "$(dirname "$0")/../ci/lib/spt-bus.sh"
+# Deterministic guard for the OMP-native CI dispatcher.
+set -u
+ROOT=$(CDPATH= cd "$(dirname "$0")/.." && pwd)
+GATES="$ROOT/ci/run-gates.sh"
 fail=0
 
-# resolve_spt_send: explicit override wins. Use a REAL executable (sh) — MSYS does not honour
-# `chmod +x` on an arbitrary temp file as `-x`, so synthesise nothing. [unit->REQ-CI-OWL-DISCOVERY]
-realexe=$(command -v sh)
-got=$(SPTC_CI_BUS="$realexe" resolve_spt_send)
-[ "$got" = "$realexe" ] && echo "ok   override resolves" || { echo "FAIL override: got [$got]"; fail=1; }
+sh -n "$GATES" && echo "ok   run-gates syntax" || { echo "FAIL run-gates syntax"; fail=1; }
+for required in \
+  'traceable-reqs check' \
+  'tests/manifest-shortcut.sh' \
+  'tests/native-launch-manifest.sh' \
+  'ci/digest/build.sh' \
+  'ci/manifest/check-manifest.sh'; do
+  grep -Fq "$required" "$GATES" \
+    && echo "ok   gate: $required" \
+    || { echo "FAIL missing gate: $required"; fail=1; }
+done
 
-# resolve_spt_send: a non-executable override is ignored (no false positive).
-bad=$(mktemp)  # plain file, not executable
-got=$(SPTC_CI_BUS="$bad" resolve_spt_send 2>/dev/null)
-[ "$got" != "$bad" ] && echo "ok   non-exec override rejected" || { echo "FAIL non-exec accepted"; fail=1; }
-rm -f "$bad"
+for stale in 'validate-skeleton' 'idle-translate' 'hooks-dispatch' 'acceptance-harness'; do
+  if grep -Fq "$stale" "$GATES"; then
+    echo "FAIL stale gate remains: $stale"
+    fail=1
+  fi
+done
 
-# run-gates.sh: valid shell + carries the load-bearing gates. [unit->REQ-CI-GATES]
-g="$(dirname "$0")/../ci/run-gates.sh"
-sh -n "$g" && echo "ok   run-gates syntax" || { echo "FAIL run-gates syntax"; fail=1; }
-grep -q 'traceable-reqs check' "$g" && echo "ok   gate: traceable-reqs" || { echo "FAIL missing traceable gate"; fail=1; }
-grep -q 'sh -n' "$g" && echo "ok   gate: shell-syntax" || { echo "FAIL missing syntax gate"; fail=1; }
-
-[ "$fail" -eq 0 ] && { echo "CI-HELPERS OK"; exit 0; } || { echo "CI-HELPERS FAIL"; exit 1; }
+[ "$fail" -eq 0 ] && { echo "CI-GATES OK"; exit 0; } || { echo "CI-GATES FAIL"; exit 1; }
diff --git a/tests/docs-gen.sh b/tests/docs-gen.sh
deleted file mode 100644
index c4f68a1..0000000
--- a/tests/docs-gen.sh
+++ /dev/null
@@ -1,28 +0,0 @@
-#!/bin/sh
-# Unit tests for the docs generator: deterministic output + full SUMMARY coverage. No mdbook needed.
-# Run: sh tests/docs-gen.sh   (exit 0 = pass). [unit->REQ-DOCS-DRIFT]
-ROOT=$(CDPATH= cd "$(dirname "$0")/.." && pwd)
-GEN="$ROOT/ci/docs/gen-llms.sh"
-SUMMARY="$ROOT/docs-site/src/SUMMARY.md"
-fail=0
-
-# 1. Deterministic: two regenerations are byte-identical.
-a=$(sh "$GEN" --check); b=$(sh "$GEN" --check)
-[ "$a" = "$b" ] && echo "ok   generator deterministic" || { echo "FAIL non-deterministic"; fail=1; }
-
-# 2. Coverage: every page linked in SUMMARY.md appears in the generated index (as .html).
-miss=0
-for rel in $(grep -o '(\./[A-Za-z0-9_./-]*\.md)' "$SUMMARY" | sed 's/^(\.\///; s/)$//'); do
-  html=$(printf '%s' "$rel" | sed 's/\.md$/.html/')
-  if printf '%s\n' "$a" | grep -q "($html)"; then :; else echo "FAIL uncovered page: $rel"; miss=1; fi
-done
-[ "$miss" -eq 0 ] && echo "ok   all SUMMARY pages covered" || fail=1
-
-# 3. Shape: starts with the H1 title and the blockquote summary (llms.txt convention).
-printf '%s\n' "$a" | head -n1 | grep -q '^# claude-spt' && echo "ok   has H1 title" || { echo "FAIL missing H1"; fail=1; }
-printf '%s\n' "$a" | grep -q '^> ' && echo "ok   has summary blockquote" || { echo "FAIL missing summary"; fail=1; }
-
-# 4. Drift gate is wired and valid shell.
-sh -n "$ROOT/ci/docs/check-docs.sh" && echo "ok   check-docs valid shell" || { echo "FAIL check-docs syntax"; fail=1; }
-
-[ "$fail" -eq 0 ] && { echo "DOCS-GEN OK"; exit 0; } || { echo "DOCS-GEN FAIL"; exit 1; }
diff --git a/tests/hooks-dispatch.sh b/tests/hooks-dispatch.sh
deleted file mode 100644
index 6f1cd16..0000000
--- a/tests/hooks-dispatch.sh
+++ /dev/null
@@ -1,118 +0,0 @@
-#!/bin/sh
-# Unit coverage for the STATIC-FOREVER plugin hook surface (D1). The hook LOGIC now lives in the
-# `claude-spt` binary and is unit-tested there (tools/claude-spt/src/hook.rs cargo tests — the port of
-# the old tests/hooks-parse.sh helper coverage). What remains in the PLUGIN is static-forever wiring:
-# hooks.json routes every CC event to dispatch.sh, and dispatch.sh resolves+execs the binary. This
-# test pins that wiring + the adapter-side declarations it depends on.
-# [unit->REQ-DIST-HOOK-BINARY] [unit->REQ-DIST-HOOKS-API] [unit->REQ-DIST-SKELETON-THIN]
-set -u
-fail=0
-check() { # check <label> <expected> <actual>
-  if [ "$2" = "$3" ]; then echo "ok   $1"; else echo "FAIL $1: expected [$2] got [$3]"; fail=1; fi
-}
-
-ROOT="$(CDPATH= cd "$(dirname "$0")/.." && pwd)"
-HK="$ROOT/plugin/omps/hooks"
-MAN="$ROOT/adapter/omp-spt.toml"
-BR="$ROOT/adapter/strings/briefs"
-SK="$ROOT/plugin/omps/skills"
-LV="$ROOT/adapter/strings/skills/live.md"
-
-# --- hooks.json: every CC event routes to dispatch.sh with its own event token (static-forever) ---
-for ev in SessionStart UserPromptSubmit PreToolUse Stop SessionEnd SubagentStart SubagentStop PostToolUse PostToolUseFailure Notification StopFailure; do
-  grep -q "\"$ev\"" "$HK/hooks.json" && r=yes || r=no
-  check "hooks.json declares $ev" "yes" "$r"
-  grep -q "dispatch.sh\\\\\" $ev" "$HK/hooks.json" && r=yes || r=no
-  check "$ev routes to dispatch.sh $ev" "yes" "$r"
-done
-# No per-event logic .sh remain (the eight wrappers + _common.sh were folded into the binary).
-n=$(ls "$HK"/*.sh 2>/dev/null | grep -Ec 'session-start|user-prompt-submit|pre-tool-use|stop|session-end|subagent-start|subagent-stop|post-tool-use|_common')
-check "old per-hook wrappers removed" "0" "$n"
-# PostToolUse keeps its Write matcher (the checkpoint detector scope).
-grep -q '"matcher": "Write"' "$HK/hooks.json" && r=yes || r=no
-check "PostToolUse keeps the Write matcher" "yes" "$r"
-# Notification uses the `*` matcher (v0.16.0 receive-heal): every notification type routes to the
-# binary, which is TYPE-AWARE — it LOGS every type (Step-0 instrumentation) but marks idle ONLY on
-# idle_prompt (REQ-HAZARD-STUCK-ACTIVE-NO-IDLE). A permission_prompt must NOT drain the spool mid-turn.
-grep -q '"matcher": "\*"' "$HK/hooks.json" && r=yes || r=no
-check "Notification uses the * matcher (type-aware in-binary)" "yes" "$r"
-# StopFailure + PostToolUseFailure are matcherless (all error types / all tools route through — the
-# binary discriminates): the receive-heal for an API-error turn-end and an Esc-during-tool-call.
-grep -q '"StopFailure"' "$HK/hooks.json" && grep -q '"PostToolUseFailure"' "$HK/hooks.json" && r=yes || r=no
-check "hooks.json wires StopFailure + PostToolUseFailure (receive-heal)" "yes" "$r"
-
-# --- dispatch.sh: static resolver shape ---
-sh -n "$HK/dispatch.sh" && r=ok || r=bad
-check "dispatch.sh is valid POSIX sh" "ok" "$r"
-grep -q 'get-string claude-spt hook_cmd' "$HK/dispatch.sh" && r=yes || r=no
-check "dispatch resolves the binary via [strings].hook_cmd" "yes" "$r"
-grep -q 'SPTC_HOOK_BIN' "$HK/dispatch.sh" && r=yes || r=no
-check "dispatch caches the resolved bin (SPTC_HOOK_BIN)" "yes" "$r"
-# v0.9.1 env-file fix: the cache value is QUOTED (CC sources $CLAUDE_ENV_FILE per Bash call; an
-# unquoted value with a space → `VAR=val cmd` → `hook: command not found` + lost value).
-grep -q 'SPTC_HOOK_BIN="%s"' "$HK/dispatch.sh" && r=yes || r=no
-check "dispatch quotes the cached value (env-file space-safe)" "yes" "$r"
-# `hook` is appended as a LITERAL subcommand (not embedded in the cached path).
-grep -q 'exec "\$bin" hook "\$event"' "$HK/dispatch.sh" && r=yes || r=no
-check "dispatch execs \"\$bin\" hook <event> (literal subcommand)" "yes" "$r"
-# Defensive: a trailing ` hook` from an older manifest value is stripped.
-grep -q 'bin="\${bin% hook}"' "$HK/dispatch.sh" && r=yes || r=no
-check "dispatch strips a legacy trailing ' hook' (cross-version safe)" "yes" "$r"
-
-# REGRESSION (v0.9.1, the env-file bug at its real seam): CC SOURCES $CLAUDE_ENV_FILE per Bash/hook
-# invocation. Emulate the exact line dispatch caches and source it in THIS shell — the v0.9.0 unquoted
-# value (a trailing ` hook`) must be shown to break (`hook: command not found`), and the v0.9.1 quoted
-# value must source clean AND preserve the value verbatim even with a space in the path.
-_ef=$(mktemp); _errf=$(mktemp)
-_old="/opt/spt/adapters/x/claude-spt hook"          # the exact v0.9.0 cached value (space before hook)
-_p="/c/Program Files/spt dir/claude-spt"            # worst case: a path WITH spaces
-# v0.9.0 (unquoted) — sourcing runs the bare `hook` token.
-unset SPTC_HOOK_BIN; printf 'SPTC_HOOK_BIN=%s\n' "$_old" > "$_ef"; : > "$_errf"
-. "$_ef" 2>"$_errf" || true
-grep -q 'hook: command not found' "$_errf" && r=yes || r=no
-check "unquoted v0.9.0 value DOES break when sourced (documents the bug)" "yes" "$r"
-# v0.9.1 (quoted) — clean source, value intact.
-unset SPTC_HOOK_BIN; printf 'SPTC_HOOK_BIN="%s"\n' "$_p" > "$_ef"; : > "$_errf"
-. "$_ef" 2>"$_errf" || true
-[ -s "$_errf" ] && r=dirty || r=clean
-check "quoted cache sources CLEAN (no stray command)" "clean" "$r"
-[ "${SPTC_HOOK_BIN:-}" = "$_p" ] && r=intact || r=lost
-check "quoted cache preserves the value verbatim (space-safe)" "intact" "$r"
-unset SPTC_HOOK_BIN; rm -f "$_ef" "$_errf"
-grep -q 'bootstrap.sh' "$HK/dispatch.sh" && r=yes || r=no
-check "dispatch runs the SessionStart bootstrap (invisible installer)" "yes" "$r"
-# bootstrap only on SessionStart (the binary cannot exist before spt-core + the adapter install).
-awk '/if \[ "\$event" = "SessionStart" \]/{s=1} /bootstrap.sh/{if(s)b=1} END{exit !b}' "$HK/dispatch.sh" && r=yes || r=no
-check "bootstrap gated to SessionStart" "yes" "$r"
-grep -q -- '--host-pid' "$HK/dispatch.sh" && r=yes || r=no
-check "dispatch passes the seed pid (--host-pid)" "yes" "$r"
-# No-op (exit 0) when the binary is unresolvable (adapter not registered yet / pre-/omps:setup).
-grep -q '\[ -z "\$bin" \] && exit 0' "$HK/dispatch.sh" && r=yes || r=no
-check "dispatch no-ops when the adapter is not yet registered" "yes" "$r"
-
-# --- manifest: the declarations the wiring depends on ---
-# v0.9.1: hook_cmd is the bare binary PATH (no trailing ` hook`); dispatch appends the subcommand.
-grep -q 'hook_cmd = "{adapter_dir}/omp-spt"' "$MAN" && r=yes || r=no
-check "manifest [strings].hook_cmd = {adapter_dir}/omp-spt (bare path)" "yes" "$r"
-# And the ASSIGNMENT line (anchored at col 0, not the explanatory comment) must not carry the old
-# space-before-hook value (the env-file regression).
-grep -qE '^hook_cmd = "\{adapter_dir\}/claude-spt hook"' "$MAN" && r=present || r=absent
-check "manifest hook_cmd assignment has no embedded ' hook' (env-file fix)" "absent" "$r"
-grep -q '^\[hooks\.PreToolUse\]' "$MAN" && r=yes || r=no
-check "manifest declares [hooks.PreToolUse]" "yes" "$r"
-grep -q 'live-ops = { file' "$MAN" && r=yes || r=no
-check "manifest registers briefs.live-ops" "yes" "$r"
-
-# --- U4: reactive-skill thinning (prose rides adapter strings, SKILL.md are thin stubs) ---
-grep -q 'commune' "$BR/live-ops.md" && grep -q '!!checkpoint!!' "$BR/live-ops.md" && grep -q 'endpoint shutdown' "$BR/live-ops.md" && r=yes || r=no
-check "live-ops brief carries commune+checkpoint+signoff" "yes" "$r"
-grep -q 'commune.md' "$LV" && grep -q '!!checkpoint!!' "$LV" && r=yes || r=no
-check "go-live body inlines commune+checkpoint" "yes" "$r"
-for s in commune signoff send; do
-  grep -q 'thin skeleton' "$SK/$s/SKILL.md" && r=yes || r=no
-  check "$s SKILL.md is a thin stub" "yes" "$r"
-done
-grep -q 'Normal commune' "$SK/commune/SKILL.md" && r=present || r=absent
-check "commune SKILL.md full body removed" "absent" "$r"
-
-[ "$fail" -eq 0 ] && { echo "ALL PASS"; exit 0; } || { echo "FAILURES"; exit 1; }
diff --git a/tests/manifest-schema.sh b/tests/manifest-schema.sh
index 094c557..874cf3a 100644
--- a/tests/manifest-schema.sh
+++ b/tests/manifest-schema.sh
@@ -1,13 +1,17 @@
 #!/bin/sh
-# Unit tests for the manifest-schema validator: it must PASS the real claude-spt manifest and FAIL
+# Unit tests for the manifest-schema validator: it must PASS the real omp-spt manifest and FAIL
 # on tampered copies (missing required field / bad enum / wrong type) — proving the gate catches
 # real breakage, not just green-on-green. Run: sh tests/manifest-schema.sh  (exit 0 = pass).
-# [unit->REQ-DIST-MANIFEST-SCHEMA]
 ROOT=$(CDPATH= cd "$(dirname "$0")/.." && pwd)
 SCHEMA="$ROOT/adapter/manifest.schema.json"
 MANIFEST="$ROOT/adapter/omp-spt.toml"
 VALIDATOR="$ROOT/ci/manifest/validate_manifest.py"
 
+for file in "$SCHEMA" "$MANIFEST" "$VALIDATOR"; do
+  [ -f "$file" ] || { echo "FAIL: required manifest-schema input missing: $file"; exit 1; }
+done
+command -v mktemp >/dev/null 2>&1 || { echo "FAIL: mktemp is required"; exit 1; }
+
 # Same interpreter probe as the gate wrapper — needs (tomllib|tomli)+jsonschema.
 PY=""
 for cand in python python3 py; do
@@ -18,12 +22,16 @@ sys.exit(0 if ((u.find_spec("tomllib") or u.find_spec("tomli")) and u.find_spec(
 PROBE
   then PY="$cand"; break; fi
 done
-if [ -z "$PY" ]; then echo "SKIP: no python with (tomllib|tomli)+jsonschema"; echo "MANIFEST-SCHEMA OK (skipped)"; exit 0; fi
+if [ -z "$PY" ]; then
+  echo "FAIL: no python with (tomllib|tomli)+jsonschema"
+  exit 1
+fi
 
 fail=0
 ok()   { echo "ok   $1"; }
 bad()  { echo "FAIL $1"; fail=1; }
 
+# [unit->REQ-DIST-MANIFEST-SCHEMA]
 # 1. The real manifest validates (exit 0).
 if "$PY" "$VALIDATOR" "$SCHEMA" "$MANIFEST" >/dev/null 2>&1; then ok "real manifest validates"; else bad "real manifest rejected"; "$PY" "$VALIDATOR" "$SCHEMA" "$MANIFEST"; fi
 
@@ -36,6 +44,7 @@ expect_reject() {
   if "$PY" "$VALIDATOR" "$SCHEMA" "$file" >/dev/null 2>&1; then bad "$desc not caught"; else ok "catches $desc"; fi
 }
 
+# [unit->REQ-DIST-MANIFEST-SCHEMA]
 # 2. Missing the required [adapter] table entirely.
 cat > "$work/m.toml" <<'EOF'
 [strings]
@@ -46,7 +55,7 @@ expect_reject "missing [adapter]"
 # 3. [adapter] missing a required field (min_spt_core_version).
 cat > "$work/m.toml" <<'EOF'
 [adapter]
-name = "claude-spt"
+name = "omp-spt"
 version = "0.1.0"
 EOF
 expect_reject "missing required adapter.min_spt_core_version"
@@ -54,30 +63,30 @@ expect_reject "missing required adapter.min_spt_core_version"
 # 4. Bad enum value for adapter.kind.
 cat > "$work/m.toml" <<'EOF'
 [adapter]
-name = "claude-spt"
+name = "omp-spt"
 kind = "robot"
 version = "0.1.0"
-min_spt_core_version = "0.7.0"
+min_spt_core_version = "0.29.0"
 EOF
 expect_reject "invalid adapter.kind enum"
 
-# 5. Wrong type: a hook with no `fires` (required) / wrong shape.
+# 5. Wrong type: hostable_types must be an array.
 cat > "$work/m.toml" <<'EOF'
 [adapter]
-name = "claude-spt"
+name = "omp-spt"
+kind = "harness"
 version = "0.1.0"
-min_spt_core_version = "0.7.0"
-[hooks.SessionStart]
-reads = ["session_id"]
+min_spt_core_version = "0.29.0"
+hostable_types = "LiveAgent"
 EOF
-expect_reject "hook missing required fires"
+expect_reject "non-array adapter.hostable_types"
 
 # 6. Wrong type: shortcut_basename as an integer.
 cat > "$work/m.toml" <<'EOF'
 [adapter]
-name = "claude-spt"
+name = "omp-spt"
 version = "0.1.0"
-min_spt_core_version = "0.7.0"
+min_spt_core_version = "0.29.0"
 shortcut_basename = 42
 EOF
 expect_reject "non-string shortcut_basename"
diff --git a/tests/manifest-shortcut.sh b/tests/manifest-shortcut.sh
index 27a9ee8..917a4a1 100644
--- a/tests/manifest-shortcut.sh
+++ b/tests/manifest-shortcut.sh
@@ -1,9 +1,6 @@
 #!/bin/sh
-# Brand-value + manifest-contract regression guard for omp-spt (rewritten from the claude-spt
-# version at the S4 cut — the CC launch-shim/ccs assertions it carried now guard the native OMP
-# hosting seam; see ADR-0007).
+# Manifest cutover regression guard for omp-spt.
 # Run: sh tests/manifest-shortcut.sh (exit 0 = pass).
-# [unit->REQ-DIST-SHORTCUT-BASENAME]
 ROOT=$(CDPATH= cd "$(dirname "$0")/.." && pwd)
 MANIFEST="$ROOT/adapter/omp-spt.toml"
 EXTENSION="$ROOT/adapter/strings/omp-spt.mjs"
@@ -26,16 +23,36 @@ grep -Eq '^[[:space:]]*host_binaries[[:space:]]*=.*"omp"' "$MANIFEST" \
   && echo 'ok   host_binaries includes "omp"' || { echo "FAIL host_binaries misses omp"; fail=1; }
 
 field_of() { awk -v h="[$1]" -v f="$2" '$0 == h {s=1;next} /^\[/{s=0} s && $0 ~ f' "$MANIFEST"; }
+hosts=$(field_of adapter '^[[:space:]]*hostable_types[[:space:]]*=')
+case "$hosts" in
+  'hostable_types = ["LiveAgent", "ReadyAgent"]') echo "ok   hostable_types exposes ReadyAgent + LiveAgent only" ;;
+  *) echo "FAIL hostable_types must be exactly LiveAgent + ReadyAgent: $hosts"; fail=1 ;;
+esac
 
-# ── bringup: native OMP owns the broker PTY and loads the packaged SPT extension ─────────────────
+# ── bringup: launch shim resolves OMP, then native OMP owns the broker PTY ────────────────────────
 # [unit->REQ-OMP-NATIVE-TUI]
-spawn=$(grep -E '^[[:space:]]*command[[:space:]]*=[[:space:]]*"omp .*--extension \{adapter_dir\}/strings/omp-spt\.mjs' "$MANIFEST")
-nspawn=$(printf '%s' "$spawn" | grep -c .)
-if [ "$nspawn" -eq 2 ]; then echo "ok   2 native omp spawn commands (self + resume)"; else echo "FAIL expected 2 native omp spawn commands, found $nspawn"; fail=1; fi
+self_spawn=$(field_of session.self '^[[:space:]]*command[[:space:]]*=')
+resume_spawn=$(field_of session.resume '^[[:space:]]*command[[:space:]]*=')
+case "$self_spawn" in
+  'command = "{adapter_dir}/omp-spt launch-omp --extension {adapter_dir}/strings/omp-spt.mjs"')
+    echo "ok   [session.self] uses the native OMP launch shim" ;;
+  *) echo "FAIL [session.self] does not use the native OMP launch shim: $self_spawn"; fail=1 ;;
+esac
+case "$resume_spawn" in
+  'command = "{adapter_dir}/omp-spt launch-omp --resume {session_id} --extension {adapter_dir}/strings/omp-spt.mjs"')
+    echo "ok   [session.resume] uses native resume through the launch shim" ;;
+  *) echo "FAIL [session.resume] does not use native resume through the launch shim: $resume_spawn"; fail=1 ;;
+esac
+spawn="$self_spawn
+$resume_spawn"
 if [ "$(printf '%s\n' "$spawn" | grep -c -- '--mode rpc')" -eq 0 ]; then echo "ok   hosted sessions never use headless RPC mode"; else echo "FAIL a hosted session still uses --mode rpc: $spawn"; fail=1; fi
-resume=$(printf '%s\n' "$spawn" | grep -- '-r {session_id}')
-nresume=$(printf '%s' "$resume" | grep -c .)
-if [ "$nresume" -eq 1 ]; then echo "ok   exactly one native resume command carries -r {session_id}"; else echo "FAIL expected 1 -r {session_id} command, found $nresume"; fail=1; fi
+if [ "$(grep -Ec '^[[:space:]]*command[[:space:]]*=[[:space:]]*"\{adapter_dir\}/omp-spt launch-omp ' "$MANIFEST")" -eq 2 ]; then echo "ok   exactly 2 native launch-shim commands"; else echo "FAIL expected exactly 2 native launch-shim commands"; fail=1; fi
+
+# ── continuity file-drops belong to SPT, not a harness configuration directory ───────────────────
+commune_dir=$(field_of session '^[[:space:]]*commune_dir[[:space:]]*=')
+signoff_dir=$(field_of session '^[[:space:]]*signoff_dir[[:space:]]*=')
+case "$commune_dir" in 'commune_dir = ".spt"') echo "ok   commune_dir = .spt" ;; *) echo "FAIL commune_dir must be .spt: $commune_dir"; fail=1 ;; esac
+case "$signoff_dir" in 'signoff_dir = ".spt"') echo "ok   signoff_dir = .spt" ;; *) echo "FAIL signoff_dir must be .spt: $signoff_dir"; fail=1 ;; esac
 if [ -f "$EXTENSION" ]; then echo "ok   packaged omp-spt extension exists"; else echo "FAIL packaged omp-spt extension missing"; fail=1; fi
 if command -v node >/dev/null 2>&1; then NODE=node
 elif command -v node.exe >/dev/null 2>&1; then NODE=node.exe
@@ -57,7 +74,7 @@ if [ "$npsy" -eq 2 ]; then echo "ok   both psyche roles run psyche-omp with the
 # The retired resident key must stay GONE from both psyche roles.
 if grep -q 'psyche_prompt' "$MANIFEST"; then echo "FAIL a psyche role references the retired {psyche_prompt}"; fail=1; else echo "ok   no {psyche_prompt} anywhere (event rides stdin)"; fi
 
-# [unit->REQ-HAZARD-PSYCHE-IDENTITY-ENV] — identity-env scrub on BOTH psyche roles.
+# [unit->REQ-PSYCHE-EPHEMERAL-SHIM] — identity-env scrub on both Psyche roles.
 for role in session.psyche_init session.psyche_resume; do
   scrub=$(field_of "$role" '^[[:space:]]*env_remove[[:space:]]*=')
   if [ -z "$scrub" ]; then echo "FAIL [$role] has no env_remove (identity-env scrub missing)"; fail=1; else
@@ -79,16 +96,26 @@ if grep -Eq '^[[:space:]]*repo[[:space:]]*=[[:space:]]*"SaberMage/' "$MANIFEST";
 if grep -Eq '^[[:space:]]*transport[[:space:]]*=[[:space:]]*"gh"' "$MANIFEST"; then echo 'ok   [update].transport = "gh"'; else echo "FAIL [update] transport must use gh for auth-capable release fetch"; fail=1; fi
 if grep -Eq '^[[:space:]]*message[[:space:]]*=' "$MANIFEST"; then echo "ok   [update].message present"; else echo "FAIL [update] has no message field"; fail=1; fi
 if grep -Eq 'endpoint run --adapter omp-spt --id <id> --create --start' "$MANIFEST"; then echo "FAIL fresh-endpoint update notice still uses --start (hides the harness PTY)"; fail=1; else echo "ok   fresh-endpoint update notice omits --start (attach-default PTY)"; fi
-if grep -Eq '^\[update\.post\]' "$MANIFEST"; then echo "ok   [update.post] table present"; else echo "FAIL no [update.post] table"; fail=1; fi
 
-# ── idle-translate binary seam (harness-agnostic; unchanged from claude-spt) ──────────────────────
-if grep -Eq '^[[:space:]]*command[[:space:]]*=[[:space:]]*"{adapter_dir}/omp-spt translate"' "$MANIFEST"; then echo "ok   [message-idle-translation-binary].command = translate"; else echo "FAIL idle-translate command missing/wrong"; fail=1; fi
-if grep -Eq '^[[:space:]]*path[[:space:]]*=[[:space:]]*"cc-spt-idle-translate"' "$MANIFEST"; then echo "FAIL deprecated idle-translate path still present"; fail=1; else echo "ok   no deprecated idle-translate path (command-only)"; fi
-
-# ── no shipped profile overlays (ccs was CC-specific; omp profiles ride `-- --profile`) ───────────
-if grep -Eq '^\[profiles\.' "$MANIFEST"; then echo "FAIL a shipped [profiles.*] table lingers (ccs was removed for omp)"; fail=1; else echo "ok   no shipped profile overlays"; fi
+# ── retired foreign-harness seams stay absent ────────────────────────────────────────────────────
+# [unit->REQ-OMP-NATIVE-TUI]
+for stale in \
+  '^\[update\.post\]' \
+  '^\[hooks\.' \
+  '^\[inject\]' \
+  '^\[message-idle-translation-binary\]' \
+  '^\[env\.SPT_INJECT_VERIFY_ECHO\]' \
+  '^\[env\.CLAUDE_CONFIG_DIR\]' \
+  '^[[:space:]]*hook_cmd[[:space:]]*=' \
+  '^[[:space:]]*command[[:space:]]*=.* translate'; do
+  if grep -Eq "$stale" "$MANIFEST"; then
+    echo "FAIL retired manifest surface remains: $stale"
+    fail=1
+  fi
+done
+if [ "$fail" -eq 0 ]; then echo "ok   retired update/hook/inject/translation/env surfaces absent"; fi
 
-# ── [env.SPT_INJECT_VERIFY_ECHO] stays declared (inert on omp; forward-safe) ──────────────────────
-if awk '/^\[env\.SPT_INJECT_VERIFY_ECHO\]/{found=1} END{exit !found}' "$MANIFEST"; then echo "ok   [env.SPT_INJECT_VERIFY_ECHO] declared"; else echo "FAIL [env.SPT_INJECT_VERIFY_ECHO] missing"; fail=1; fi
+# OMP model routing is native; the adapter ships no foreign profile overlay.
+if grep -Eq '^\[profiles\.' "$MANIFEST"; then echo "FAIL a shipped [profiles.*] table lingers"; fail=1; else echo "ok   no shipped profile overlays"; fi
 
 [ "$fail" -eq 0 ] && { echo "MANIFEST-SHORTCUT OK"; exit 0; } || { echo "MANIFEST-SHORTCUT FAIL"; exit 1; }
diff --git a/tests/msys-hazard.sh b/tests/msys-hazard.sh
deleted file mode 100644
index 1478f43..0000000
--- a/tests/msys-hazard.sh
+++ /dev/null
@@ -1,42 +0,0 @@
-#!/bin/sh
-# REQ-HAZARD-MSYS-PATHCONV conformance (D1 architecture). The CC hook payload — which can contain
-# /-leading content (e.g. a prompt "/omps:send doyle") — must reach the handler via STDIN (immune to
-# MSYS), never as a positional argv (Git-Bash path-mangles a /-leading argv on Windows — see
-# docs/KNOWN-HAZARDS.md 1.1). After D1 the only argv passed anywhere is the CC EVENT NAME (SessionStart,
-# …) + the numeric --host-pid — never message/prompt content, and never /-leading.
-# Run: sh tests/msys-hazard.sh   (exit 0 = pass).   [unit->REQ-HAZARD-MSYS-PATHCONV]
-ROOT="$(CDPATH= cd "$(dirname "$0")/.." && pwd)"
-HK="$ROOT/plugin/omps/hooks"
-HOOKRS="$ROOT/tools/claude-spt/src/hook.rs"
-fail=0
-yn() { [ "$1" -eq 0 ] && echo yes || echo no; }
-
-# 1. hooks.json passes dispatch.sh only a bare, non-/-leading CC event-name token (no payload content).
-#    Every `dispatch.sh <token>` token must be alphabetic (an event name), never /-leading.
-bad_tokens=$(grep -oE 'dispatch\.sh\\?" [^"]+' "$HK/hooks.json" | sed 's#.*dispatch\.sh\\\?" ##' | grep -Ec '^[A-Za-z]' )
-tot_tokens=$(grep -oE 'dispatch\.sh\\?" [^"]+' "$HK/hooks.json" | wc -l | tr -d ' ')
-if [ "$bad_tokens" -ne "$tot_tokens" ] || [ "$tot_tokens" -eq 0 ]; then
-  printf 'FAIL hooks.json: a dispatch token is not a bare event name (%s/%s alphabetic)\n' "$bad_tokens" "$tot_tokens"; fail=1
-fi
-if grep -qE 'dispatch\.sh\\?" +/' "$HK/hooks.json"; then
-  printf 'FAIL hooks.json: a /-leading positional token is passed to dispatch.sh (MSYS-unsafe)\n'; fail=1
-fi
-
-# 2. dispatch.sh must NOT read the payload (no `cat`) — it inherits stdin straight through to the
-#    binary — and must NOT reconstruct content from a positional argv ($1 is the event name only).
-if grep -qE '\$\(\s*cat\b' "$HK/dispatch.sh"; then
-  printf 'FAIL dispatch.sh: reads stdin itself (must pass it through to the binary)\n'; fail=1
-fi
-if grep -Eq '(prompt|msg|body|message|content|file_path)=("?\$[1-9])' "$HK/dispatch.sh"; then
-  printf 'FAIL dispatch.sh: parses payload content from a positional argv (MSYS-unsafe)\n'; fail=1
-fi
-
-# 3. The binary reads the CC payload from STDIN and parses every field off that parsed object — never
-#    from argv (which only carries the event name + --host-pid).
-grep -q 'stdin().read_to_string' "$HOOKRS" && r=0 || r=1
-[ "$r" -eq 0 ] || { printf 'FAIL hook.rs: does not read the CC payload from stdin\n'; fail=1; }
-# The argv loop handles only --host-pid; the payload fields come from the parsed stdin Value (field/nested).
-grep -q 'serde_json::from_str' "$HOOKRS" && r=0 || r=1
-[ "$r" -eq 0 ] || { printf 'FAIL hook.rs: does not parse the stdin payload as JSON\n'; fail=1; }
-
-[ "$fail" -eq 0 ] && { echo "MSYS-HAZARD OK"; exit 0; } || { echo "MSYS-HAZARD FAIL"; exit 1; }
diff --git a/tests/omp-extension.mjs b/tests/omp-extension.mjs
index 2ccf034..60c8ed2 100644
--- a/tests/omp-extension.mjs
+++ b/tests/omp-extension.mjs
@@ -1,25 +1,833 @@
 import assert from "node:assert/strict";
-import { decodeBody, drainEvents, extractReply } from "../adapter/strings/omp-spt.mjs";
+import { EventEmitter } from "node:events";
+import {
+	createOmpSpt,
+	decodeBody,
+	drainEvents,
+	extractReply,
+} from "../adapter/strings/omp-spt.mjs";
 
+const flush = () => new Promise((resolve) => setImmediate(resolve));
+function deferred() {
+	let resolve;
+	let reject;
+	const promise = new Promise((resolvePromise, rejectPromise) => {
+		resolve = resolvePromise;
+		reject = rejectPromise;
+	});
+	return { promise, reject, resolve };
+}
+
+class FakeStream extends EventEmitter {
+	setEncoding(encoding) {
+		this.encoding = encoding;
+	}
+}
+
+class FakeChild extends EventEmitter {
+	constructor() {
+		super();
+		this.stdout = new FakeStream();
+		this.stderr = new FakeStream();
+		this.kills = 0;
+	}
+
+	kill() {
+		this.kills += 1;
+	}
+}
+
+class FakeClock {
+	constructor() {
+		this.nextId = 1;
+		this.timers = new Map();
+	}
+
+	setTimeout(fn, delay) {
+		const handle = { id: this.nextId++, unref() {} };
+		this.timers.set(handle, { fn, delay });
+		return handle;
+	}
+
+	clearTimeout(handle) {
+		this.timers.delete(handle);
+	}
+
+	delays() {
+		return [...this.timers.values()].map(({ delay }) => delay);
+	}
+
+	async runNext(expectedDelay) {
+		const entry = [...this.timers.entries()].sort((left, right) => left[1].delay - right[1].delay)[0];
+		assert.ok(entry, `expected a ${expectedDelay}ms timer`);
+		const [handle, timer] = entry;
+		assert.equal(timer.delay, expectedDelay);
+		this.timers.delete(handle);
+		timer.fn();
+		await flush();
+	}
+}
+
+function createHarness(options = {}) {
+	const handlers = new Map();
+	const calls = [];
+	const children = [];
+	const submitted = [];
+	const statuses = [];
+	const notifications = [];
+	const errors = [];
+	const debug = [];
+	const clock = new FakeClock();
+	let shutdowns = 0;
+
+	const ui = {
+		notify(message, type) {
+			notifications.push({ message, type });
+		},
+		setStatus(key, text) {
+			statuses.push({ key, text });
+		},
+	};
+	const ctx = {
+		ui,
+		sessionManager: { getSessionId: () => options.sessionId ?? "session-1" },
+		shutdown() {
+			shutdowns += 1;
+		},
+	};
+	const pi = {
+		logger: {
+			error(message, details) {
+				errors.push({ message, details });
+			},
+			debug(message, details) {
+				debug.push({ message, details });
+			},
+		},
+		on(name, handler) {
+			const registered = handlers.get(name) ?? [];
+			registered.push(handler);
+			handlers.set(name, registered);
+		},
+		sendUserMessage(content) {
+			submitted.push(content);
+			options.onSubmit?.(content);
+		},
+	};
+	const runSptCommand = async (args, input) => {
+		const call = { args: [...args], input };
+		calls.push(call);
+		const overridden = await options.onRun?.(call);
+		if (overridden !== undefined) return overridden;
+		if (args[0] === "api" && args[3] === "bind") {
+			return options.bindOutput ?? "BOUND endpoint token=token-123";
+		}
+		return "";
+	};
+	const spawnProcess = (binary, args, spawnOptions) => {
+		const child = new FakeChild();
+		child.binary = binary;
+		child.args = [...args];
+		child.spawnOptions = spawnOptions;
+		children.push(child);
+		return child;
+	};
+	const extension = createOmpSpt({
+		env: {
+			SPT_ENDPOINT_ID: options.id ?? "omp-agent",
+			OMP_SPT_SUBNET: options.subnet,
+			OMP_SPT_SPT_BIN: "spt-test",
+		},
+		restartDelaysMs: options.restartDelaysMs ?? [5, 10],
+		outcomeRetryDelaysMs: options.outcomeRetryDelaysMs ?? [],
+		sessionEndRetryDelaysMs: options.sessionEndRetryDelaysMs ?? [],
+		listenerStableMs: options.listenerStableMs ?? false,
+		runSptCommand,
+		spawnProcess,
+		setTimeout: clock.setTimeout.bind(clock),
+		clearTimeout: clock.clearTimeout.bind(clock),
+	});
+	extension(pi);
+
+	async function emit(name, event = {}) {
+		let result;
+		for (const handler of handlers.get(name) ?? []) {
+			const returned = await handler({ type: name, ...event }, ctx);
+			if (returned !== undefined) result = returned;
+		}
+		return result;
+	}
+
+	return {
+		calls,
+		children,
+		clock,
+		ctx,
+		debug,
+		emit,
+		errors,
+		handlers,
+		notifications,
+		statuses,
+		submitted,
+		get shutdowns() {
+			return shutdowns;
+		},
+	};
+}
+
+function commandCalls(harness, command) {
+	return harness.calls.filter((call) => call.args[0] === command);
+}
+
+function stateCalls(harness) {
+	return harness.calls.filter((call) => call.args[0] === "api" && call.args[3] === "state");
+}
+
+async function testParsingAndReplies() {
+	assert.equal(decodeBody('a&lt;b&gt;<br>&quot;c&quot; &amp; &amp;lt;'), 'a<b>\n"c" & &lt;');
+
+	const partialEnvelope = '<EVENT type="msg" from="doyle">hello<br>wo';
+	const partial = drainEvents(`noise${partialEnvelope}`);
+	assert.deepEqual(partial.events, []);
+	assert.equal(partial.rest, partialEnvelope);
+
+	const envelope = `${partial.rest}rld</EVENT>`;
+	const complete = drainEvents(`${envelope}<EVENT type="notify">skip</EVENT>`);
+	assert.deepEqual(complete.events, [
+		{ from: "doyle", body: "hello\nworld", envelope },
+	]);
+	assert.equal(complete.rest, "");
+
+	assert.equal(
+		extractReply([
+			{ role: "assistant", content: [{ type: "text", text: "first" }] },
+			{ role: "toolResult", content: [] },
+			{
+				role: "assistant",
+				content: [
+					{ type: "text", text: "final " },
+					{ type: "text", text: "answer" },
+				],
+			},
+		]),
+		"final answer",
+	);
+	assert.equal(
+		extractReply(
+			[
+				{ role: "assistant", content: "stale answer" },
+				{ role: "user", content: '<msg from="doyle"/>' },
+			],
+			'<msg from="doyle"/>',
+		),
+		"",
+	);
+}
+
+// [unit->REQ-OMP-EXTENSION-CUSTODY]
+// [unit->REQ-OMP-SESSION-IMMUTABLE]
+// [unit->REQ-OMP-MESSAGE-CONTEXT]
 // [unit->REQ-OMP-NATIVE-TUI]
-assert.equal(decodeBody('a&lt;b&gt;<br>&quot;c&quot; &amp; &amp;lt;'), 'a<b>\n"c" & &lt;');
-
-const partial = drainEvents('noise<EVENT type="msg" from="doyle">hello<br>wo');
-assert.deepEqual(partial.events, []);
-assert.equal(partial.rest, '<EVENT type="msg" from="doyle">hello<br>wo');
-
-const complete = drainEvents(`${partial.rest}rld</EVENT><EVENT type="notify">skip</EVENT>`);
-assert.deepEqual(complete.events, [{ from: "doyle", body: "hello\nworld" }]);
-assert.equal(complete.rest, "");
-
-assert.equal(
-	extractReply([
-		{ role: "assistant", content: [{ type: "text", text: "first" }] },
-		{ role: "toolResult", content: [] },
-		{ role: "assistant", content: [{ type: "text", text: "final " }, { type: "text", text: "answer" }] },
-	]),
-	"final answer",
-);
-assert.equal(extractReply([{ role: "user", content: "hello" }]), "");
+async function testLifecycleCustodyAndContext() {
+	const harness = createHarness({ subnet: "mesh-a" });
+	assert.deepEqual([...harness.handlers.keys()], [
+		"session_start",
+		"session_before_switch",
+		"session_before_branch",
+		"context",
+		"agent_start",
+		"agent_end",
+		"session_shutdown",
+	]);
+
+	await harness.emit("session_start");
+	assert.deepEqual(harness.calls[0], {
+		args: [
+			"api",
+			"--adapter",
+			"omp-spt",
+			"bind",
+			"omp-agent",
+			"--set-session-id",
+			"session-1",
+			"--subnet",
+			"mesh-a",
+		],
+		input: undefined,
+	});
+	assert.deepEqual(harness.calls[1].args, [
+		"api",
+		"--adapter",
+		"omp-spt",
+		"state",
+		"idle",
+		"omp-agent",
+		"--token",
+		"token-123",
+	]);
+	assert.equal(harness.children.length, 1);
+	assert.equal(harness.children[0].binary, "spt-test");
+	assert.deepEqual(harness.children[0].args, ["ready", "omp-agent", "--subnet", "mesh-a"]);
+
+	for (const reason of ["new", "resume", "fork", "handoff"]) {
+		assert.deepEqual(await harness.emit("session_before_switch", { reason }), { cancel: true });
+		assert.ok(
+			harness.notifications.some(({ message }) =>
+				message.includes(`${reason} session switch`),
+			),
+		);
+	}
+	assert.deepEqual(await harness.emit("session_before_branch"), { cancel: true });
+	assert.ok(
+		harness.notifications.some(({ message }) => message.includes("session branch")),
+	);
+
+	const aliceEnvelope =
+		'<EVENT type="msg" from="alice" event_id="evt-1">hello&lt;world<br>line</EVENT>';
+	const bobEnvelope = '<EVENT type="msg" from="bob" event_id="evt-2">second</EVENT>';
+	harness.children[0].stdout.emit("data", `${aliceEnvelope}${bobEnvelope}`);
+	await flush();
+	assert.deepEqual(harness.submitted, ['<msg from="alice"/>']);
+	assert.deepEqual(
+		stateCalls(harness).map((call) => call.args[4]),
+		["idle", "busy"],
+	);
+
+	const originalMessages = [{ role: "user", content: '<msg from="alice"/>' }];
+	const context = await harness.emit("context", { messages: originalMessages });
+	assert.equal(originalMessages[0].content, '<msg from="alice"/>');
+	assert.equal(context.messages[0].content, `<msg from="alice"/>\n\n${aliceEnvelope}`);
+
+	const arrayContext = await harness.emit("context", {
+		messages: [{ role: "user", content: [{ type: "text", text: '<msg from="alice"/>' }] }],
+	});
+	assert.deepEqual(arrayContext.messages[0].content, [
+		{ type: "text", text: '<msg from="alice"/>' },
+		{ type: "text", text: `\n\n${aliceEnvelope}` },
+	]);
+
+	await harness.emit("agent_start");
+	assert.deepEqual(
+		stateCalls(harness).map((call) => call.args[4]),
+		["idle", "busy"],
+		"agent_start must not duplicate the already-honest busy transition",
+	);
+	await harness.emit("agent_end", {
+		messages: [
+			{ role: "user", content: '<msg from="alice"/>' },
+			{ role: "assistant", content: [{ type: "text", text: "alice reply" }] },
+		],
+	});
+	assert.deepEqual(harness.submitted, ['<msg from="alice"/>']);
+	assert.deepEqual(harness.clock.delays(), [0]);
+
+	await harness.clock.runNext(0);
+	assert.deepEqual(harness.submitted, ['<msg from="alice"/>', '<msg from="bob"/>']);
+	await harness.emit("agent_start");
+	await harness.emit("agent_end", {
+		messages: [
+			{ role: "assistant", content: "previous reply" },
+			{ role: "user", content: '<msg from="bob"/>' },
+		],
+	});
+
+	const outcomes = commandCalls(harness, "send");
+	assert.equal(outcomes.length, 2);
+	assert.deepEqual(
+		outcomes.map((call) => call.args),
+		[
+			["send", "alice", "--from", "omp-agent"],
+			["send", "bob", "--from", "omp-agent"],
+		],
+	);
+	assert.equal(outcomes[0].input, "alice reply");
+	assert.match(outcomes[1].input, /turn ended without an assistant response/);
+	assert.deepEqual(
+		stateCalls(harness).map((call) => call.args[4]),
+		["idle", "busy", "idle", "busy", "idle"],
+	);
+	for (const call of [...stateCalls(harness), ...harness.calls.filter((candidate) => candidate.args[3] === "session-end")]) {
+		assert.deepEqual(call.args.slice(-2), ["--token", "token-123"]);
+	}
+
+	await harness.emit("session_shutdown");
+	const ended = harness.calls.filter((call) => call.args[3] === "session-end");
+	assert.equal(ended.length, 1);
+	assert.deepEqual(ended[0].args.slice(-2), ["--token", "token-123"]);
+	assert.equal(harness.children[0].kills, 1);
+	assert.deepEqual(harness.clock.delays(), []);
+}
+
+async function testDeferredBindLifecycleSerialization() {
+	const busyBind = deferred();
+	const busyHarness = createHarness({
+		onRun(call) {
+			if (call.args[0] === "api" && call.args[3] === "bind") return busyBind.promise;
+		},
+	});
+	const startingBusy = busyHarness.emit("session_start");
+	await flush();
+	const becomingBusy = busyHarness.emit("agent_start");
+	await flush();
+	assert.deepEqual(stateCalls(busyHarness), []);
+	assert.equal(busyHarness.children.length, 0);
+
+	busyBind.resolve("BOUND endpoint token=token-busy");
+	await Promise.all([startingBusy, becomingBusy]);
+	assert.deepEqual(
+		stateCalls(busyHarness).map((call) => call.args[4]),
+		["busy"],
+		"agent_start before bind completion must suppress the stale idle publication",
+	);
+	assert.equal(busyHarness.children.length, 1);
+	await busyHarness.emit("session_shutdown");
+	assert.deepEqual(busyHarness.clock.delays(), []);
+
+	const shutdownBind = deferred();
+	const shutdownHarness = createHarness({
+		onRun(call) {
+			if (call.args[0] === "api" && call.args[3] === "bind") return shutdownBind.promise;
+		},
+	});
+	const startingShutdown = shutdownHarness.emit("session_start");
+	await flush();
+	const shuttingDown = shutdownHarness.emit("session_shutdown");
+	await flush();
+	assert.equal(shutdownHarness.children.length, 0);
+	assert.equal(
+		shutdownHarness.calls.filter((call) => call.args[3] === "session-end").length,
+		0,
+	);
+
+	shutdownBind.resolve("BOUND endpoint token=token-shutdown");
+	await Promise.all([startingShutdown, shuttingDown]);
+	assert.deepEqual(stateCalls(shutdownHarness), []);
+	assert.equal(shutdownHarness.children.length, 0);
+	assert.equal(
+		shutdownHarness.calls.filter((call) => call.args[3] === "session-end").length,
+		1,
+	);
+	assert.ok(
+		!shutdownHarness.statuses.some(({ text }) => text === "spt:omp-agent"),
+		"bind completion after shutdown must not restore live status",
+	);
+	assert.deepEqual(shutdownHarness.clock.delays(), []);
+}
+
+// [unit->REQ-OMP-EXTENSION-CUSTODY]
+// [unit->REQ-OMP-LISTENER-FAIL-CLOSED]
+async function testOutcomeSendRetriesAndExhaustion() {
+	let retryAttempts = 0;
+	const retryHarness = createHarness({
+		outcomeRetryDelaysMs: [5, 10],
+		onRun(call) {
+			if (call.args[0] === "send" && call.args[1] === "retry") {
+				retryAttempts += 1;
+				if (retryAttempts < 3) throw new Error(`outcome failure ${retryAttempts}`);
+			}
+		},
+	});
+	await retryHarness.emit("session_start");
+	retryHarness.children[0].stdout.emit(
+		"data",
+		'<EVENT type="msg" from="retry">work</EVENT>',
+	);
+	await flush();
+	await retryHarness.emit("agent_start");
+	const retryEnding = retryHarness.emit("agent_end", {
+		messages: [
+			{ role: "user", content: '<msg from="retry"/>' },
+			{ role: "assistant", content: "eventual outcome" },
+		],
+	});
+	await flush();
+	assert.equal(commandCalls(retryHarness, "send").length, 1);
+	assert.deepEqual(retryHarness.clock.delays(), [5]);
+	await retryHarness.clock.runNext(5);
+	assert.equal(commandCalls(retryHarness, "send").length, 2);
+	assert.deepEqual(retryHarness.clock.delays(), [10]);
+	await retryHarness.clock.runNext(10);
+	await retryEnding;
+	assert.equal(commandCalls(retryHarness, "send").length, 3);
+	assert.equal(commandCalls(retryHarness, "send").at(-1).input, "eventual outcome");
+	assert.equal(retryHarness.shutdowns, 0);
+	await retryHarness.emit("session_shutdown");
+	assert.deepEqual(retryHarness.clock.delays(), []);
+
+	const exhaustedHarness = createHarness({
+		outcomeRetryDelaysMs: [7],
+		onRun(call) {
+			if (call.args[0] === "send") throw new Error("outcome channel unavailable");
+		},
+	});
+	await exhaustedHarness.emit("session_start");
+	const exhaustedListener = exhaustedHarness.children[0];
+	exhaustedListener.stdout.emit(
+		"data",
+		'<EVENT type="msg" from="exhausted">work</EVENT>',
+	);
+	await flush();
+	await exhaustedHarness.emit("agent_start");
+	const exhaustedEnding = exhaustedHarness.emit("agent_end", {
+		messages: [
+			{ role: "user", content: '<msg from="exhausted"/>' },
+			{ role: "assistant", content: "undeliverable outcome" },
+		],
+	});
+	await flush();
+	assert.equal(commandCalls(exhaustedHarness, "send").length, 1);
+	assert.deepEqual(exhaustedHarness.clock.delays(), [7]);
+	await exhaustedHarness.clock.runNext(7);
+	await exhaustedEnding;
+
+	assert.equal(commandCalls(exhaustedHarness, "send").length, 2);
+	assert.deepEqual(
+		stateCalls(exhaustedHarness).map((call) => call.args[4]),
+		["idle", "busy"],
+		"exhausted custody must never be advertised idle",
+	);
+	assert.equal(exhaustedHarness.shutdowns, 1);
+	assert.equal(exhaustedListener.kills, 1);
+	assert.equal(
+		exhaustedHarness.calls.filter((call) => call.args[3] === "session-end").length,
+		1,
+	);
+	assert.ok(
+		exhaustedHarness.errors.some(({ message }) =>
+			message.includes("could not send the outcome to exhausted"),
+		),
+	);
+	await exhaustedHarness.emit("session_shutdown");
+	assert.deepEqual(exhaustedHarness.clock.delays(), []);
+}
+
+// [unit->REQ-OMP-EXTENSION-CUSTODY]
+async function testSubmissionFailureAdvancesQueue() {
+	const harness = createHarness({
+		onSubmit(content) {
+			if (content === '<msg from="broken"/>') throw new Error("OMP prompt flow rejected input");
+		},
+	});
+	await harness.emit("session_start");
+	harness.children[0].stdout.emit(
+		"data",
+		'<EVENT type="msg" from="broken">one</EVENT><EVENT type="msg" from="next">two</EVENT>',
+	);
+	await flush();
+
+	const firstOutcome = commandCalls(harness, "send");
+	assert.equal(firstOutcome.length, 1);
+	assert.deepEqual(firstOutcome[0].args, ["send", "broken", "--from", "omp-agent"]);
+	assert.match(firstOutcome[0].input, /could not submit your message to OMP/);
+	assert.deepEqual(harness.clock.delays(), [0]);
+
+	await harness.clock.runNext(0);
+	assert.deepEqual(harness.submitted, ['<msg from="broken"/>', '<msg from="next"/>']);
+	await harness.emit("agent_start");
+	await harness.emit("agent_end", {
+		messages: [
+			{ role: "user", content: '<msg from="next"/>' },
+			{ role: "assistant", content: "next reply" },
+		],
+	});
+	const outcomes = commandCalls(harness, "send");
+	assert.equal(outcomes.length, 2);
+	assert.deepEqual(
+		outcomes.map((call) => call.args[1]),
+		["broken", "next"],
+	);
+	assert.equal(outcomes[1].input, "next reply");
+	await harness.emit("session_shutdown");
+	assert.deepEqual(harness.clock.delays(), []);
+}
+
+async function testFailedIdleRecoveryFailsClosed() {
+	let idleCalls = 0;
+	const harness = createHarness({
+		onSubmit() {
+			throw new Error("OMP prompt flow rejected input");
+		},
+		onRun(call) {
+			if (call.args[0] === "api" && call.args[3] === "state" && call.args[4] === "idle") {
+				idleCalls += 1;
+				if (idleCalls === 2) throw new Error("state channel unavailable");
+			}
+		},
+	});
+	await harness.emit("session_start");
+	harness.children[0].stdout.emit("data", '<EVENT type="msg" from="broken">one</EVENT>');
+	await flush();
+
+	assert.equal(commandCalls(harness, "send").length, 1);
+	assert.match(commandCalls(harness, "send")[0].input, /could not submit your message to OMP/);
+	assert.equal(harness.shutdowns, 1);
+	assert.equal(harness.calls.filter((call) => call.args[3] === "session-end").length, 1);
+	assert.ok(
+		harness.errors.some(({ message }) =>
+			message.includes("could not restore idle state after a failed submission"),
+		),
+	);
+	assert.deepEqual(harness.clock.delays(), []);
+}
+
+// [unit->REQ-OMP-LISTENER-FAIL-CLOSED]
+async function testListenerRestartExhaustion() {
+	const harness = createHarness({ restartDelaysMs: [5, 10] });
+	await harness.emit("session_start");
+	const first = harness.children[0];
+	first.emit("close", 7);
+	assert.deepEqual(harness.clock.delays(), [5]);
+
+	await harness.clock.runNext(5);
+	const second = harness.children[1];
+	second.stdout.emit("data", '<EVENT type="msg" from="partial">half');
+	second.emit("error", new Error("listener crashed"));
+	second.emit("close", 8);
+	assert.deepEqual(harness.clock.delays(), [10], "error plus close schedules one restart");
+
+	await harness.clock.runNext(10);
+	const third = harness.children[2];
+	third.emit("close", 9);
+	await flush();
+
+	assert.equal(harness.children.length, 3);
+	assert.equal(harness.shutdowns, 1);
+	assert.ok(
+		harness.errors.some(({ message }) => message.includes("listener restart budget exhausted")),
+	);
+	assert.ok(
+		harness.notifications.some(({ message, type }) =>
+			type === "error" && message.includes("listener restart budget exhausted"),
+		),
+	);
+	assert.equal(harness.calls.filter((call) => call.args[3] === "session-end").length, 1);
+	assert.deepEqual(harness.clock.delays(), []);
+
+	await harness.emit("session_shutdown");
+	assert.equal(
+		harness.calls.filter((call) => call.args[3] === "session-end").length,
+		1,
+		"fatal shutdown and lifecycle shutdown share one teardown",
+	);
+}
+
+async function testListenerStableIntervalResetsRetries() {
+	const harness = createHarness({
+		listenerStableMs: 20,
+		restartDelaysMs: [5, 10],
+	});
+	await harness.emit("session_start");
+	await harness.emit("agent_start");
+	assert.deepEqual(harness.clock.delays(), [20]);
+
+	harness.children[0].emit("close", 1);
+	assert.deepEqual(harness.clock.delays(), [5]);
+	await harness.clock.runNext(5);
+
+	const shortLived = harness.children[1];
+	shortLived.stdout.emit(
+		"data",
+		'<EVENT type="msg" from="proof">a parsed event is not stability</EVENT>',
+	);
+	shortLived.emit("close", 2);
+	assert.deepEqual(
+		harness.clock.delays(),
+		[10],
+		"a parsed event followed by an immediate crash remains in the consecutive crash loop",
+	);
+	await harness.clock.runNext(10);
+
+	const stable = harness.children[2];
+	assert.deepEqual(harness.clock.delays(), [20]);
+	await harness.clock.runNext(20);
+	stable.emit("close", 3);
+	assert.deepEqual(
+		harness.clock.delays(),
+		[5],
+		"a listener surviving the stable interval resets the next retry to attempt one",
+	);
+	assert.match(
+		harness.notifications.filter(({ type }) => type === "warning").at(-1).message,
+		/restarting 1\/2 in 5ms/,
+	);
+
+	await harness.clock.runNext(5);
+	assert.equal(harness.children.length, 4);
+	await harness.emit("session_shutdown");
+	assert.deepEqual(harness.clock.delays(), []);
+}
+
+// [unit->REQ-OMP-EXTENSION-CUSTODY]
+// [unit->REQ-OMP-LISTENER-FAIL-CLOSED]
+async function testFatalTeardownAwaitsInFlightOutcome() {
+	let releaseOutcome;
+	const outcomeGate = new Promise((resolve) => {
+		releaseOutcome = resolve;
+	});
+	const harness = createHarness({
+		restartDelaysMs: [],
+		onRun(call) {
+			if (call.args[0] === "send" && call.args[1] === "slow") return outcomeGate;
+		},
+	});
+	await harness.emit("session_start");
+	harness.children[0].stdout.emit("data", '<EVENT type="msg" from="slow">work</EVENT>');
+	await flush();
+	await harness.emit("agent_start");
+	const ending = harness.emit("agent_end", {
+		messages: [
+			{ role: "user", content: '<msg from="slow"/>' },
+			{ role: "assistant", content: "finished" },
+		],
+	});
+	await flush();
+	assert.equal(commandCalls(harness, "send").length, 1);
+
+	harness.children[0].emit("close", 11);
+	await flush();
+	assert.equal(harness.shutdowns, 0, "fatal teardown must join the sender outcome");
+	assert.equal(harness.calls.filter((call) => call.args[3] === "session-end").length, 0);
+
+	const shutdown = harness.emit("session_shutdown");
+	await flush();
+	assert.equal(
+		harness.calls.filter((call) => call.args[3] === "session-end").length,
+		0,
+		"concurrent lifecycle shutdown must join fatal custody teardown",
+	);
+	for (const reason of ["new", "resume", "fork", "handoff"]) {
+		assert.deepEqual(
+			await harness.emit("session_before_switch", { reason }),
+			{ cancel: true },
+			`teardown must keep blocking the ${reason} switch while custody is pending`,
+		);
+	}
+	assert.deepEqual(
+		await harness.emit("session_before_branch"),
+		{ cancel: true },
+		"teardown must keep blocking branches while custody is pending",
+	);
+
+	releaseOutcome();
+	await Promise.all([ending, shutdown]);
+	await flush();
+	assert.equal(harness.shutdowns, 1);
+	assert.equal(harness.calls.filter((call) => call.args[3] === "session-end").length, 1);
+	assert.deepEqual(harness.clock.delays(), []);
+}
+
+async function testSessionEndRetriesAfterTransientFailure() {
+	const firstEnd = deferred();
+	let endAttempts = 0;
+	const harness = createHarness({
+		restartDelaysMs: [],
+		sessionEndRetryDelaysMs: [5],
+		onRun(call) {
+			if (call.args[0] === "api" && call.args[3] === "session-end") {
+				endAttempts += 1;
+				if (endAttempts === 1) return firstEnd.promise;
+			}
+		},
+	});
+	await harness.emit("session_start");
+	harness.children[0].emit("close", 12);
+	await flush();
+	assert.equal(
+		harness.calls.filter((call) => call.args[3] === "session-end").length,
+		1,
+	);
+
+	const shutdown = harness.emit("session_shutdown");
+	await flush();
+	firstEnd.reject(new Error("transient teardown failure"));
+	await flush();
+	assert.equal(harness.shutdowns, 0, "fatal close must wait for the bounded teardown retry");
+	assert.deepEqual(harness.clock.delays(), [5]);
+	assert.ok(
+		harness.errors.some(
+			({ message, details }) =>
+				message.includes("session teardown failed; retrying") &&
+				details.error.includes("transient teardown failure"),
+		),
+	);
+
+	await harness.clock.runNext(5);
+	await shutdown;
+	await flush();
+	assert.equal(
+		harness.calls.filter((call) => call.args[3] === "session-end").length,
+		2,
+		"concurrent fatal and lifecycle teardown must share the successful retry",
+	);
+	assert.equal(harness.shutdowns, 1);
+	assert.deepEqual(harness.clock.delays(), []);
+}
+
+async function testHumanBusyFailureFailsClosed() {
+	const harness = createHarness({
+		onRun(call) {
+			if (call.args[0] === "api" && call.args[3] === "state" && call.args[4] === "busy") {
+				throw new Error("state channel unavailable");
+			}
+		},
+	});
+	await harness.emit("session_start");
+	await harness.emit("agent_start");
+
+	assert.equal(harness.shutdowns, 1);
+	assert.equal(harness.calls.filter((call) => call.args[3] === "session-end").length, 1);
+	assert.ok(
+		harness.errors.some(({ message }) => message.includes("could not mark the endpoint busy")),
+	);
+	assert.equal(harness.children[0].kills, 1);
+	assert.deepEqual(harness.clock.delays(), []);
+}
+
+// [unit->REQ-OMP-EXTENSION-CUSTODY]
+// [unit->REQ-OMP-LISTENER-FAIL-CLOSED]
+async function testShutdownReapsAndFailsQueuedCustody() {
+	const harness = createHarness();
+	await harness.emit("session_start");
+	const listener = harness.children[0];
+	listener.stdout.emit(
+		"data",
+		'<EVENT type="msg" from="first">one</EVENT><EVENT type="msg" from="queued">two</EVENT>',
+	);
+	await flush();
+	await harness.emit("agent_start");
+	await harness.emit("agent_end", {
+		messages: [
+			{ role: "user", content: '<msg from="first"/>' },
+			{ role: "assistant", content: "done" },
+		],
+	});
+	assert.deepEqual(harness.clock.delays(), [0]);
+
+	await harness.emit("session_shutdown");
+	assert.equal(listener.kills, 1);
+	assert.deepEqual(harness.clock.delays(), []);
+	assert.deepEqual(
+		commandCalls(harness, "send").map((call) => call.args[1]),
+		["first", "queued"],
+	);
+	assert.match(commandCalls(harness, "send")[1].input, /OMP session shut down/);
+	assert.equal(harness.calls.filter((call) => call.args[3] === "session-end").length, 1);
+	assert.deepEqual(harness.statuses.at(-1), { key: "omp-spt", text: undefined });
+	assert.equal(harness.shutdowns, 0, "normal lifecycle shutdown must not recursively shut down OMP");
+}
+
+await testParsingAndReplies();
+await testLifecycleCustodyAndContext();
+await testDeferredBindLifecycleSerialization();
+await testOutcomeSendRetriesAndExhaustion();
+await testSubmissionFailureAdvancesQueue();
+await testFailedIdleRecoveryFailsClosed();
+await testListenerRestartExhaustion();
+await testListenerStableIntervalResetsRetries();
+await testFatalTeardownAwaitsInFlightOutcome();
+await testSessionEndRetriesAfterTransientFailure();
+await testHumanBusyFailureFailsClosed();
+await testShutdownReapsAndFailsQueuedCustody();
 
 console.log("OMP-EXTENSION OK");
diff --git a/tests/skeleton-validate.sh b/tests/skeleton-validate.sh
deleted file mode 100644
index 0b3a6f3..0000000
--- a/tests/skeleton-validate.sh
+++ /dev/null
@@ -1,48 +0,0 @@
-#!/bin/sh
-# Unit tests for the cplugs skeleton validator: it must PASS the real skeleton and FAIL on tampered
-# copies (leaked runtime state / planted binary / missing SKILL.md) — proving the gate catches
-# real breakage, not just green-on-green. Run: sh tests/skeleton-validate.sh  (exit 0 = pass).
-# [unit->REQ-DIST-PLUGIN-SKELETON]
-ROOT=$(CDPATH= cd "$(dirname "$0")/.." && pwd)
-VALIDATE="$ROOT/ci/publish/validate-skeleton.sh"
-fail=0
-
-# 1. Real skeleton is installable.
-if sh "$VALIDATE" "$ROOT/plugin/omps" >/dev/null 2>&1; then echo "ok   real skeleton validates"; else echo "FAIL real skeleton rejected"; sh "$VALIDATE" "$ROOT/plugin/omps"; fail=1; fi
-
-# Build a clean fixture copy we can tamper.
-work=$(mktemp -d) || { echo "FAIL mktemp"; exit 1; }
-trap 'rm -rf "$work"' EXIT INT TERM
-sk="$work/omps"
-mkdir -p "$sk"
-cp -r "$ROOT/plugin/omps/.claude-plugin" "$sk/"
-cp -r "$ROOT/plugin/omps/hooks" "$sk/"
-cp -r "$ROOT/plugin/omps/skills" "$sk/"
-cp "$ROOT/plugin/omps/bootstrap.sh" "$sk/" 2>/dev/null || true
-
-# Sanity: the clean copy validates (else later negatives are meaningless).
-if sh "$VALIDATE" "$sk" >/dev/null 2>&1; then echo "ok   clean fixture validates"; else echo "FAIL clean fixture rejected"; fail=1; fi
-
-# 2. Runtime state leaked INTO a published path (hooks/) must FAIL — this is the real publish leak
-#    (state inside the subset that package-skeleton.sh would copy to the marketplace). State in a
-#    non-published dir like `.claude/` is intentionally NOT a finding: the packager never copies it.
-printf '{"last_used":"perri"}\n' > "$sk/hooks/LIVE_AGENT_IDS.json"
-if sh "$VALIDATE" "$sk" >/dev/null 2>&1; then echo "FAIL leaked LIVE_AGENT_IDS.json not caught"; fail=1; else echo "ok   catches runtime state in published path"; fi
-rm -f "$sk/hooks/LIVE_AGENT_IDS.json"
-
-# 3. Planted binary must FAIL.
-printf 'MZ\0' > "$sk/skills/rogue.exe"
-if sh "$VALIDATE" "$sk" >/dev/null 2>&1; then echo "FAIL planted .exe not caught"; fail=1; else echo "ok   catches planted binary"; fi
-rm -f "$sk/skills/rogue.exe"
-
-# 4. Missing SKILL.md must FAIL.
-victim=$(find "$sk/skills" -name SKILL.md | head -n1)
-mv "$victim" "$victim.bak"
-if sh "$VALIDATE" "$sk" >/dev/null 2>&1; then echo "FAIL missing SKILL.md not caught"; fail=1; else echo "ok   catches missing SKILL.md"; fi
-mv "$victim.bak" "$victim"
-
-# 5. Wrong plugin name must FAIL.
-sed 's/"name": "omps"/"name": "wrong"/' "$sk/.claude-plugin/plugin.json" > "$sk/.claude-plugin/plugin.json.tmp" && mv "$sk/.claude-plugin/plugin.json.tmp" "$sk/.claude-plugin/plugin.json"
-if sh "$VALIDATE" "$sk" >/dev/null 2>&1; then echo "FAIL wrong plugin name not caught"; fail=1; else echo "ok   catches wrong plugin name"; fi
-
-[ "$fail" -eq 0 ] && { echo "SKELETON-VALIDATE OK"; exit 0; } || { echo "SKELETON-VALIDATE FAIL"; exit 1; }
diff --git a/tools/claude-spt/Cargo.lock b/tools/claude-spt/Cargo.lock
deleted file mode 100644
index 3e7cab6..0000000
--- a/tools/claude-spt/Cargo.lock
+++ /dev/null
@@ -1,105 +0,0 @@
-# This file is automatically @generated by Cargo.
-# It is not intended for manual editing.
-version = 4
-
-[[package]]
-name = "claude-spt"
-version = "0.1.3"
-dependencies = [
- "serde_json",
-]
-
-[[package]]
-name = "itoa"
-version = "1.0.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
-
-[[package]]
-name = "memchr"
-version = "2.8.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "88904434abc2901f197fe8cc55f0445e7ded921dba5911dad2e2b39b48e663c4"
-
-[[package]]
-name = "proc-macro2"
-version = "1.0.106"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
-dependencies = [
- "unicode-ident",
-]
-
-[[package]]
-name = "quote"
-version = "1.0.46"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dfbc457d0c7a0759a614551b11a6409e5951f6c7537be1f1b7682b9ae9230368"
-dependencies = [
- "proc-macro2",
-]
-
-[[package]]
-name = "serde"
-version = "1.0.228"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
-dependencies = [
- "serde_core",
-]
-
-[[package]]
-name = "serde_core"
-version = "1.0.228"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
-dependencies = [
- "serde_derive",
-]
-
-[[package]]
-name = "serde_derive"
-version = "1.0.228"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "serde_json"
-version = "1.0.150"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e8014e44b4736ed0538adeecded0fce2a272f22dc9578a7eb6b2d9993c74cfb9"
-dependencies = [
- "itoa",
- "memchr",
- "serde",
- "serde_core",
- "zmij",
-]
-
-[[package]]
-name = "syn"
-version = "2.0.118"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b9ae57f904213ebb649ce6895b8a66c66f0203b9319718f69a5612a065b1422"
-dependencies = [
- "proc-macro2",
- "quote",
- "unicode-ident",
-]
-
-[[package]]
-name = "unicode-ident"
-version = "1.0.24"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
-
-[[package]]
-name = "zmij"
-version = "1.0.21"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa"
diff --git a/tools/claude-spt/Cargo.toml b/tools/claude-spt/Cargo.toml
deleted file mode 100644
index 3260060..0000000
--- a/tools/claude-spt/Cargo.toml
+++ /dev/null
@@ -1,33 +0,0 @@
-# claude-spt — the consolidated tool binary for the claude-spt adapter (ADR-0006, U2).
-# Merges the former claude-spt-digest + claude-spt-psyche crates into ONE binary with subcommands
-# (`claude-spt digest` / `claude-spt psyche` / `claude-spt post-update`), so the fat adapter.spt
-# carries fewer artifacts per triple and the seams share one dep tree. Rust for the same reasons as
-# its predecessors: a compiled, dependency-light binary the spt-core daemon can spawn BARE on
-# Win+Linux with no interpreter-on-PATH or locale-encoding hazard (stdout is always UTF-8).
-#
-# Subcommand dispatch is hand-rolled (a bare argv[1] match), NOT clap: both predecessor crates were
-# deliberately dependency-light (psyche was std-only; digest carried serde_json alone), and a flat
-# three-way dispatch needs no arg-parsing framework. Each subcommand keeps its own hand-written flag
-# parser (verbatim from its origin crate). [impl->REQ-DIST-BINARY-CONSOLIDATE]
-#
-# Builds via ci/digest/build.sh + ci/psyche/build.sh (both now build THIS crate), gated in
-# ci/run-gates.sh; packed into adapter.spt by ci/publish/package-adapter.sh.
-[package]
-name = "claude-spt"
-version = "0.1.3"
-edition = "2021"
-publish = false
-
-[[bin]]
-# HIGH-1 (docs/OMP-BRIDGE-FIELD-ISSUES.md): the SHIPPED BINARY is `omp-spt` — a distinct basename
-# from upstream claude-spt, so the bridge process is self-identifying in a task list (the field
-# incident's misdiagnosis was a bridge indistinguishable from a real claude-spt). The crate/package
-# keeps the claude-spt name (dir layout + CI scripts unchanged).
-name = "omp-spt"
-path = "src/main.rs"
-
-[dependencies]
-serde_json = "1"
-
-[profile.release]
-strip = true
diff --git a/tools/claude-spt/examples/fake-omp.rs b/tools/claude-spt/examples/fake-omp.rs
deleted file mode 100644
index 9ac0730..0000000
--- a/tools/claude-spt/examples/fake-omp.rs
+++ /dev/null
@@ -1,74 +0,0 @@
-//! fake-omp — a deterministic, model-free stand-in for `omp --mode rpc`, for the omp-spt bridge
-//! acceptance test (tests/bridge-acceptance.sh). A compiled Cargo EXAMPLE (never shipped in the
-//! release adapter.spt), so it is a real cross-platform executable the bridge can spawn via
-//! `Command::new` — unlike a shell script, which Windows cannot exec directly.
-//!
-//! It ignores all argv (the bridge appends `--mode rpc [--session-dir …]`) and speaks just enough of
-//! the verified RPC protocol (OMP-ADAPTER-PLAN.md, confirmed against omp v16.3.11) for the bridge to
-//! complete a full ready → get_state → prompt → agent_end cycle with zero model billing:
-//!
-//!   • on start                : `{"type":"ready"}`
-//!   • on `{"type":"get_state"}`: `{"type":"response","command":"get_state","success":true,
-//!                                  "data":{"sessionId":"<FAKE_OMP_SID>","sessionFile":"…"}}`
-//!   • on `{"type":"prompt",…}` : the prompt ack, `agent_start`, then `agent_end` with a canned
-//!                                assistant reply — AND appends the raw inbound frame to $FAKE_OMP_LOG
-//!                                (the deterministic side-effect the acceptance test asserts on).
-//!
-//! Env knobs: FAKE_OMP_SID (session id, default `fake-sess-0001`), FAKE_OMP_LOG (prompt-log path,
-//! default none), FAKE_OMP_REPLY (canned reply text, default `FAKE_OMP_REPLY: pong`), and
-//! FAKE_OMP_MUTE=1 (ack + agent_start but NEVER send agent_end — the hung-turn shape that
-//! exercises the bridge's per-turn deadline, HIGH-4). stdout is flushed after every frame so the
-//! bridge's line reader never stalls behind a full pipe buffer.
-
-use std::io::{BufRead, Write};
-
-fn main() {
-    let sid = std::env::var("FAKE_OMP_SID").unwrap_or_else(|_| "fake-sess-0001".to_string());
-    let log = std::env::var("FAKE_OMP_LOG").ok().filter(|s| !s.is_empty());
-    let reply = std::env::var("FAKE_OMP_REPLY").unwrap_or_else(|_| "FAKE_OMP_REPLY: pong".to_string());
-    let mute = std::env::var("FAKE_OMP_MUTE").map(|v| v == "1").unwrap_or(false);
-
-    let stdout = std::io::stdout();
-    let mut out = stdout.lock();
-    let emit = |out: &mut std::io::StdoutLock, line: &str| {
-        let _ = writeln!(out, "{line}");
-        let _ = out.flush();
-    };
-
-    emit(&mut out, r#"{"type":"ready"}"#);
-
-    let stdin = std::io::stdin();
-    for line in stdin.lock().lines() {
-        let line = match line {
-            Ok(l) => l,
-            Err(_) => break,
-        };
-        if line.contains("\"get_state\"") {
-            emit(
-                &mut out,
-                &format!(
-                    r#"{{"type":"response","command":"get_state","success":true,"data":{{"sessionId":"{sid}","sessionFile":"/tmp/{sid}.jsonl"}}}}"#
-                ),
-            );
-        } else if line.contains("\"prompt\"") {
-            if let Some(path) = &log {
-                if let Ok(mut f) = std::fs::OpenOptions::new().create(true).append(true).open(path) {
-                    let _ = writeln!(f, "{line}");
-                }
-            }
-            emit(&mut out, r#"{"type":"response","command":"prompt","success":true}"#);
-            emit(&mut out, r#"{"type":"agent_start"}"#);
-            if mute {
-                continue; // FAKE_OMP_MUTE: hang the turn — no agent_end ever (deadline exercise)
-            }
-            // Escape the reply for embedding in the JSON string (quotes + backslashes).
-            let esc = reply.replace('\\', "\\\\").replace('"', "\\\"");
-            emit(
-                &mut out,
-                &format!(
-                    r#"{{"type":"agent_end","messages":[{{"role":"assistant","content":[{{"type":"text","text":"{esc}"}}]}}]}}"#
-                ),
-            );
-        }
-    }
-}
diff --git a/tools/claude-spt/src/bridge.rs b/tools/claude-spt/src/bridge.rs
deleted file mode 100644
index 8b1fff0..0000000
--- a/tools/claude-spt/src/bridge.rs
+++ /dev/null
@@ -1,1016 +0,0 @@
-//! The omp-spt RPC bridge (S2 ready-agent; hardened at v0.1.1 per docs/OMP-BRIDGE-FIELD-ISSUES.md).
-//!
-//! This is the hosted harness process for the oh-my-pi (omp) adapter: spt-core's broker spawns it as
-//! `[session.self].command`, and it drives a resident `omp --mode rpc` child, translating in both
-//! directions (OMP-ADAPTER-PLAN.md, "Architecture decision: RPC-bridge (Style A)"):
-//!
-//! ```text
-//! spt daemon ──spawn──▶ omp-spt ──stdio NDJSON──▶ omp --mode rpc
-//!                          │  spt api bind/state/session-end, spt ready, spt send   (to spt-core)
-//!                          └  prompt / get_state                                    (to omp)
-//! ```
-//!
-//! Shipped as the `omp-spt` binary (HIGH-1: a distinct basename — the process is self-identifying
-//! in a task list, never confusable with a genuine claude-spt). `claude-spt bridge` remains as a
-//! compat alias for the same entry.
-//!
-//! ## Protocol (verified against omp v16.3.11 — see OMP-ADAPTER-PLAN.md §"decisive finding")
-//!
-//! Startup:   omp → `{"type":"ready"}` (then unsolicited `extension_ui_request` /
-//!            `available_commands_update`, which `--mode rpc` — unlike `rpc-ui` — does NOT block on).
-//! Introspect: host → `{"type":"get_state"}`; omp → `{"type":"response","command":"get_state",
-//!            "success":true,"data":{"sessionId":"<uuid>","sessionFile":"…","model":…}}`.
-//! Drive turn: host → `{"type":"prompt","message":"…"}`; omp acks `{"type":"response",
-//!            "command":"prompt","success":true}`, then streams `turn_start` → `agent_start` →
-//!            `message_update`… → `turn_end` → `{"type":"agent_end","messages":[…]}`.
-//!
-//! ## Hardening (the doyle 2026-07-09 field incident — docs/OMP-BRIDGE-FIELD-ISSUES.md)
-//!
-//! * **HIGH-2 teardown**: at startup the bridge assigns ITSELF to a Windows Job Object with
-//!   kill-on-close, so its children (omp + `spt ready`) inherit membership and die with the bridge
-//!   no matter HOW the bridge dies (broker kill, crash, taskkill without /T). Explicit `kill()`s on
-//!   the graceful path remain. A dying bridge also best-effort soft-tears the perch
-//!   (`spt api session-end`) so a dead endpoint never keeps advertising as listening.
-//! * **HIGH-3 visibility**: an ALWAYS-ON operational log rides stderr (the broker PTY): resolved
-//!   binary paths, bind/listen breadcrumbs, one line per message in / reply out, every spt/omp
-//!   failure, child exits, and a periodic heartbeat — a working, idle, and wedged bridge all look
-//!   different now. `OMP_SPT_DEBUG` still gates the frame-level trace.
-//! * **HIGH-4 deadlines**: omp stdout and the `spt ready` stream are read by dedicated threads into
-//!   ONE event channel; every wait is bounded (`ready`/`get_state` at bringup, per-turn while
-//!   driving). A bringup breach exits loud BEFORE bind (no ledger poisoning — MED-4's no-bind-
-//!   before-handshake); a turn breach recovers the perch to idle and tells the sender.
-//! * **MED-2**: the event loop notices a dead omp/listener child immediately (reader-thread EOF),
-//!   even while idle — not on the next message.
-//! * **LOW-1/2**: spt bind/state/send failures land on the operational log, and a failed turn sends
-//!   the sender an explicit failure notice, never a silent empty reply.
-
-use serde_json::{json, Value};
-use std::io::{BufRead, BufReader, Write};
-use std::process::{ChildStdin, Command, ExitCode, Stdio};
-use std::sync::mpsc::{Receiver, RecvTimeoutError, Sender};
-use std::time::{Duration, Instant};
-
-/// The adapter_name every targeted `spt api` verb carries (`--adapter`). Distinct from the plugin
-/// namespace `omps`; mirrors hook.rs's `ADAPTER` for the claude-spt path.
-const ADAPTER: &str = "omp-spt";
-
-/// Bringup deadline for omp's `ready` frame (override: OMP_SPT_READY_TIMEOUT_S). Generous — a cold
-/// omp start loads providers/extensions; but bounded, so a wrong binary (the OneCLI gateway alias,
-/// MED-3) or an auth prompt fails LOUD instead of wedging forever.
-const DEFAULT_READY_TIMEOUT_S: u64 = 120;
-/// `get_state` response deadline at bringup (same env-knob family: OMP_SPT_STATE_TIMEOUT_S).
-const DEFAULT_STATE_TIMEOUT_S: u64 = 30;
-/// Per-turn deadline: prompt dispatch → `agent_end` (override: OMP_SPT_TURN_TIMEOUT_S). Long — a
-/// real agent turn can run tools for minutes — but bounded, so a hung turn frees the perch.
-const DEFAULT_TURN_TIMEOUT_S: u64 = 600;
-/// Idle heartbeat cadence on the operational log (override: OMP_SPT_HEARTBEAT_S; 0 disables).
-const DEFAULT_HEARTBEAT_S: u64 = 300;
-
-/// ALWAYS-ON operational log (HIGH-3). Rides stderr = the broker PTY, so an attached operator sees
-/// message/reply/error/heartbeat lines without any env flag.
-macro_rules! oplog {
-    ($($a:tt)*) => {
-        eprintln!("[omp-spt] {}", format!($($a)*))
-    };
-}
-
-/// Frame-level trace, still gated behind `OMP_SPT_DEBUG` (diagnostics; off by default).
-macro_rules! trace {
-    ($($a:tt)*) => {
-        if std::env::var_os("OMP_SPT_DEBUG").is_some() {
-            eprintln!("[omp-spt::trace] {}", format!($($a)*));
-        }
-    };
-}
-
-fn env_secs(name: &str, default: u64) -> u64 {
-    std::env::var(name).ok().and_then(|s| s.parse().ok()).unwrap_or(default)
-}
-
-/// Parsed bridge argv. `omp_args` is everything after a `--` separator, forwarded to omp verbatim.
-struct Args {
-    id: Option<String>,
-    subnet: Option<String>,
-    session_dir: Option<String>,
-    resume: Option<String>,
-    omp_args: Vec<String>,
-}
-
-fn parse_args<I: Iterator<Item = String>>(mut it: I) -> Args {
-    let mut a = Args {
-        id: None,
-        subnet: None,
-        session_dir: None,
-        resume: None,
-        omp_args: Vec::new(),
-    };
-    while let Some(arg) = it.next() {
-        match arg.as_str() {
-            "--id" => a.id = it.next(),
-            "--subnet" => a.subnet = it.next(),
-            "--session-dir" => a.session_dir = it.next(),
-            "--resume" => a.resume = it.next(),
-            "--node" => {
-                let _ = it.next(); // accepted for manifest {node} parity; the bridge does not use it
-            }
-            "--" => {
-                a.omp_args.extend(it.by_ref());
-                break;
-            }
-            other => oplog!("ignoring unrecognized flag: {other}"),
-        }
-    }
-    // Home subnet: required by `spt ready`/`bind` for a NEW endpoint on a multi-subnet node;
-    // harmless otherwise. Broker-hosted perches are pre-homed so the broker path can omit it.
-    if a.subnet.is_none() {
-        a.subnet = std::env::var("OMP_SPT_SUBNET").ok().filter(|s| !s.is_empty());
-    }
-    a
-}
-
-/// Entry for `claude-spt bridge …` (compat alias — argv starts after the subcommand token).
-pub fn run() -> ExitCode {
-    run_argv(std::env::args().skip(2))
-}
-
-/// Entry for the `omp-spt` binary (HIGH-1 — argv starts right after the binary name).
-pub fn run_argv<I: Iterator<Item = String>>(argv: I) -> ExitCode {
-    let args = parse_args(argv);
-
-    // Endpoint id: --id wins, else the broker-injected $SPT_ENDPOINT_ID ([env.SPT_ENDPOINT_ID],
-    // direction="inject", value="{id}"). Without it we cannot address the perch — fail loud.
-    let id = args
-        .id
-        .clone()
-        .or_else(|| std::env::var("SPT_ENDPOINT_ID").ok())
-        .filter(|s| !s.is_empty());
-    let id = match id {
-        Some(id) => id,
-        None => {
-            oplog!("FATAL: no endpoint id (pass --id or set SPT_ENDPOINT_ID)");
-            return ExitCode::from(2);
-        }
-    };
-
-    // HIGH-2: put OURSELVES in a kill-on-close job object BEFORE spawning any child, so both
-    // children inherit membership and the OS reaps the whole tree when the bridge dies — however it
-    // dies. Best-effort: a failure is logged, never fatal (explicit kills still cover the graceful
-    // path). The returned handle is deliberately held (leaked) for the process lifetime; the OS
-    // closes it at process exit, which is exactly the kill trigger.
-    match teardown::arm_kill_on_close() {
-        Ok(()) => trace!("job-object armed (children die with the bridge)"),
-        Err(e) => oplog!("WARN: could not arm child teardown ({e}) — orphan risk on hard kill"),
-    }
-
-    let spt = spt_bin();
-    let omp = omp_bin();
-    oplog!("bridge starting: id={id} omp={omp} spt={spt}");
-
-    // Spawn the resident omp RPC child. stderr is inherited so omp's own diagnostics (auth, model)
-    // surface in the broker PTY; stdin/stdout carry the NDJSON protocol.
-    let mut cmd = Command::new(&omp);
-    cmd.arg("--mode").arg("rpc");
-    // [session.resume]: reload a prior omp session by id — omp's native resume (`-r <id-prefix>`).
-    // get_state after startup still reports the (resumed) sessionId, so the bind path is identical.
-    if let Some(sid) = &args.resume {
-        cmd.arg("-r").arg(sid);
-    }
-    if let Some(dir) = &args.session_dir {
-        cmd.arg("--session-dir").arg(dir);
-    }
-    cmd.args(&args.omp_args);
-    cmd.stdin(Stdio::piped()).stdout(Stdio::piped()).stderr(Stdio::inherit());
-    let mut omp_child = match cmd.spawn() {
-        Ok(c) => c,
-        Err(e) => {
-            oplog!("FATAL: failed to spawn omp ({omp}): {e}");
-            return ExitCode::FAILURE;
-        }
-    };
-    let mut omp_stdin = match omp_child.stdin.take() {
-        Some(s) => s,
-        None => {
-            oplog!("FATAL: omp child missing stdin handle");
-            let _ = omp_child.kill();
-            return ExitCode::FAILURE;
-        }
-    };
-
-    // HIGH-4/MED-2: one event channel, fed by dedicated reader threads — every wait below is a
-    // bounded recv, and a child dying is an Event even while the bridge is idle.
-    let (tx, rx) = std::sync::mpsc::channel::<Event>();
-    spawn_line_reader(omp_child.stdout.take(), tx.clone(), Event::OmpLine, Event::OmpEof);
-
-    // Startup gate: omp's `ready` frame within the deadline. Breaching exits loud BEFORE any bind,
-    // so a failed bringup never poisons the endpoint's session ledger (MED-4 discipline).
-    let ready_deadline = Duration::from_secs(env_secs("OMP_SPT_READY_TIMEOUT_S", DEFAULT_READY_TIMEOUT_S));
-    match await_frame(&rx, ready_deadline, |f| (f["type"].as_str() == Some("ready")).then_some(())) {
-        Ok(()) => oplog!("omp ready"),
-        Err(e) => {
-            oplog!("FATAL: omp never became ready within {}s ({e}) — is {omp} really oh-my-pi? (set OMP_SPT_OMP_BIN)", ready_deadline.as_secs());
-            let _ = omp_child.kill();
-            return ExitCode::FAILURE;
-        }
-    }
-
-    // Identity binding: omp mints the session id, we read it and attach it to the perch. omp has no
-    // "inject an endpoint id" flag, so the id flows the other way — this bind is how the perch
-    // learns which omp session backs it, and it returns the capability TOKEN (`BOUND:<id>
-    // token=<hex>`) that authenticates later mutating calls.
-    if !send_frame(&mut omp_stdin, &json!({"type": "get_state"})) {
-        oplog!("FATAL: could not write get_state to omp");
-        let _ = omp_child.kill();
-        return ExitCode::FAILURE;
-    }
-    let state_deadline = Duration::from_secs(env_secs("OMP_SPT_STATE_TIMEOUT_S", DEFAULT_STATE_TIMEOUT_S));
-    let sid = match await_frame(&rx, state_deadline, |f| {
-        (f["type"].as_str() == Some("response") && f["command"].as_str() == Some("get_state"))
-            .then(|| f["data"]["sessionId"].as_str().map(str::to_string))
-            .flatten()
-    }) {
-        Ok(s) => s,
-        Err(e) => {
-            oplog!("FATAL: no get_state response within {}s ({e})", state_deadline.as_secs());
-            let _ = omp_child.kill();
-            return ExitCode::FAILURE;
-        }
-    };
-
-    let mut bind_args = vec!["api", "--adapter", ADAPTER, "bind", &id, "--set-session-id", &sid];
-    if let Some(sub) = &args.subnet {
-        bind_args.push("--subnet");
-        bind_args.push(sub);
-    }
-    let bind_out = spt_call(&spt, &bind_args, None).unwrap_or_default();
-    let token = parse_bound_token(&bind_out);
-    if token.is_none() {
-        // Broker-hosted revive may not re-mint a token; state calls then fall back to --session-id.
-        oplog!("bind returned no token ({}) — state auth falls back to session id", first_line(&bind_out));
-    }
-    oplog!("bound: id={id} omp-session={sid}");
-    set_state(&spt, &id, &sid, token.as_deref(), "idle");
-
-    // ── Receive relay ────────────────────────────────────────────────────────────────────────────
-    // `spt ready <id>` registers the perch as a listener and BLOCKS, printing one
-    // `<EVENT type="msg" from="…">body</EVENT>` line per delivery (verified live). Its stdout feeds
-    // the same event channel; stderr is inherited so its `READY:<id>` banner reaches the PTY.
-    let mut ready_cmd = Command::new(&spt);
-    ready_cmd.arg("ready").arg(&id);
-    if let Some(sub) = &args.subnet {
-        ready_cmd.arg("--subnet").arg(sub);
-    }
-    ready_cmd.stdout(Stdio::piped()).stderr(Stdio::inherit()).stdin(Stdio::null());
-    let mut ready_child = match ready_cmd.spawn() {
-        Ok(c) => c,
-        Err(e) => {
-            oplog!("FATAL: failed to spawn `spt ready`: {e}");
-            let _ = omp_child.kill();
-            return ExitCode::FAILURE;
-        }
-    };
-    spawn_line_reader(ready_child.stdout.take(), tx.clone(), Event::ReadyLine, Event::ReadyEof);
-    oplog!("listening: relay is `spt ready {id}` (messages will log here as they arrive)");
-
-    // ── Event loop ───────────────────────────────────────────────────────────────────────────────
-    let turn_deadline = Duration::from_secs(env_secs("OMP_SPT_TURN_TIMEOUT_S", DEFAULT_TURN_TIMEOUT_S));
-    let heartbeat_s = env_secs("OMP_SPT_HEARTBEAT_S", DEFAULT_HEARTBEAT_S);
-    let heartbeat = Duration::from_secs(if heartbeat_s == 0 { 3600 } else { heartbeat_s });
-    let started = Instant::now();
-    let mut turns: u64 = 0;
-    let mut stale_turns: u32 = 0; // timed-out turns whose late agent_end should be discarded
-    let mut pending: std::collections::VecDeque<String> = std::collections::VecDeque::new();
-    let exit_reason: String;
-
-    'main: loop {
-        // Deliveries queued behind a long turn are served before blocking on the channel again.
-        let event = if let Some(line) = pending.pop_front() {
-            Ok(Event::ReadyLine(line))
-        } else {
-            rx.recv_timeout(heartbeat)
-        };
-        match event {
-            Ok(Event::ReadyLine(line)) => {
-                for (from, body) in parse_events(&line) {
-                    let sender = from.as_deref().unwrap_or("<unknown>");
-                    oplog!("msg in: from={sender} bytes={}", body.len());
-                    // Busy for the whole handling window (pickup → agent_end) so a concurrent
-                    // status read never sees an idle perch mid-turn.
-                    set_state(&spt, &id, &sid, token.as_deref(), "busy");
-                    let turn = drive_turn(&mut omp_stdin, &rx, turn_deadline, &body, &mut pending, &mut stale_turns);
-                    set_state(&spt, &id, &sid, token.as_deref(), "idle");
-                    turns += 1;
-                    let mut omp_gone = false;
-                    match (&from, turn) {
-                        (Some(target), Ok(reply)) if !target.is_empty() => {
-                            let status = spt_call(&spt, &["send", target, "--from", &id], Some(&reply))
-                                .unwrap_or_else(|| "SEND_SPAWN_FAIL".into());
-                            oplog!("reply out: to={target} bytes={} ({})", reply.len(), first_line(&status));
-                        }
-                        (Some(target), Err(fail)) if !target.is_empty() => {
-                            // LOW-2: a failed turn is reported, never a silent empty reply.
-                            let cause = fail.cause();
-                            omp_gone = matches!(fail, TurnFail::OmpGone);
-                            oplog!("turn FAILED: {cause}");
-                            let notice = format!(
-                                "[omp-spt] turn failed ({cause}) — no answer was produced.{}",
-                                if omp_gone {
-                                    " The endpoint is going down."
-                                } else {
-                                    " The endpoint is still up; retry, or an operator can inspect it with `spt rc`."
-                                }
-                            );
-                            let status = spt_call(&spt, &["send", target, "--from", &id], Some(&notice))
-                                .unwrap_or_else(|| "SEND_SPAWN_FAIL".into());
-                            oplog!("failure notice out: to={target} ({})", first_line(&status));
-                        }
-                        (_, Ok(_)) => oplog!("msg had no `from` — reply not routed (kept in omp session)"),
-                        (_, Err(fail)) => {
-                            omp_gone = matches!(fail, TurnFail::OmpGone);
-                            oplog!("turn FAILED on sender-less msg: {}", fail.cause());
-                        }
-                    }
-                    if omp_gone {
-                        exit_reason = "omp child exited mid-turn".into();
-                        break 'main;
-                    }
-                }
-            }
-            Ok(Event::OmpLine(line)) => {
-                // A frame outside a turn: either unsolicited chatter or a STALE agent_end from a
-                // timed-out turn. Log the latter so a late completion is visible, then discard.
-                if line.contains("\"agent_end\"") && stale_turns > 0 {
-                    stale_turns -= 1;
-                    oplog!("stale agent_end from a timed-out turn discarded (late completion)");
-                } else {
-                    trace!("omp frame outside turn: {}", &line[..line.len().min(120)]);
-                }
-            }
-            Ok(Event::OmpEof) => {
-                exit_reason = "omp child exited".into();
-                break 'main;
-            }
-            Ok(Event::ReadyEof) => {
-                exit_reason = "`spt ready` listener exited (delivery pipe closed)".into();
-                break 'main;
-            }
-            Err(RecvTimeoutError::Timeout) => {
-                // Liveness on every tick; the visible heartbeat only when enabled.
-                if let Ok(Some(st)) = omp_child.try_wait() {
-                    exit_reason = format!("omp child exited ({st})");
-                    break 'main;
-                }
-                if let Ok(Some(st)) = ready_child.try_wait() {
-                    exit_reason = format!("`spt ready` listener exited ({st})");
-                    break 'main;
-                }
-                if heartbeat_s != 0 {
-                    oplog!("heartbeat: idle, up {}m, {turns} turn(s) served", started.elapsed().as_secs() / 60);
-                }
-            }
-            Err(RecvTimeoutError::Disconnected) => {
-                exit_reason = "internal event channel closed".into();
-                break 'main;
-            }
-        }
-    }
-
-    // ── Teardown (graceful path; the job object backstops every other path) ─────────────────────
-    oplog!("shutting down: {exit_reason}");
-    let _ = ready_child.kill();
-    let _ = omp_child.kill();
-    // Soft-tear the perch so a dead endpoint never keeps advertising as listening (field incident
-    // symptom 3). Best-effort: auth via the bind token, else the session id.
-    let mut end_args = vec!["api", "--adapter", ADAPTER, "session-end", &id];
-    match token.as_deref() {
-        Some(t) => {
-            end_args.push("--token");
-            end_args.push(t);
-        }
-        None => {
-            end_args.push("--session-id");
-            end_args.push(&sid);
-        }
-    }
-    match spt_call(&spt, &end_args, None) {
-        Some(out) => oplog!("perch soft-teardown: {}", first_line(&out)),
-        None => oplog!("perch soft-teardown: spt could not be spawned"),
-    }
-    ExitCode::FAILURE // reaching here means a child died — loud, so the broker records a failure
-}
-
-/// The unified event stream (HIGH-4/MED-2): omp frames, listener deliveries, and child EOFs all
-/// arrive on one channel, so every wait is a bounded `recv_timeout`.
-enum Event {
-    OmpLine(String),
-    OmpEof,
-    ReadyLine(String),
-    ReadyEof,
-}
-
-/// Read `stream` line-by-line into the event channel from a dedicated thread; emit `eof` when the
-/// stream closes (child exit). Generic over the two children.
-fn spawn_line_reader<R: std::io::Read + Send + 'static>(
-    stream: Option<R>,
-    tx: Sender<Event>,
-    wrap: fn(String) -> Event,
-    eof: Event,
-) {
-    let Some(stream) = stream else { return };
-    std::thread::spawn(move || {
-        let reader = BufReader::new(stream);
-        for line in reader.lines() {
-            match line {
-                Ok(l) => {
-                    if tx.send(wrap(l)).is_err() {
-                        return; // main loop gone
-                    }
-                }
-                Err(_) => break,
-            }
-        }
-        let _ = tx.send(eof);
-    });
-}
-
-/// Await an omp frame matching `pick` within `deadline`. Non-matching omp frames are skipped;
-/// listener lines arriving early are DROPPED (nothing should be inbound before the perch exists).
-fn await_frame<T>(
-    rx: &Receiver<Event>,
-    deadline: Duration,
-    pick: impl Fn(&Value) -> Option<T>,
-) -> Result<T, String> {
-    let until = Instant::now() + deadline;
-    loop {
-        let left = until.saturating_duration_since(Instant::now());
-        if left.is_zero() {
-            return Err("deadline".into());
-        }
-        match rx.recv_timeout(left) {
-            Ok(Event::OmpLine(line)) => {
-                if let Ok(v) = serde_json::from_str::<Value>(line.trim()) {
-                    if let Some(t) = pick(&v) {
-                        return Ok(t);
-                    }
-                }
-            }
-            Ok(Event::OmpEof) => return Err("omp exited".into()),
-            Ok(_) => {} // listener events before the relay exists — ignore
-            Err(RecvTimeoutError::Timeout) => return Err("deadline".into()),
-            Err(RecvTimeoutError::Disconnected) => return Err("event channel closed".into()),
-        }
-    }
-}
-
-/// Write one host→omp frame (newline-delimited, flushed).
-fn send_frame(stdin: &mut ChildStdin, frame: &Value) -> bool {
-    let mut line = frame.to_string();
-    line.push('\n');
-    stdin.write_all(line.as_bytes()).is_ok() && stdin.flush().is_ok()
-}
-
-/// How a driven turn ended (HIGH-4). `OmpGone` tells the main loop the resident child is dead —
-/// the endpoint cannot serve again and must tear down; the other failures leave it serving.
-enum TurnFail {
-    /// The per-turn deadline passed with no `agent_end`; the late completion is marked stale.
-    Timeout(u64),
-    /// omp's stdout closed mid-turn (the child died).
-    OmpGone,
-    /// The prompt could not be written / the channel broke.
-    Io(String),
-}
-
-impl TurnFail {
-    fn cause(&self) -> String {
-        match self {
-            TurnFail::Timeout(s) => format!("no answer within {s}s"),
-            TurnFail::OmpGone => "the omp process died mid-turn".into(),
-            TurnFail::Io(e) => e.clone(),
-        }
-    }
-}
-
-/// Drive one turn: send the prompt, consume events until `agent_end`, within `deadline` (HIGH-4).
-/// Listener deliveries that arrive MID-TURN are not lost or reordered — they are pushed onto
-/// `pending`, which the main loop drains after this turn completes. On deadline the turn is
-/// abandoned (`stale_turns` marks the late agent_end for discard on arrival).
-fn drive_turn(
-    omp_stdin: &mut ChildStdin,
-    rx: &Receiver<Event>,
-    deadline: Duration,
-    prompt: &str,
-    pending: &mut std::collections::VecDeque<String>,
-    stale_turns: &mut u32,
-) -> Result<String, TurnFail> {
-    if !send_frame(omp_stdin, &json!({"type": "prompt", "message": prompt})) {
-        return Err(TurnFail::Io("could not write the prompt frame to omp".into()));
-    }
-    let until = Instant::now() + deadline;
-    loop {
-        let left = until.saturating_duration_since(Instant::now());
-        if left.is_zero() {
-            *stale_turns += 1;
-            return Err(TurnFail::Timeout(deadline.as_secs()));
-        }
-        match rx.recv_timeout(left) {
-            Ok(Event::OmpLine(line)) => {
-                if let Ok(v) = serde_json::from_str::<Value>(line.trim()) {
-                    if v["type"].as_str() == Some("agent_end") {
-                        return Ok(extract_reply(&v));
-                    }
-                }
-                // prompt ack / agent_start / message_update — the turn stream; not the end.
-            }
-            Ok(Event::OmpEof) => return Err(TurnFail::OmpGone),
-            Ok(Event::ReadyLine(line)) => pending.push_back(line), // deliver after this turn
-            Ok(Event::ReadyEof) => {
-                // The delivery pipe died mid-turn; finish the turn (the answer may still be
-                // routable) — the main loop notices the EOF on its own next receive... except we
-                // just consumed it. Re-queue the fact as a poisoned pending marker instead.
-                pending.push_back(String::new()); // sentinel: empty line parses to no events
-                // The listener child's exit is re-detected by the heartbeat try_wait.
-            }
-            Err(RecvTimeoutError::Timeout) => {
-                *stale_turns += 1;
-                return Err(TurnFail::Timeout(deadline.as_secs()));
-            }
-            Err(RecvTimeoutError::Disconnected) => {
-                return Err(TurnFail::Io("event channel closed".into()))
-            }
-        }
-    }
-}
-
-/// Pull the capability token from `spt api bind` stdout. The line is `BOUND:<id> token=<hex>`; the
-/// token authenticates later `state` calls (`--token`). `None` if absent (e.g. a token-less revive).
-fn parse_bound_token(bind_out: &str) -> Option<String> {
-    for line in bind_out.lines() {
-        if let Some(i) = line.find("token=") {
-            let tok = line[i + "token=".len()..]
-                .split_whitespace()
-                .next()
-                .unwrap_or("");
-            if !tok.is_empty() {
-                return Some(tok.to_string());
-            }
-        }
-    }
-    None
-}
-
-/// First non-empty line of a multi-line string (for terse diagnostics).
-fn first_line(s: &str) -> &str {
-    s.lines().find(|l| !l.trim().is_empty()).unwrap_or("")
-}
-
-/// Pull the assistant's answer out of an `agent_end` frame: the LAST `role:"assistant"` message,
-/// concatenating its `content[]` entries of `type:"text"`. Empty string if none.
-fn extract_reply(agent_end: &Value) -> String {
-    let msgs = match agent_end["messages"].as_array() {
-        Some(m) => m,
-        None => return String::new(),
-    };
-    let assistant = msgs
-        .iter()
-        .rev()
-        .find(|m| m["role"].as_str() == Some("assistant"));
-    let assistant = match assistant {
-        Some(a) => a,
-        None => return String::new(),
-    };
-    let mut out = String::new();
-    if let Some(parts) = assistant["content"].as_array() {
-        for p in parts {
-            if p["type"].as_str() == Some("text") {
-                if let Some(t) = p["text"].as_str() {
-                    out.push_str(t);
-                }
-            }
-        }
-    }
-    out
-}
-
-/// Parse `spt ready`/`spt api poll` stdout into `(from, body)` messages. The wire grammar
-/// (spt-proto::event, per hook.rs and SPT_HARNESS_ADAPTER_TIPS.md §"Message delivery is stdout
-/// framing") is a stream of `<EVENT type="…" from="<sender>">body</EVENT>` envelopes. Only
-/// `type="msg"` envelopes are returned — `notify`/`alarm`/`echo_commune`/`init_signoff` are dropped
-/// (they must NOT be forwarded to omp as a prompt). `from` is `None` when the envelope carries no
-/// sender attribute. Malformed/truncated tails are skipped (best-effort drain).
-fn parse_events(raw: &str) -> Vec<(Option<String>, String)> {
-    let mut out = Vec::new();
-    let mut rest = raw;
-    while let Some(start) = rest.find("<EVENT") {
-        let after = &rest[start..];
-        let gt = match after.find('>') {
-            Some(g) => g,
-            None => break, // opening tag never closes — truncated tail
-        };
-        let open_tag = &after[..gt]; // "<EVENT type=\"msg\" from=\"doyle\""
-        let etype = attr_value(open_tag, "type");
-        let from = attr_value(open_tag, "from");
-        let body_start = gt + 1;
-        let close = match after[body_start..].find("</EVENT>") {
-            Some(c) => c,
-            None => break, // body never closes — truncated tail
-        };
-        if etype.as_deref() == Some("msg") {
-            let body = after[body_start..body_start + close].to_string();
-            out.push((from, body));
-        }
-        let consumed = start + body_start + close + "</EVENT>".len();
-        rest = &rest[consumed..];
-    }
-    out
-}
-
-/// Extract `name="value"` from an opening-tag substring. Space-anchored so `from` never matches a
-/// substring of another attribute (mirrors hook.rs's EVENT attribute reader).
-fn attr_value(open_tag: &str, name: &str) -> Option<String> {
-    let needle = format!(" {name}=\"");
-    let i = open_tag.find(&needle)? + needle.len();
-    let end = open_tag[i..].find('"')? + i;
-    Some(open_tag[i..end].to_string())
-}
-
-/// `spt api state <busy|idle> <id>` with auth. Prefers the bind `--token` (the reliable credential);
-/// falls back to `--session-id` when no token was minted. Failures LAND ON THE LOG (LOW-1) — state
-/// is advisory, but an auth refusal here is the first symptom of a wedged perch.
-fn set_state(spt: &str, id: &str, sid: &str, token: Option<&str>, state: &str) {
-    let mut a = vec!["api", "--adapter", ADAPTER, "state", state, id];
-    match token {
-        Some(t) => {
-            a.push("--token");
-            a.push(t);
-        }
-        None => {
-            a.push("--session-id");
-            a.push(sid);
-        }
-    }
-    match spt_call(spt, &a, None) {
-        Some(out) if out.contains("REFUSED") || out.contains("FAIL") => {
-            oplog!("state {state} REFUSED: {}", first_line(&out));
-        }
-        Some(_) => {}
-        None => oplog!("state {state}: spt could not be spawned"),
-    }
-}
-
-/// Invoke `spt` with args (optional stdin body), returning trimmed stdout+stderr, or `None` on spawn
-/// failure. Both streams are captured because `spt send`'s delivery token rides stderr (F-031).
-fn spt_call(spt: &str, args: &[&str], stdin: Option<&str>) -> Option<String> {
-    let mut cmd = Command::new(spt);
-    cmd.args(args);
-    cmd.stdout(Stdio::piped()).stderr(Stdio::piped());
-    cmd.stdin(if stdin.is_some() { Stdio::piped() } else { Stdio::null() });
-    let mut child = cmd.spawn().ok()?;
-    if let Some(s) = stdin {
-        if let Some(mut si) = child.stdin.take() {
-            let _ = si.write_all(s.as_bytes());
-        }
-    }
-    let out = child.wait_with_output().ok()?;
-    let mut s = String::from_utf8_lossy(&out.stdout).into_owned();
-    s.push_str(&String::from_utf8_lossy(&out.stderr));
-    while s.ends_with('\n') || s.ends_with('\r') {
-        s.pop();
-    }
-    Some(s)
-}
-
-/// Resolve the `spt` binary: PATH first (post-bootstrap), then known install locations. Mirrors
-/// hook.rs's `SysEnv::spt_bin` (kept independent to preserve this module's self-contained ethos).
-fn spt_bin() -> String {
-    if which("spt") {
-        return "spt".to_string();
-    }
-    let home = std::env::var("HOME").unwrap_or_default();
-    let local = std::env::var("LOCALAPPDATA").unwrap_or_default();
-    for p in [
-        format!("{home}/.local/bin/spt"),
-        format!("{local}/spt-core/bin/spt.exe"),
-        format!("{home}/AppData/Local/spt-core/bin/spt.exe"),
-    ] {
-        if std::path::Path::new(&p).is_file() {
-            return p;
-        }
-    }
-    "spt".to_string()
-}
-
-/// Resolve the oh-my-pi `omp` binary. IMPORTANT: PATH is checked LAST — on the Librarian host `omp`
-/// on PATH is the OneCLI *gateway* alias (a vaulted-API proxy), a name collision with the coding
-/// agent. So an explicit `OMP_SPT_OMP_BIN` override wins, then the known install path, and only then
-/// PATH. Shared with the psyche/echo-commune omp shims. The resolved path is always on the
-/// operational log, and the bringup ready-deadline turns a wrong-binary spawn into a loud failure
-/// instead of a wedge (MED-3 mitigation). [OMP-ADAPTER-PLAN.md host note]
-pub(crate) fn omp_bin() -> String {
-    if let Ok(p) = std::env::var("OMP_SPT_OMP_BIN") {
-        if !p.is_empty() {
-            return p;
-        }
-    }
-    let home = std::env::var("HOME").unwrap_or_default();
-    let local = std::env::var("LOCALAPPDATA").unwrap_or_default();
-    for p in [
-        format!("{local}/omp/omp.exe"),
-        format!("{home}/AppData/Local/omp/omp.exe"),
-        format!("{home}/.local/bin/omp"),
-    ] {
-        if std::path::Path::new(&p).is_file() {
-            return p;
-        }
-    }
-    "omp".to_string() // last resort; may be the gateway alias — prefer OMP_SPT_OMP_BIN
-}
-
-/// Is `name` resolvable on PATH? (cross-platform `command -v`).
-fn which(name: &str) -> bool {
-    let path = std::env::var_os("PATH").unwrap_or_default();
-    let exts: Vec<String> = if cfg!(windows) {
-        std::env::var("PATHEXT")
-            .unwrap_or_else(|_| ".EXE;.CMD;.BAT;.COM".into())
-            .split(';')
-            .map(|e| e.to_ascii_lowercase())
-            .collect()
-    } else {
-        vec![String::new()]
-    };
-    for dir in std::env::split_paths(&path) {
-        if dir.join(name).is_file() {
-            return true;
-        }
-        for ext in &exts {
-            if !ext.is_empty() && dir.join(format!("{name}{ext}")).is_file() {
-                return true;
-            }
-        }
-    }
-    false
-}
-
-/// HIGH-2 — OS-level child-tree teardown.
-///
-/// Windows: assign the CURRENT process to a Job Object created with
-/// `JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE`. Children spawned afterwards inherit job membership, so the
-/// OS terminates the whole tree when the job's last handle closes — which happens when this process
-/// exits, HOWEVER it exits (broker kill, crash, taskkill without /T). Hand-rolled minimal FFI: the
-/// crate stays dependency-light (serde_json only) by design.
-///
-/// Unix: no-op today — the graceful-path kills cover the common case, and the field incident
-/// platform is Windows. (A process-group + signal handler is the follow-on; tracked in
-/// docs/OMP-BRIDGE-FIELD-ISSUES.md HIGH-2.)
-mod teardown {
-    #[cfg(windows)]
-    pub fn arm_kill_on_close() -> Result<(), String> {
-        use std::ffi::c_void;
-        type Handle = *mut c_void;
-        type Bool = i32;
-        #[repr(C)]
-        #[derive(Default)]
-        struct JobObjectBasicLimitInformation {
-            per_process_user_time_limit: i64,
-            per_job_user_time_limit: i64,
-            limit_flags: u32,
-            minimum_working_set_size: usize,
-            maximum_working_set_size: usize,
-            active_process_limit: u32,
-            affinity: usize,
-            priority_class: u32,
-            scheduling_class: u32,
-        }
-        #[repr(C)]
-        #[derive(Default)]
-        struct IoCounters {
-            read_operation_count: u64,
-            write_operation_count: u64,
-            other_operation_count: u64,
-            read_transfer_count: u64,
-            write_transfer_count: u64,
-            other_transfer_count: u64,
-        }
-        #[repr(C)]
-        #[derive(Default)]
-        struct JobObjectExtendedLimitInformation {
-            basic_limit_information: JobObjectBasicLimitInformation,
-            io_info: IoCounters,
-            process_memory_limit: usize,
-            job_memory_limit: usize,
-            peak_process_memory_used: usize,
-            peak_job_memory_used: usize,
-        }
-        const JOB_OBJECT_EXTENDED_LIMIT_INFORMATION_CLASS: i32 = 9;
-        const JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE: u32 = 0x2000;
-        #[link(name = "kernel32")]
-        extern "system" {
-            fn CreateJobObjectW(attrs: *mut c_void, name: *const u16) -> Handle;
-            fn SetInformationJobObject(
-                job: Handle,
-                class: i32,
-                info: *mut c_void,
-                len: u32,
-            ) -> Bool;
-            fn AssignProcessToJobObject(job: Handle, process: Handle) -> Bool;
-            fn GetCurrentProcess() -> Handle;
-            fn GetLastError() -> u32;
-        }
-        unsafe {
-            let job = CreateJobObjectW(std::ptr::null_mut(), std::ptr::null());
-            if job.is_null() {
-                return Err(format!("CreateJobObjectW failed (err {})", GetLastError()));
-            }
-            let mut info = JobObjectExtendedLimitInformation::default();
-            info.basic_limit_information.limit_flags = JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE;
-            let ok = SetInformationJobObject(
-                job,
-                JOB_OBJECT_EXTENDED_LIMIT_INFORMATION_CLASS,
-                &mut info as *mut _ as *mut c_void,
-                std::mem::size_of::<JobObjectExtendedLimitInformation>() as u32,
-            );
-            if ok == 0 {
-                return Err(format!("SetInformationJobObject failed (err {})", GetLastError()));
-            }
-            if AssignProcessToJobObject(job, GetCurrentProcess()) == 0 {
-                return Err(format!("AssignProcessToJobObject failed (err {})", GetLastError()));
-            }
-            // The job handle is intentionally NOT closed: it lives for the process lifetime, and
-            // the OS closing it at process exit is exactly the kill-on-close trigger.
-            Ok(())
-        }
-    }
-
-    #[cfg(not(windows))]
-    pub fn arm_kill_on_close() -> Result<(), String> {
-        Err("no-op on this platform (unix process-group teardown is a tracked follow-on)".into())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use serde_json::json;
-    use std::collections::VecDeque;
-    use std::sync::mpsc::channel;
-
-    // ── EVENT-envelope parsing (unchanged contract) ──────────────────────────
-
-    #[test]
-    fn parses_single_event() {
-        let raw = "<EVENT type=\"msg\" from=\"doyle\">hello there</EVENT>";
-        assert_eq!(parse_events(raw), vec![(Some("doyle".into()), "hello there".into())]);
-    }
-
-    #[test]
-    fn parses_multiple_events_and_preserves_order() {
-        let raw = "<EVENT type=\"msg\" from=\"a\">one</EVENT><EVENT type=\"msg\" from=\"b\">two</EVENT>";
-        assert_eq!(
-            parse_events(raw),
-            vec![(Some("a".into()), "one".into()), (Some("b".into()), "two".into())]
-        );
-    }
-
-    #[test]
-    fn event_without_from_yields_none_sender() {
-        let raw = "<EVENT type=\"msg\">anon body</EVENT>";
-        assert_eq!(parse_events(raw), vec![(None, "anon body".into())]);
-    }
-
-    #[test]
-    fn empty_and_non_event_drain_is_empty() {
-        assert!(parse_events("").is_empty());
-        assert!(parse_events("no perch\n").is_empty());
-    }
-
-    #[test]
-    fn non_msg_event_types_are_filtered_out() {
-        let notify = "<EVENT type=\"notify\" from=\"spt-update\" subnet=\"Phils-Den\">update available</EVENT>";
-        assert!(parse_events(notify).is_empty());
-        let mixed = format!("{notify}<EVENT type=\"msg\" from=\"doyle\">real work</EVENT>");
-        assert_eq!(parse_events(&mixed), vec![(Some("doyle".into()), "real work".into())]);
-    }
-
-    #[test]
-    fn truncated_tail_is_skipped_not_panicked() {
-        let raw = "<EVENT type=\"msg\" from=\"x\">unterminated body";
-        assert!(parse_events(raw).is_empty());
-    }
-
-    #[test]
-    fn body_may_contain_angle_brackets() {
-        let raw = "<EVENT type=\"msg\" from=\"x\">a < b && c > d</EVENT>";
-        assert_eq!(parse_events(raw), vec![(Some("x".into()), "a < b && c > d".into())]);
-    }
-
-    #[test]
-    fn attr_value_is_space_anchored() {
-        let tag = "<EVENT type=\"msg\" from=\"doyle\"";
-        assert_eq!(attr_value(tag, "from"), Some("doyle".into()));
-        assert_eq!(attr_value(tag, "type"), Some("msg".into()));
-        assert_eq!(attr_value(tag, "missing"), None);
-    }
-
-    // ── reply extraction + bind token (unchanged contract) ──────────────────
-
-    #[test]
-    fn extract_reply_takes_last_assistant_text() {
-        let f = json!({
-            "type": "agent_end",
-            "messages": [
-                {"role": "user", "content": [{"type": "text", "text": "hi"}]},
-                {"role": "assistant", "content": [
-                    {"type": "text", "text": "ok"},
-                    {"type": "text", "text": " done"}
-                ]}
-            ]
-        });
-        assert_eq!(extract_reply(&f), "ok done");
-    }
-
-    #[test]
-    fn extract_reply_empty_without_assistant() {
-        let f = json!({"type": "agent_end", "messages": [{"role": "user", "content": []}]});
-        assert_eq!(extract_reply(&f), "");
-        let f2 = json!({"type": "agent_end"});
-        assert_eq!(extract_reply(&f2), "");
-    }
-
-    #[test]
-    fn parses_bound_token() {
-        assert_eq!(
-            parse_bound_token("BOUND:omp-spt-seq token=9eb0a091e24a045b").as_deref(),
-            Some("9eb0a091e24a045b")
-        );
-        let multi = "ADAPTER_SKIP:omp-spt — …\nBOUND:x token=abc123\nNOTIFS_RESURFACED:x:1";
-        assert_eq!(parse_bound_token(multi).as_deref(), Some("abc123"));
-        assert_eq!(parse_bound_token("BOUND:x"), None);
-        assert_eq!(parse_bound_token(""), None);
-    }
-
-    // ── HIGH-4: bounded waits over the event channel ─────────────────────────
-
-    #[test]
-    fn await_frame_picks_matching_frame_and_skips_noise() {
-        let (tx, rx) = channel();
-        tx.send(Event::OmpLine("not json".into())).unwrap();
-        tx.send(Event::OmpLine(r#"{"type":"available_commands_update"}"#.into())).unwrap();
-        tx.send(Event::OmpLine(r#"{"type":"ready"}"#.into())).unwrap();
-        let got = await_frame(&rx, Duration::from_secs(2), |f| {
-            (f["type"].as_str() == Some("ready")).then_some(())
-        });
-        assert!(got.is_ok());
-    }
-
-    #[test]
-    fn await_frame_times_out_and_reports_omp_exit() {
-        let (tx, rx) = channel::<Event>();
-        let err = await_frame(&rx, Duration::from_millis(30), |_: &Value| Some(())).unwrap_err();
-        assert!(err.contains("deadline"));
-        tx.send(Event::OmpEof).unwrap();
-        let err = await_frame(&rx, Duration::from_secs(1), |_: &Value| Option::<()>::None).unwrap_err();
-        assert!(err.contains("omp exited"));
-    }
-
-    // ── drive_turn: buffering + deadline + failure classification ───────────
-    // (drive_turn needs a live ChildStdin to write the prompt; the pure receive-side behaviors are
-    // covered through await_frame above and the TurnFail causes below.)
-
-    #[test]
-    fn turn_fail_causes_are_operator_readable() {
-        assert!(TurnFail::Timeout(600).cause().contains("600s"));
-        assert!(TurnFail::OmpGone.cause().contains("died"));
-        assert_eq!(TurnFail::Io("x".into()).cause(), "x");
-    }
-
-    #[test]
-    fn pending_deque_preserves_delivery_order() {
-        // The mid-turn buffering contract: lines pushed during a turn come back FIFO.
-        let mut pending: VecDeque<String> = VecDeque::new();
-        pending.push_back("<EVENT type=\"msg\" from=\"a\">first</EVENT>".into());
-        pending.push_back("<EVENT type=\"msg\" from=\"b\">second</EVENT>".into());
-        let first = pending.pop_front().unwrap();
-        assert_eq!(parse_events(&first)[0].0.as_deref(), Some("a"));
-        let second = pending.pop_front().unwrap();
-        assert_eq!(parse_events(&second)[0].0.as_deref(), Some("b"));
-    }
-
-    // ── env knobs ────────────────────────────────────────────────────────────
-
-    #[test]
-    fn env_secs_defaults_and_parses() {
-        assert_eq!(env_secs("OMP_SPT_TEST_UNSET_KNOB", 42), 42);
-        std::env::set_var("OMP_SPT_TEST_SET_KNOB", "7");
-        assert_eq!(env_secs("OMP_SPT_TEST_SET_KNOB", 42), 7);
-        std::env::set_var("OMP_SPT_TEST_BAD_KNOB", "not-a-number");
-        assert_eq!(env_secs("OMP_SPT_TEST_BAD_KNOB", 42), 42);
-    }
-
-    // ── HIGH-2: the job object arms on Windows ───────────────────────────────
-
-    #[cfg(windows)]
-    #[test]
-    fn job_object_arms_on_windows() {
-        // Assigning the TEST process to a kill-on-close job is safe: the handle leaks for the
-        // process lifetime and the test process owns no children.
-        assert!(teardown::arm_kill_on_close().is_ok());
-    }
-}
diff --git a/tools/claude-spt/src/digest.rs b/tools/claude-spt/src/digest.rs
deleted file mode 100644
index 2266f96..0000000
--- a/tools/claude-spt/src/digest.rs
+++ /dev/null
@@ -1,525 +0,0 @@
-//! `claude-spt digest` — the `[digest]` session-digest extractor (was the claude-spt-digest crate).
-//!
-//! Maps Claude Code's native JSONL transcript -> the published digest-record contract: NDJSON, one
-//! `{"role","text"?,"tool"?,"ts"?}` object per stdout line. Emits RAW records — spt-core's digest
-//! renderer applies the `[digest]` presentation defaults (window_turns / arg_truncation /
-//! sprint_collapse), NOT this extractor. `role` is one of `input | agent | tool` (the published enum).
-//!
-//! Per-session by contract: spt-core's session ledger stitches the per-endpoint digest across
-//! `/clear`; this reads exactly ONE session's log (the watch-item doyle flagged 2026-06-15 —
-//! single-session slice is correct here, the spanning is ledger-side).
-//!
-//! Invoked by spt-core (FETCHER strategy, v0.10.0 / spt-core v0.19.0, REQ-DIST-DIGEST-FETCHER):
-//!   `claude-spt digest --session <session_id> --config-dir <claude-config-root>`
-//!   The extractor IS the locator: the session file lives at
-//!   `<config-root>/projects/<cwd-slug>/<session_id>.jsonl` and the cwd-slug subdir is a CC-internal
-//!   encoding not expressible as a flat template, so we LOCATE `<session_id>.jsonl` by search under
-//!   the projects root. `<claude-config-root>` is the spt-core-captured {CLAUDE_CONFIG_DIR} read-var
-//!   ([env] direction="read") — the session's own value, or the manifest fallback `~/.claude`.
-//!   Legacy `--in` stays accepted: `spt adapter digest-proof --sample <file>` points it straight at
-//!   a log file (read as-is, never overridden), and an old locate_normalize manifest mid-update may
-//!   still pass a projects-root dir (used only when no config-dir source resolves).
-//!
-//! ccs profile (REQ-CCS-PROFILES): a ccs-launched session relocates CC's whole state tree —
-//! including `projects/` — under `$CLAUDE_CONFIG_DIR` (e.g. `~/.ccs/instances/<account>/.claude`).
-//! That value is set by ccs at runtime per-account and is NOT expressible as a static manifest path,
-//! so the `claude-spt:ccs` overlay carries no `[digest]` leaf — the captured read-var reaches this
-//! extractor via `--config-dir` even in the daemon's context. The inherited-env preference
-//! ($CLAUDE_CONFIG_DIR/projects, the pre-0.19.0 branch mirroring owlery::claude_projects_root) is
-//! kept as the next rung of the precedence chain (see resolve_projects_root).
-//!
-//! Mapping (CC event -> digest record):
-//!   type=user,  message.content str         -> {role:input, text}              (a real user prompt)
-//!   type=user,  content[].type=text         -> {role:input, text}
-//!   type=assistant, content[].type=text     -> {role:agent, text}
-//!   type=assistant, content[].type=tool_use -> {role:tool,  tool:{name,arg}}
-//!   thinking / tool_result / attachment / queue-operation / last-prompt -> skipped (not emitted)
-//! [impl->REQ-DIST-DIGEST-EXTRACTOR]
-
-use serde_json::{json, Value};
-use std::fs::{self, File};
-use std::io::{self, BufRead, BufReader, BufWriter, Write};
-use std::path::{Path, PathBuf};
-use std::process::ExitCode;
-
-/// Single salient arg per tool call (spt-core truncates to arg_truncation). Preference order picks
-/// the most digest-meaningful field; falls back to the first scalar, then compact JSON of the input.
-const ARG_KEYS: &[&str] = &[
-    "file_path", "path", "notebook_path", "command", "pattern", "query", "url", "prompt",
-    "old_string", "description", "subagent_type",
-];
-
-pub(crate) fn scalar_str(v: &Value) -> Option<String> {
-    match v {
-        Value::String(s) => Some(s.clone()),
-        Value::Number(n) => Some(n.to_string()),
-        Value::Bool(b) => Some(b.to_string()),
-        _ => None,
-    }
-}
-
-fn tool_arg(input: &Value) -> String {
-    let obj = match input.as_object() {
-        Some(o) => o,
-        None => return String::new(),
-    };
-    for k in ARG_KEYS {
-        if let Some(s) = obj.get(*k).and_then(scalar_str) {
-            if !s.is_empty() {
-                return s;
-            }
-        }
-    }
-    for v in obj.values() {
-        if let Some(s) = scalar_str(v) {
-            if !s.is_empty() {
-                return s;
-            }
-        }
-    }
-    serde_json::to_string(input).unwrap_or_default()
-}
-
-pub(crate) fn rec(role: &str, text: Option<&str>, tool: Option<Value>, ts: Option<&str>) -> Value {
-    let mut m = serde_json::Map::new();
-    m.insert("role".into(), json!(role));
-    if let Some(t) = text {
-        m.insert("text".into(), json!(t));
-    }
-    if let Some(t) = tool {
-        m.insert("tool".into(), t);
-    }
-    if let Some(t) = ts {
-        if !t.is_empty() {
-            m.insert("ts".into(), json!(t));
-        }
-    }
-    Value::Object(m)
-}
-
-/// Read CC JSONL from `reader`, write digest NDJSON to `writer`. Pure over byte streams so it is
-/// directly unit-testable without touching the filesystem.
-fn extract<R: BufRead, W: Write>(reader: R, mut writer: W) -> io::Result<()> {
-    for line in reader.lines() {
-        let line = line?;
-        let line = line.trim();
-        if line.is_empty() {
-            continue;
-        }
-        let o: Value = match serde_json::from_str(line) {
-            Ok(v) => v,
-            Err(_) => continue, // CC's log is well-formed; a stray line is not ours to emit
-        };
-        let typ = o.get("type").and_then(Value::as_str).unwrap_or("");
-        let ts = o.get("timestamp").and_then(Value::as_str);
-        let msg = match o.get("message").and_then(Value::as_object) {
-            Some(m) => m,
-            None => continue,
-        };
-        let role = msg.get("role").and_then(Value::as_str).unwrap_or("");
-        let content = msg.get("content");
-
-        if typ == "user" && role == "user" {
-            // A plain prompt is a string. List-content user turns are tool_results -> skip those.
-            match content {
-                Some(Value::String(s)) if !s.is_empty() => {
-                    writeln!(writer, "{}", rec("input", Some(s), None, ts))?;
-                }
-                Some(Value::Array(items)) => {
-                    for it in items {
-                        if it.get("type").and_then(Value::as_str) == Some("text") {
-                            if let Some(t) = it.get("text").and_then(Value::as_str) {
-                                if !t.is_empty() {
-                                    writeln!(writer, "{}", rec("input", Some(t), None, ts))?;
-                                }
-                            }
-                        }
-                    }
-                }
-                _ => {}
-            }
-        } else if typ == "assistant" && role == "assistant" {
-            if let Some(Value::Array(items)) = content {
-                for it in items {
-                    match it.get("type").and_then(Value::as_str) {
-                        Some("text") => {
-                            if let Some(t) = it.get("text").and_then(Value::as_str) {
-                                if !t.is_empty() {
-                                    writeln!(writer, "{}", rec("agent", Some(t), None, ts))?;
-                                }
-                            }
-                        }
-                        Some("tool_use") => {
-                            let name = it.get("name").and_then(Value::as_str).unwrap_or("");
-                            let arg = it.get("input").map(tool_arg).unwrap_or_default();
-                            let tool = json!({"name": name, "arg": arg});
-                            writeln!(writer, "{}", rec("tool", None, Some(tool), ts))?;
-                        }
-                        _ => {} // thinking, etc. -> skip
-                    }
-                }
-            }
-        }
-        // other event types -> skip
-    }
-    writer.flush()
-}
-
-/// Locate `<session>.jsonl` under `root` (depth-1 guess first, then a bounded recursive sweep —
-/// the cwd-slug subdir is CC-internal so the exact path is not known a priori).
-pub(crate) fn locate(root: &Path, session: &str) -> Option<PathBuf> {
-    let target = format!("{session}.jsonl");
-    // Depth-1: root/<slug>/<session>.jsonl
-    if let Ok(entries) = fs::read_dir(root) {
-        for e in entries.flatten() {
-            let p = e.path();
-            if p.is_dir() {
-                let cand = p.join(&target);
-                if cand.is_file() {
-                    return Some(cand);
-                }
-            }
-        }
-    }
-    // Bounded recursive fallback.
-    find_recursive(root, &target, 6)
-}
-
-fn find_recursive(dir: &Path, target: &str, depth: usize) -> Option<PathBuf> {
-    if depth == 0 {
-        return None;
-    }
-    let entries = fs::read_dir(dir).ok()?;
-    for e in entries.flatten() {
-        let p = e.path();
-        if p.is_file() {
-            if p.file_name().and_then(|n| n.to_str()) == Some(target) {
-                return Some(p);
-            }
-        } else if p.is_dir() {
-            if let Some(hit) = find_recursive(&p, target, depth - 1) {
-                return Some(hit);
-            }
-        }
-    }
-    None
-}
-
-struct Args {
-    session: Option<String>,
-    source: Option<String>,
-    config_dir: Option<String>,
-}
-
-/// Parse `--session <id> [--config-dir <dir>] [--in <source>]` from the subcommand's argv (main
-/// already skipped the binary name + the `digest` token). Order-independent single-value flags.
-/// `--config-dir` is the v0.10.0 fetcher-strategy fill (`{CLAUDE_CONFIG_DIR}`, spt-core v0.19.0
-/// read-var capture); `--in` stays for digest-proof `--sample` files + legacy manifests mid-update.
-fn parse_args<I: IntoIterator<Item = String>>(argv: I) -> Result<Args, String> {
-    let mut session = None;
-    let mut source = None;
-    let mut config_dir = None;
-    let mut it = argv.into_iter();
-    while let Some(a) = it.next() {
-        match a.as_str() {
-            "--session" => session = it.next(),
-            "--in" => source = it.next(),
-            "--config-dir" => config_dir = it.next(),
-            "-h" | "--help" => {
-                println!("claude-spt digest --session <id> [--config-dir <claude-config-root>] [--in <projects-root-or-logfile>]");
-                std::process::exit(0);
-            }
-            other => return Err(format!("unknown arg: {other}")),
-        }
-    }
-    Ok(Args { session, source, config_dir })
-}
-
-/// Expand a leading `~/` (or bare `~`) to the user's home. spt-core resolves `~` in the `source`
-/// template, but the extractor expands defensively too — it runs argv-direct (no shell), so a
-/// literal `~` would otherwise become a bogus relative path.
-pub(crate) fn expand_tilde(p: &str) -> PathBuf {
-    if p == "~" || p.starts_with("~/") || p.starts_with("~\\") {
-        if let Some(home) = std::env::var_os("HOME").or_else(|| std::env::var_os("USERPROFILE")) {
-            let rest = p[1..].trim_start_matches(['/', '\\']);
-            return Path::new(&home).join(rest);
-        }
-    }
-    PathBuf::from(p)
-}
-
-/// ccs (and any CLAUDE_CONFIG_DIR-relocating launcher) move CC's state tree — including the
-/// `projects/` transcript root — under `$CLAUDE_CONFIG_DIR`. Returns `$CLAUDE_CONFIG_DIR/projects`
-/// when `cfg` is `Some` and non-empty, else `None` (caller falls back to the `--in` root). Pure over
-/// its input so the env read stays at the edge and this is unit-testable without env races. Mirrors
-/// the known-good claude_skill_owl resolver (owlery::claude_projects_root). [impl->REQ-CCS-PROFILES]
-fn ccs_projects_root_from(cfg: Option<&str>) -> Option<PathBuf> {
-    match cfg {
-        Some(c) if !c.is_empty() => Some(PathBuf::from(c).join("projects")),
-        _ => None,
-    }
-}
-
-/// Resolve the projects ROOT for the dir-locate branch (the fetcher strategy's locator half).
-/// Precedence: `--config-dir` (the spt-core-captured {CLAUDE_CONFIG_DIR} read-var — authoritative,
-/// it IS the session's value or the manifest's ~/.claude fallback) → $CLAUDE_CONFIG_DIR env (an
-/// in-session invocation that inherited the harness env; the pre-0.19.0 branch, kept) → a legacy
-/// `--in` root (old manifest mid-update / digest-proof pointing at a dir) → `~/.claude/projects`.
-/// Pure over its inputs so the precedence is unit-testable without env races.
-/// [impl->REQ-DIST-DIGEST-FETCHER]
-pub(crate) fn resolve_projects_root(
-    config_dir: Option<&str>,
-    env_cfg: Option<&str>,
-    in_root: Option<PathBuf>,
-) -> PathBuf {
-    ccs_projects_root_from(config_dir)
-        .or_else(|| ccs_projects_root_from(env_cfg))
-        .or(in_root)
-        .unwrap_or_else(|| expand_tilde("~/.claude").join("projects"))
-}
-
-fn execute<I: IntoIterator<Item = String>>(argv: I) -> Result<(), String> {
-    let args = parse_args(argv)?;
-    if args.source.is_none() && args.config_dir.is_none() {
-        return Err("missing --config-dir (or legacy --in)".into());
-    }
-    let src: Option<PathBuf> = args.source.as_deref().map(expand_tilde);
-
-    // A legacy --in may be a direct log FILE (digest-proof --sample) -> read it as-is, no override.
-    let path: Option<PathBuf> = match src {
-        Some(f) if f.is_file() => Some(f),
-        src_dir => {
-            // Directory ("projects root") branch — the fetcher locate (the adapter owns the slug).
-            let cfg = args.config_dir.as_deref().map(expand_tilde);
-            let cfg_str = cfg.as_ref().map(|p| p.to_string_lossy().into_owned());
-            let env_cfg = std::env::var("CLAUDE_CONFIG_DIR").ok();
-            let root =
-                resolve_projects_root(cfg_str.as_deref(), env_cfg.as_deref(), src_dir);
-            if root.is_dir() {
-                let session =
-                    args.session.ok_or("locating in a projects root needs --session")?;
-                locate(&root, &session)
-            } else {
-                None
-            }
-        }
-    };
-
-    let path = match path {
-        Some(p) => p,
-        None => return Ok(()), // no log -> empty digest (not an error; spt-core reports the empty)
-    };
-
-    let file = File::open(&path).map_err(|e| format!("open {}: {e}", path.display()))?;
-    let stdout = io::stdout();
-    let writer = BufWriter::new(stdout.lock());
-    extract(BufReader::new(file), writer).map_err(|e| e.to_string())
-}
-
-/// `claude-spt digest` entry. Reads its own argv (binary name + `digest` token already consumed).
-pub fn run() -> ExitCode {
-    match execute(std::env::args().skip(2)) {
-        Ok(()) => ExitCode::SUCCESS,
-        Err(e) => {
-            eprintln!("claude-spt digest: {e}");
-            ExitCode::from(2)
-        }
-    }
-}
-
-// [unit->REQ-DIST-DIGEST-EXTRACTOR]
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use serde_json::Value;
-
-    fn run_extract(input: &str) -> Vec<Value> {
-        let mut out = Vec::new();
-        extract(input.as_bytes(), &mut out).unwrap();
-        String::from_utf8(out)
-            .unwrap()
-            .lines()
-            .filter(|l| !l.trim().is_empty())
-            .map(|l| serde_json::from_str(l).expect("each output line is valid JSON"))
-            .collect()
-    }
-
-    #[test]
-    fn user_string_is_input() {
-        let recs = run_extract(
-            r#"{"type":"user","timestamp":"2026-06-15T10:00:00Z","message":{"role":"user","content":"hello"}}"#,
-        );
-        assert_eq!(recs.len(), 1);
-        assert_eq!(recs[0]["role"], "input");
-        assert_eq!(recs[0]["text"], "hello");
-        assert_eq!(recs[0]["ts"], "2026-06-15T10:00:00Z");
-    }
-
-    #[test]
-    fn assistant_text_is_agent_thinking_skipped() {
-        let recs = run_extract(
-            r#"{"type":"assistant","message":{"role":"assistant","content":[{"type":"thinking","thinking":"x"},{"type":"text","text":"hi"}]}}"#,
-        );
-        assert_eq!(recs.len(), 1, "thinking dropped, text kept");
-        assert_eq!(recs[0]["role"], "agent");
-        assert_eq!(recs[0]["text"], "hi");
-    }
-
-    #[test]
-    fn tool_use_maps_name_and_arg() {
-        let recs = run_extract(
-            r#"{"type":"assistant","message":{"role":"assistant","content":[{"type":"tool_use","name":"Write","input":{"file_path":"src/a.rs","content":"fn main(){}"}}]}}"#,
-        );
-        assert_eq!(recs.len(), 1);
-        assert_eq!(recs[0]["role"], "tool");
-        assert_eq!(recs[0]["tool"]["name"], "Write");
-        assert_eq!(recs[0]["tool"]["arg"], "src/a.rs"); // file_path preferred over content
-    }
-
-    #[test]
-    fn tool_arg_prefers_command_then_first_scalar() {
-        let recs = run_extract(
-            r#"{"type":"assistant","message":{"role":"assistant","content":[{"type":"tool_use","name":"Bash","input":{"command":"cargo build","description":"d"}}]}}"#,
-        );
-        assert_eq!(recs[0]["tool"]["arg"], "cargo build");
-    }
-
-    #[test]
-    fn user_tool_result_is_skipped() {
-        let recs = run_extract(
-            r#"{"type":"user","message":{"role":"user","content":[{"type":"tool_result","tool_use_id":"t1","content":"ok"}]}}"#,
-        );
-        assert!(recs.is_empty(), "tool_result has no contract role");
-    }
-
-    #[test]
-    fn noise_types_and_bad_lines_skipped() {
-        let input = concat!(
-            r#"{"type":"attachment","attachment":{}}"#,
-            "\n",
-            r#"{"type":"last-prompt","lastPrompt":"x"}"#,
-            "\n",
-            "this is not json\n",
-            "\n",
-            r#"{"type":"assistant","message":{"role":"assistant","content":[{"type":"text","text":"only this"}]}}"#,
-        );
-        let recs = run_extract(input);
-        assert_eq!(recs.len(), 1);
-        assert_eq!(recs[0]["text"], "only this");
-    }
-
-    #[test]
-    fn non_ascii_round_trips_utf8() {
-        let recs = run_extract(
-            r#"{"type":"assistant","message":{"role":"assistant","content":[{"type":"text","text":"done — built clean"}]}}"#,
-        );
-        assert_eq!(recs[0]["text"], "done — built clean");
-    }
-
-    #[test]
-    fn tilde_expands_to_home() {
-        std::env::set_var("HOME", "/home/test");
-        assert_eq!(expand_tilde("~/.claude/projects"), Path::new("/home/test").join(".claude/projects"));
-        assert_eq!(expand_tilde("/abs/path"), PathBuf::from("/abs/path"));
-        assert_eq!(expand_tilde("rel/path"), PathBuf::from("rel/path"));
-    }
-
-    // [unit->REQ-CCS-PROFILES] ccs CLAUDE_CONFIG_DIR-aware projects-root resolution. Pure helper so
-    // no env mutation / no test races (owl parity: set -> $CFG/projects; unset/empty -> fall back).
-    #[test]
-    fn ccs_root_honors_config_dir() {
-        assert_eq!(
-            ccs_projects_root_from(Some("/tmp/ccs-acct/.claude")),
-            Some(Path::new("/tmp/ccs-acct/.claude").join("projects"))
-        );
-    }
-
-    #[test]
-    fn ccs_root_none_when_unset() {
-        assert_eq!(ccs_projects_root_from(None), None);
-    }
-
-    #[test]
-    fn ccs_root_ignores_empty() {
-        // Empty env var must NOT shadow the --in fallback (owl: `!cfg.is_empty()` guard).
-        assert_eq!(ccs_projects_root_from(Some("")), None);
-    }
-
-    #[test]
-    fn parse_args_reads_session_and_in_order_independent() {
-        // The subcommand parser sees argv AFTER `claude-spt digest` is stripped by main.
-        let a = parse_args(
-            ["--in", "/p/root", "--session", "sess-1"]
-                .iter()
-                .map(|s| s.to_string()),
-        )
-        .unwrap();
-        assert_eq!(a.session.as_deref(), Some("sess-1"));
-        assert_eq!(a.source.as_deref(), Some("/p/root"));
-    }
-
-    // [unit->REQ-DIST-DIGEST-FETCHER] the v0.10.0 fetcher fill: --config-dir parses beside the
-    // legacy flags (the manifest extractor line threads {CLAUDE_CONFIG_DIR} through it).
-    #[test]
-    fn parse_args_reads_config_dir() {
-        let a = parse_args(
-            ["--session", "s", "--config-dir", "/u/.ccs/acct/.claude"]
-                .iter()
-                .map(|s| s.to_string()),
-        )
-        .unwrap();
-        assert_eq!(a.config_dir.as_deref(), Some("/u/.ccs/acct/.claude"));
-        assert_eq!(a.source, None);
-    }
-
-    // [unit->REQ-DIST-DIGEST-FETCHER] projects-root precedence: the spt-core-captured --config-dir
-    // fill is authoritative; the inherited env is next (pre-0.19.0 branch, kept); a legacy --in
-    // root third; the ~/.claude default last. Pure helper — no env mutation in the test.
-    #[test]
-    fn projects_root_precedence_config_dir_wins() {
-        let root = resolve_projects_root(
-            Some("/cap/.claude"),
-            Some("/env/.claude"),
-            Some(PathBuf::from("/in/projects")),
-        );
-        assert_eq!(root, Path::new("/cap/.claude").join("projects"));
-    }
-
-    #[test]
-    fn projects_root_precedence_env_then_in() {
-        let env_next =
-            resolve_projects_root(None, Some("/env/.claude"), Some(PathBuf::from("/in/p")));
-        assert_eq!(env_next, Path::new("/env/.claude").join("projects"));
-        let in_third = resolve_projects_root(None, None, Some(PathBuf::from("/in/p")));
-        assert_eq!(in_third, Path::new("/in/p"));
-    }
-
-    #[test]
-    fn projects_root_defaults_to_home_claude() {
-        // Empty captured value must not shadow the chain (mirrors ccs_root_ignores_empty).
-        let root = resolve_projects_root(Some(""), None, None);
-        assert!(root.ends_with(Path::new(".claude").join("projects")), "got {root:?}");
-    }
-
-    #[test]
-    fn every_record_satisfies_the_contract() {
-        // role enum + field-presence invariants across a mixed stream.
-        let input = concat!(
-            r#"{"type":"user","message":{"role":"user","content":"q"}}"#,
-            "\n",
-            r#"{"type":"assistant","message":{"role":"assistant","content":[{"type":"text","text":"a"},{"type":"tool_use","name":"Read","input":{"file_path":"f"}}]}}"#,
-        );
-        for r in run_extract(input) {
-            let role = r["role"].as_str().unwrap();
-            assert!(matches!(role, "input" | "agent" | "tool"), "role enum: {role}");
-            match role {
-                "input" | "agent" => assert!(r.get("text").is_some() && r.get("tool").is_none()),
-                "tool" => {
-                    assert!(r.get("text").is_none());
-                    assert!(r["tool"].get("name").is_some() && r["tool"].get("arg").is_some());
-                }
-                _ => unreachable!(),
-            }
-        }
-    }
-}
diff --git a/tools/claude-spt/src/digest_omp.rs b/tools/claude-spt/src/digest_omp.rs
deleted file mode 100644
index e2e27f3..0000000
--- a/tools/claude-spt/src/digest_omp.rs
+++ /dev/null
@@ -1,366 +0,0 @@
-//! `claude-spt digest-omp` — the omp-spt `[digest]` extractor (S3).
-//!
-//! Maps oh-my-pi's native session JSONL → the SAME published digest-record contract the CC extractor
-//! (digest.rs) emits: NDJSON, one `{"role","text"?,"tool"?,"ts"?}` object per stdout line, `role` ∈
-//! `input | agent | tool`. spt-core's digest renderer applies the presentation defaults
-//! (window_turns / arg_truncation / sprint_collapse); this emits RAW records. The `rec()` contract
-//! emitter is shared with digest.rs so the two adapters can never drift.
-//!
-//! ## omp session JSONL (verified against omp v16.3.11 real session files)
-//!
-//! One JSON object per line. Entry `type`s: `title`, `session` (the header — NOT guaranteed line 1;
-//! a `title` precedes it), `model_change`, `thinking_level_change`, `message`, `custom` /
-//! `custom_message` (tool results / lifecycle ride here). Only `message` entries carry conversation.
-//! A message entry: `{type:"message", id, parentId, timestamp, message:{role, content, …}}`. Roles
-//! seen: `user`, `assistant`. `content` is an array of parts:
-//!   • `{type:"text", text}`                        → conversation text
-//!   • `{type:"toolCall", id, name, arguments:{…}}` → a tool invocation (omp's tool-call shape;
-//!                                                    NOT the provider-payload `function_call`)
-//!   • `{type:"thinking"|"reasoning"|"summary_text"|…}` → dropped (not digest-salient)
-//!
-//! ## Mapping (omp entry → digest record)
-//!   role=user,      content[].type=text      → {role:input, text, ts}
-//!   role=assistant, content[].type=text      → {role:agent, text, ts}
-//!   role=assistant, content[].type=toolCall  → {role:tool,  tool:{name,arg}, ts}
-//!   everything else (thinking/reasoning/session/custom/…) → skipped
-//! `ts` = the entry-level `timestamp` (ISO-8601). [impl->REQ-DIST-DIGEST-EXTRACTOR]
-//!
-//! ## Invocation
-//!   Fetcher (daemon): `claude-spt digest-omp --session {session_id}` — LOCATES the session file by
-//!   id under the omp sessions root (default `~/.omp/agent/sessions`, override `--session-dir`),
-//!   searching for `*_<session_id>.jsonl` across the `<dir-encoded>` subdirs (so the exact
-//!   dir-encoding rule need not be reproduced — locate-by-id, as CC's digest.rs does).
-//!   Proof: `spt adapter digest-proof omp-spt --sample <file>` passes the file via `--in` (read
-//!   as-is, never located). stdout is UTF-8 (the Windows cp1252 trap from the tips doc).
-
-use crate::digest::{rec, scalar_str};
-use serde_json::Value;
-use std::fs::File;
-use std::io::{self, BufRead, BufReader, BufWriter, Write};
-use std::path::{Path, PathBuf};
-use std::process::ExitCode;
-
-/// Salient-arg preference for an omp `toolCall.arguments` object. `i` (omp's per-call intent blurb)
-/// is the most digest-meaningful when present; then the concrete target keys, mirroring digest.rs's
-/// CC ARG_KEYS. Falls back (in `tool_arg`) to the first scalar, then compact JSON.
-const ARG_KEYS: &[&str] = &[
-    "path", "command", "pattern", "query", "url", "prompt", "file_path", "i", "description",
-];
-
-fn tool_arg(arguments: &Value) -> String {
-    let obj = match arguments.as_object() {
-        Some(o) => o,
-        None => return String::new(),
-    };
-    for k in ARG_KEYS {
-        if let Some(s) = obj.get(*k).and_then(scalar_str) {
-            if !s.is_empty() {
-                return s;
-            }
-        }
-    }
-    for v in obj.values() {
-        if let Some(s) = scalar_str(v) {
-            if !s.is_empty() {
-                return s;
-            }
-        }
-    }
-    serde_json::to_string(arguments).unwrap_or_default()
-}
-
-/// Read omp JSONL from `reader`, write digest NDJSON to `writer`. Pure over byte streams so it is
-/// directly unit-testable without the filesystem (mirrors digest.rs::extract).
-fn extract<R: BufRead, W: Write>(reader: R, mut writer: W) -> io::Result<()> {
-    for line in reader.lines() {
-        let line = line?;
-        let line = line.trim();
-        if line.is_empty() {
-            continue;
-        }
-        let o: Value = match serde_json::from_str(line) {
-            Ok(v) => v,
-            Err(_) => continue, // omp's log is well-formed; a stray line is not ours to emit
-        };
-        if o.get("type").and_then(Value::as_str) != Some("message") {
-            continue; // title / session / model_change / custom / … — not conversation
-        }
-        let ts = o.get("timestamp").and_then(Value::as_str);
-        let msg = match o.get("message").and_then(Value::as_object) {
-            Some(m) => m,
-            None => continue,
-        };
-        // Role-keyed mapping. `toolResult` is omp's DEDICATED role for tool output (carries
-        // toolCallId/toolName) — dropped here, matching CC's skip of tool_result (else the digest
-        // floods with tool stdout). `system`/anything else is likewise not conversation.
-        let role = msg.get("role").and_then(Value::as_str).unwrap_or("");
-        let out_role = match role {
-            "user" => "input",
-            "assistant" => "agent",
-            _ => continue, // toolResult / system / … — not digest conversation
-        };
-        let content = msg.get("content");
-
-        // A user turn may (rarely) carry a bare string; normally it is a text-part array.
-        if let Some(s) = content.and_then(Value::as_str) {
-            if !s.is_empty() {
-                writeln!(writer, "{}", rec(out_role, Some(s), None, ts))?;
-            }
-            continue;
-        }
-        let parts = match content.and_then(Value::as_array) {
-            Some(p) => p,
-            None => continue,
-        };
-        for it in parts {
-            match it.get("type").and_then(Value::as_str) {
-                Some("text") => {
-                    if let Some(t) = it.get("text").and_then(Value::as_str) {
-                        if !t.is_empty() {
-                            writeln!(writer, "{}", rec(out_role, Some(t), None, ts))?;
-                        }
-                    }
-                }
-                // A tool invocation is only meaningful on the assistant turn.
-                Some("toolCall") if role == "assistant" => {
-                    let name = it.get("name").and_then(Value::as_str).unwrap_or("");
-                    let arg = it.get("arguments").map(tool_arg).unwrap_or_default();
-                    let tool = serde_json::json!({"name": name, "arg": arg});
-                    writeln!(writer, "{}", rec("tool", None, Some(tool), ts))?;
-                }
-                _ => {} // thinking / reasoning / summary_text / path / url / … — dropped
-            }
-        }
-    }
-    writer.flush()
-}
-
-/// omp's session store root: `--session-dir` override → `$HOME/.omp/agent/sessions`.
-/// Shared with the history-omp fetcher and the echo-commune-omp self-locate.
-pub(crate) fn sessions_root(session_dir: Option<&str>) -> PathBuf {
-    if let Some(d) = session_dir {
-        return PathBuf::from(d);
-    }
-    let home = std::env::var("HOME")
-        .or_else(|_| std::env::var("USERPROFILE"))
-        .unwrap_or_default();
-    PathBuf::from(home).join(".omp").join("agent").join("sessions")
-}
-
-/// Locate a session file by id under `root`: the filename is `<timestamp>_<sessionId>.jsonl` across
-/// `<dir-encoded>` subdirs, so we match `*_<id>.jsonl` (exact), else an `<id>`-prefix on the id part
-/// (omp resumes by id prefix too). Returns the first match (one session id is unique per node).
-/// Shared with the history-omp fetcher and the echo-commune-omp self-locate.
-pub(crate) fn locate(root: &Path, session_id: &str) -> Option<PathBuf> {
-    let suffix_exact = format!("_{session_id}.jsonl");
-    let mut prefix_hit: Option<PathBuf> = None;
-    let dirs = std::fs::read_dir(root).ok()?;
-    for d in dirs.flatten() {
-        let sub = d.path();
-        if !sub.is_dir() {
-            // sessions may also sit directly under root (e.g. a --session-dir run)
-            if let Some(hit) = match_in_dir(root, &suffix_exact, session_id, &mut prefix_hit) {
-                return Some(hit);
-            }
-            continue;
-        }
-        if let Some(hit) = match_in_dir(&sub, &suffix_exact, session_id, &mut prefix_hit) {
-            return Some(hit);
-        }
-    }
-    prefix_hit
-}
-
-/// Scan one directory for `*_<id>.jsonl`; returns an exact suffix match immediately, else records an
-/// id-prefix match into `prefix_hit` (used only if no exact match exists anywhere).
-fn match_in_dir(
-    dir: &Path,
-    suffix_exact: &str,
-    session_id: &str,
-    prefix_hit: &mut Option<PathBuf>,
-) -> Option<PathBuf> {
-    let entries = std::fs::read_dir(dir).ok()?;
-    for e in entries.flatten() {
-        let p = e.path();
-        let name = match p.file_name().and_then(|n| n.to_str()) {
-            Some(n) => n,
-            None => continue,
-        };
-        if !name.ends_with(".jsonl") {
-            continue;
-        }
-        if name.ends_with(suffix_exact) {
-            return Some(p);
-        }
-        // id-prefix fallback: filename `<ts>_<idpart>.jsonl`, match on the id part.
-        if prefix_hit.is_none() {
-            if let Some(idpart) = name.rsplit('_').next().and_then(|s| s.strip_suffix(".jsonl")) {
-                if idpart.starts_with(session_id) {
-                    *prefix_hit = Some(p.clone());
-                }
-            }
-        }
-    }
-    None
-}
-
-pub fn run() -> ExitCode {
-    let mut session: Option<String> = None;
-    let mut session_dir: Option<String> = None;
-    let mut in_file: Option<String> = None;
-    let mut it = std::env::args().skip(2); // skip binary + "digest-omp"
-    while let Some(a) = it.next() {
-        match a.as_str() {
-            "--session" => session = it.next(),
-            "--session-dir" => session_dir = it.next(),
-            "--in" => in_file = it.next(),
-            "-h" | "--help" => {
-                println!("claude-spt digest-omp --session <id> [--session-dir <dir>] [--in <logfile>]");
-                return ExitCode::SUCCESS;
-            }
-            // Tolerate stray flags a mid-update manifest might still pass (e.g. --config-dir): consume
-            // a following value if present, so it is not misread as positional.
-            other if other.starts_with("--") => {
-                if let Some(peek) = it.next() {
-                    let _ = peek; // value swallowed; unknown flag ignored
-                }
-            }
-            _ => {}
-        }
-    }
-
-    // Resolve the input: an explicit --in (digest-proof --sample) wins; else locate by session id.
-    let path: PathBuf = if let Some(f) = in_file {
-        PathBuf::from(f)
-    } else {
-        let id = match session.as_deref() {
-            Some(s) if !s.is_empty() => s,
-            _ => {
-                eprintln!("claude-spt digest-omp: need --session <id> or --in <logfile>");
-                return ExitCode::from(2);
-            }
-        };
-        let root = sessions_root(session_dir.as_deref());
-        match locate(&root, id) {
-            Some(p) => p,
-            None => {
-                eprintln!("claude-spt digest-omp: no session file for '{id}' under {}", root.display());
-                return ExitCode::FAILURE;
-            }
-        }
-    };
-
-    let file = match File::open(&path) {
-        Ok(f) => f,
-        Err(e) => {
-            eprintln!("claude-spt digest-omp: cannot open {}: {e}", path.display());
-            return ExitCode::FAILURE;
-        }
-    };
-    let stdout = io::stdout();
-    let writer = BufWriter::new(stdout.lock());
-    match extract(BufReader::new(file), writer) {
-        Ok(()) => ExitCode::SUCCESS,
-        Err(e) => {
-            eprintln!("claude-spt digest-omp: {e}");
-            ExitCode::FAILURE
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn run_extract(lines: &[&str]) -> Vec<Value> {
-        let input = lines.join("\n");
-        let mut out = Vec::new();
-        extract(BufReader::new(input.as_bytes()), &mut out).unwrap();
-        String::from_utf8(out)
-            .unwrap()
-            .lines()
-            .map(|l| serde_json::from_str(l).unwrap())
-            .collect()
-    }
-
-    #[test]
-    fn user_text_becomes_input() {
-        let recs = run_extract(&[
-            r#"{"type":"message","timestamp":"2026-07-09T06:52:57.496Z","message":{"role":"user","content":[{"type":"text","text":"Reply with exactly: ok"}],"attribution":"user"}}"#,
-        ]);
-        assert_eq!(recs.len(), 1);
-        assert_eq!(recs[0]["role"], "input");
-        assert_eq!(recs[0]["text"], "Reply with exactly: ok");
-        assert_eq!(recs[0]["ts"], "2026-07-09T06:52:57.496Z");
-    }
-
-    #[test]
-    fn tool_result_role_is_skipped() {
-        // omp feeds tool output back as a DEDICATED role:"toolResult" message (with toolCallId) —
-        // it must not pollute the digest as input (parity with CC skipping tool_result).
-        let recs = run_extract(&[
-            r#"{"type":"message","message":{"role":"toolResult","toolCallId":"call_x","toolName":"read","content":[{"type":"text","text":"file contents blob"}]}}"#,
-        ]);
-        assert!(recs.is_empty());
-    }
-
-    #[test]
-    fn assistant_text_becomes_agent() {
-        let recs = run_extract(&[
-            r#"{"type":"message","message":{"role":"assistant","content":[{"type":"thinking","thinking":"x"},{"type":"text","text":"ok"}]}}"#,
-        ]);
-        assert_eq!(recs.len(), 1);
-        assert_eq!(recs[0]["role"], "agent");
-        assert_eq!(recs[0]["text"], "ok");
-    }
-
-    #[test]
-    fn assistant_toolcall_becomes_tool_with_salient_arg() {
-        let recs = run_extract(&[
-            r#"{"type":"message","message":{"role":"assistant","content":[{"type":"toolCall","id":"call_x|fc_y","name":"read","arguments":{"i":"Reading root catalog","path":"index.md:1-220"}}]}}"#,
-        ]);
-        assert_eq!(recs.len(), 1);
-        assert_eq!(recs[0]["role"], "tool");
-        assert_eq!(recs[0]["tool"]["name"], "read");
-        assert_eq!(recs[0]["tool"]["arg"], "index.md:1-220"); // path preferred over intent `i`
-    }
-
-    #[test]
-    fn toolcall_arg_falls_back_to_intent_when_no_target() {
-        let recs = run_extract(&[
-            r#"{"type":"message","message":{"role":"assistant","content":[{"type":"toolCall","name":"think","arguments":{"i":"planning next step"}}]}}"#,
-        ]);
-        assert_eq!(recs[0]["tool"]["arg"], "planning next step");
-    }
-
-    #[test]
-    fn header_and_lifecycle_entries_are_skipped() {
-        let recs = run_extract(&[
-            r#"{"type":"title","v":1,"title":""}"#,
-            r#"{"type":"session","version":3,"id":"019f45a6","cwd":"C:\\x"}"#,
-            r#"{"type":"model_change","model":"openrouter/openai/gpt-5.5"}"#,
-            r#"{"type":"thinking_level_change","thinkingLevel":"off"}"#,
-            r#"{"type":"custom","customType":"session_exit","data":{}}"#,
-        ]);
-        assert!(recs.is_empty());
-    }
-
-    #[test]
-    fn multi_part_assistant_emits_text_then_tool_in_order() {
-        let recs = run_extract(&[
-            r#"{"type":"message","message":{"role":"assistant","content":[{"type":"text","text":"let me look"},{"type":"toolCall","name":"glob","arguments":{"pattern":"**/*.rs"}}]}}"#,
-        ]);
-        assert_eq!(recs.len(), 2);
-        assert_eq!(recs[0]["role"], "agent");
-        assert_eq!(recs[0]["text"], "let me look");
-        assert_eq!(recs[1]["role"], "tool");
-        assert_eq!(recs[1]["tool"]["name"], "glob");
-        assert_eq!(recs[1]["tool"]["arg"], "**/*.rs");
-    }
-
-    #[test]
-    fn stray_and_empty_lines_are_tolerated() {
-        let recs = run_extract(&["", "not json", r#"{"type":"message"}"#]);
-        assert!(recs.is_empty());
-    }
-}
diff --git a/tools/claude-spt/src/echo_commune.rs b/tools/claude-spt/src/echo_commune.rs
deleted file mode 100644
index fd87f27..0000000
--- a/tools/claude-spt/src/echo_commune.rs
+++ /dev/null
@@ -1,427 +0,0 @@
-//! `claude-spt echo-commune` — the `[session.echo_commune]` bounded summarizer
-//! ([impl->REQ-SESSION-ECHO-COMMUNE]).
-//!
-//! Published contract: "when a session ends without a signoff, spt-core runs a bounded
-//! summarizer over the session's history so the context delta is captured anyway"; core
-//! 0.27/0.28 also spawns it from the commune-sync per-event turn (flynn 2026-07-07 field pin —
-//! a missing role 3-strikes the whole psyche host).
-//!
-//! One invocation = one bounded turn, run to completion (the psyche-shim shape):
-//!   1. INPUT — the session history arrives on STDIN (core feeds the `[history]` fetcher's
-//!      output verbatim, per the contract's "[history] … feeds the echo-commune"). When stdin
-//!      is EMPTY the shim self-locates the transcript (`--session-id` through the digest locate
-//!      machinery) — a blind-build hedge: the exact core-side history→stdin wiring is not
-//!      published (docs-gap filed), and the shim must produce a delta under EITHER wiring.
-//!   2. BOUND — take the transcript TAIL (whole JSONL lines, ~48KB cap): the delta lives at the
-//!      end of a session; an unbounded transcript would blow the summarizer turn's context.
-//!   3. TURN — one headless `claude -p` with the summarization directive + the tail on stdin.
-//!      Psyche-parity sandbox (REQ-HAZARD-PSYCHE-PERMS-DEADLOCK: skip-permissions is REQUIRED
-//!      non-interactively) but Read-ONLY tools — a summarizer never writes. No --resume /
-//!      --session-id: a throwaway turn, no custody, no sid to mint or keep.
-//!   4. OUTPUT — claude's stdout IS the context delta; core ingests it. Empty output or any
-//!      claude failure = loud `ECHO_COMMUNE_FAIL:` + exit 1 (never a silent vacuous delta).
-//!
-//! The role table carries `recursion_guard_env = "SPT_ECHO_COMMUNE"`: core sets it on THIS
-//! process; the claude we spawn inherits it, and the hook binary bails when it is set — the
-//! summarizer's inner session can never seed/bind/rebind a perch (hook.rs guard, same REQ).
-
-use std::io::{Read, Write};
-use std::process::{Command, ExitCode, Stdio};
-
-/// Bound on the history tail fed to the turn. Whole lines only — a JSONL record split mid-line
-/// reads as garbage. [impl->REQ-SESSION-ECHO-COMMUNE]
-const TAIL_CAP_BYTES: usize = 48 * 1024;
-
-struct Args {
-    id: String,
-    session_id: String,
-}
-
-impl Args {
-    /// Parse `--id V --session-id V`. Both required, single-value, order-independent —
-    /// the psyche shim's parser discipline. [impl->REQ-SESSION-ECHO-COMMUNE]
-    fn parse<I: IntoIterator<Item = String>>(argv: I) -> Result<Args, String> {
-        let (mut id, mut session_id) = (None, None);
-        let mut it = argv.into_iter();
-        while let Some(a) = it.next() {
-            match a.as_str() {
-                "--id" => id = Some(it.next().ok_or("--id expects a value")?),
-                "--session-id" => {
-                    session_id = Some(it.next().ok_or("--session-id expects a value")?)
-                }
-                other => return Err(format!("unknown arg: {other}")),
-            }
-        }
-        Ok(Args {
-            id: id.ok_or("missing --id")?,
-            session_id: session_id.ok_or("missing --session-id")?,
-        })
-    }
-}
-
-/// The whole-line tail of `history`, capped at `cap` bytes. Cuts ONLY at line boundaries: when
-/// the cap lands mid-line the partial first line is dropped (a truncated JSONL record is noise,
-/// not signal). Pure. [impl->REQ-SESSION-ECHO-COMMUNE]
-fn bounded_tail(history: &str, cap: usize) -> &str {
-    if history.len() <= cap {
-        return history;
-    }
-    let start = history.len() - cap;
-    // Snap forward to the first line START at/after `start` (skip the cut-open line).
-    match history[start..].find('\n') {
-        Some(nl) => &history[start + nl + 1..],
-        None => "", // one giant unterminated line — nothing whole to keep
-    }
-}
-
-/// The summarization directive fed ABOVE the history tail. Asks for a commune-shaped context
-/// delta (what /sptc:commune authors by hand) — current task + status, decisions, next steps —
-/// because core ingests this stdout into the SAME tracked-mind tiers a real commune lands in. The
-/// delta is SLICED into `<project-context>` (this-project detail) vs `<live-context>` (cross-project
-/// / role standing context) so core routes each to the right durable tier; untagged text defaults to
-/// the live tier, which is why an unsliced summary pollutes the durable identity with project noise.
-/// [impl->REQ-SESSION-ECHO-COMMUNE] [impl->REQ-COMMUNE-CONTEXT-TIER-SLICING]
-fn compose_prompt(id: &str, tail: &str) -> String {
-    format!(
-        "You are the echo-commune summarizer for spt agent \"{id}\" — the session below ended \
-         without a signoff, and your summary is the context delta that survives it.\n\
-         The input is the tail of a Claude Code session transcript (JSONL, one event per line).\n\
-         Write a concise commune-style context delta in markdown: current task + status, \
-         decisions made, and immediate next steps. State facts from the transcript only — no \
-         speculation, no preamble, no closing remarks.\n\
-         Slice the delta so spt routes each part to the right durable tier: put everything specific \
-         to THIS project (its task, files, and decisions) inside \
-         <project-context>…</project-context>, and any cross-project, role, or standing-identity \
-         context inside <live-context>…</live-context>. Untagged text defaults to the live tier, so \
-         tag project-specific detail to keep it out of the durable identity. Output the sliced delta \
-         and nothing else.\n\
-         \n\
-         ---- transcript tail ----\n\
-         {tail}"
-    )
-}
-
-/// Sandbox flags for the summarizer turn — psyche parity (claude_skill_owl lineage) with the
-/// tool surface narrowed to Read: a summarizer consumes its stdin and writes NOTHING.
-/// `--dangerously-skip-permissions` stays REQUIRED (REQ-HAZARD-PSYCHE-PERMS-DEADLOCK: a
-/// non-interactive turn + an interactive permission prompt = hang).
-/// [impl->REQ-SESSION-ECHO-COMMUNE]
-fn sandbox_flags() -> Vec<String> {
-    [
-        "--model", "sonnet",
-        "--fallback-model", "opus",
-        "--effort", "medium",
-        "--dangerously-skip-permissions",
-        "--disable-slash-commands",
-        "--tools", "Read",
-    ]
-    .iter()
-    .map(|s| (*s).to_string())
-    .collect()
-}
-
-/// Where the turn's history comes from: stdin when core piped it, else self-locate the
-/// transcript by session id. Pure over the already-read stdin content so the fork is
-/// unit-testable. (Field pin 2026-07-07, doyle: core does NOT stdin-feed [history] today — the
-/// stdin rung is kept for the future published wiring; self-locate is the live path.)
-/// [impl->REQ-SESSION-ECHO-COMMUNE]
-#[derive(Debug, PartialEq)]
-enum InputPlan {
-    FromStdin,
-    SelfLocate,
-}
-
-fn input_plan(stdin_content: &str) -> InputPlan {
-    if stdin_content.trim().is_empty() {
-        InputPlan::SelfLocate
-    } else {
-        InputPlan::FromStdin
-    }
-}
-
-fn fail_line(id: &str, cause: &str) -> String {
-    format!("ECHO_COMMUNE_FAIL:{id}: {cause}")
-}
-
-/// The perch's captured CLAUDE_CONFIG_DIR out of its info.json `read_env` — THE authoritative
-/// config root for a ccs-relocated session (doyle-sanctioned source, 2026-07-07 field RCA: the
-/// role spawn does not inherit the session env, so the env rung alone missed every ccs
-/// transcript and the psyche host 3-strike-latched on locate-miss). Pure over the JSON text.
-/// [impl->REQ-SESSION-ECHO-COMMUNE]
-fn read_env_config_dir(info_json: &str) -> Option<String> {
-    let v: serde_json::Value = serde_json::from_str(info_json).ok()?;
-    let dir = v.get("read_env")?.get("CLAUDE_CONFIG_DIR")?.as_str()?;
-    (!dir.is_empty()).then(|| dir.to_string())
-}
-
-/// The perch's info.json path: $SPT_HOME/owlery/<id>/info.json, else the platform default core
-/// state dir (%LOCALAPPDATA%\spt-core on Windows). Best-effort — None just skips the rung.
-fn owlery_info_path(id: &str) -> Option<std::path::PathBuf> {
-    let base = std::env::var_os("SPT_HOME")
-        .map(std::path::PathBuf::from)
-        .or_else(|| std::env::var_os("LOCALAPPDATA").map(|l| std::path::PathBuf::from(l).join("spt-core")))?;
-    Some(base.join("owlery").join(id).join("info.json"))
-}
-
-/// Every ccs instance's config root (`~/.ccs/instances/<account>`) — the last-ditch sweep rung:
-/// a ccs-launched session's transcripts live under its instance root, unreachable from
-/// ~/.claude. Best-effort; empty when ~/.ccs is absent.
-fn ccs_instance_roots() -> Vec<std::path::PathBuf> {
-    let instances = crate::digest::expand_tilde("~/.ccs/instances");
-    let Ok(entries) = std::fs::read_dir(&instances) else { return Vec::new() };
-    entries
-        .flatten()
-        .map(|e| e.path())
-        .filter(|p| p.is_dir())
-        .collect()
-}
-
-/// The endpoint's authoritative CLAUDE_CONFIG_DIR: the perch's info.json `read_env` capture
-/// (ccs truth for THIS endpoint), else our own env. None = stock ~/.claude session. Feeds BOTH
-/// the transcript locate rungs AND the spawned claude's env — the role spawn does not inherit
-/// the session env, so without this the summarizer claude runs against the WRONG config root
-/// (no ccs auth/config) and dies at spawn: `ECHO_COMMUNE_FAIL: claude exited exit code: 1`,
-/// doyle field pin 2026-07-07, the second latch class. [impl->REQ-SESSION-ECHO-COMMUNE]
-fn resolve_config_root(id: &str) -> Option<String> {
-    if let Some(info) = owlery_info_path(id).and_then(|p| std::fs::read_to_string(p).ok()) {
-        if let Some(dir) = read_env_config_dir(&info) {
-            return Some(dir);
-        }
-    }
-    std::env::var("CLAUDE_CONFIG_DIR").ok().filter(|v| !v.is_empty())
-}
-
-/// Self-locate the transcript across every rung, most-authoritative first:
-///   1. the endpoint's resolved config root (perch read_env, else env) — see resolve_config_root
-///   2. ~/.claude/projects (the stock root)
-///   3. every ~/.ccs/instances/<account>/projects (sweep — wrong-account hit beats no delta)
-/// [impl->REQ-SESSION-ECHO-COMMUNE]
-fn self_locate(config_root: Option<&str>, session_id: &str) -> Option<String> {
-    let mut roots: Vec<std::path::PathBuf> = Vec::new();
-    if let Some(dir) = config_root {
-        roots.push(std::path::PathBuf::from(dir).join("projects"));
-    }
-    roots.push(crate::digest::expand_tilde("~/.claude").join("projects"));
-    roots.extend(ccs_instance_roots().into_iter().map(|r| r.join("projects")));
-
-    for root in roots {
-        if !root.is_dir() {
-            continue;
-        }
-        if let Some(path) = crate::digest::locate(&root, session_id) {
-            if let Ok(body) = std::fs::read_to_string(path) {
-                return Some(body);
-            }
-        }
-    }
-    None
-}
-
-/// The graceful no-transcript delta: emitted on stdout with EXIT 0 when every locate rung
-/// misses. WHY exit 0: a nonzero here rides the psyche host's 3-strike budget, and a locate-miss
-/// is an ordinary condition (fresh session, purged transcript) — the 2026-07-07 field regression
-/// LATCHED doyle's and perri's psyche hosts on exactly this. The miss stays visible (this marker
-/// is the ingested delta + a stderr breadcrumb); only real faults (claude spawn/turn failures)
-/// stay nonzero. [impl->REQ-SESSION-ECHO-COMMUNE]
-fn no_transcript_delta(id: &str, session_id: &str) -> String {
-    format!(
-        "(echo-commune: no transcript located for session {session_id} of {id} — no context delta captured for this reset)"
-    )
-}
-
-/// Run claude once: prompt on stdin, stdout captured (the delta), stderr captured (the fail
-/// surface). The inherited env rides through UNTOUCHED — core set SPT_ECHO_COMMUNE on us and
-/// the child claude must inherit it so ITS hooks bail (the recursion guard's whole mechanism) —
-/// EXCEPT the endpoint's CLAUDE_CONFIG_DIR, which is SET explicitly: the role spawn's env lacks
-/// the ccs instance root, and a bare-env claude has no auth/config there → immediate exit 1
-/// (doyle field pin 2026-07-07, the post-locate-fix latch class). [impl->REQ-SESSION-ECHO-COMMUNE]
-fn run_claude(prompt: &str, config_root: Option<&str>) -> std::io::Result<std::process::Output> {
-    let mut c = Command::new("claude");
-    c.arg("-p")
-        .args(sandbox_flags())
-        .stdin(Stdio::piped())
-        .stdout(Stdio::piped())
-        .stderr(Stdio::piped());
-    if let Some(dir) = config_root {
-        c.env("CLAUDE_CONFIG_DIR", dir);
-    }
-    let mut child = c.spawn()?;
-    child.stdin.take().expect("piped stdin").write_all(prompt.as_bytes())?;
-    child.wait_with_output()
-}
-
-/// `claude-spt echo-commune` entry. [impl->REQ-SESSION-ECHO-COMMUNE]
-pub fn run() -> ExitCode {
-    let args = match Args::parse(std::env::args().skip(2)) {
-        Ok(a) => a,
-        Err(e) => {
-            eprintln!("ECHO_COMMUNE_FAIL: {e}");
-            return ExitCode::FAILURE;
-        }
-    };
-
-    let mut stdin_content = String::new();
-    let _ = std::io::stdin().read_to_string(&mut stdin_content);
-
-    // Resolved ONCE: feeds both the transcript locate and the spawned claude's env.
-    let config_root = resolve_config_root(&args.id);
-
-    let history = match input_plan(&stdin_content) {
-        InputPlan::FromStdin => stdin_content,
-        InputPlan::SelfLocate => match self_locate(config_root.as_deref(), &args.session_id) {
-            Some(h) if !h.trim().is_empty() => h,
-            _ => {
-                // Locate-miss is GRACEFUL (exit 0, marker delta) — never a psyche-host strike.
-                // The 2026-07-07 regression latched two psyche hosts on this exact miss.
-                eprintln!(
-                    "ECHO_COMMUNE_NO_TRANSCRIPT:{}: session {} not found under any config root — emitting the no-delta marker (exit 0)",
-                    args.id, args.session_id
-                );
-                print!("{}", no_transcript_delta(&args.id, &args.session_id));
-                let _ = std::io::stdout().flush();
-                return ExitCode::SUCCESS;
-            }
-        },
-    };
-
-    let prompt = compose_prompt(&args.id, bounded_tail(&history, TAIL_CAP_BYTES));
-    match run_claude(&prompt, config_root.as_deref()) {
-        Ok(out) if out.status.success() => {
-            let delta = String::from_utf8_lossy(&out.stdout);
-            if delta.trim().is_empty() {
-                eprintln!("{}", fail_line(&args.id, "claude produced an empty delta"));
-                return ExitCode::FAILURE;
-            }
-            print!("{delta}");
-            let _ = std::io::stdout().flush();
-            ExitCode::SUCCESS
-        }
-        Ok(out) => {
-            let stderr = String::from_utf8_lossy(&out.stderr);
-            eprintln!(
-                "{}",
-                fail_line(&args.id, &format!("claude exited {}: {}", out.status, stderr.trim()))
-            );
-            ExitCode::FAILURE
-        }
-        Err(e) => {
-            eprintln!("{}", fail_line(&args.id, &format!("claude spawn failed: {e}")));
-            ExitCode::FAILURE
-        }
-    }
-}
-
-// [unit->REQ-SESSION-ECHO-COMMUNE]
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn argv(parts: &[&str]) -> Vec<String> {
-        parts.iter().map(|s| (*s).to_string()).collect()
-    }
-
-    #[test]
-    fn both_flags_required_order_independent() {
-        let a = Args::parse(argv(&["--session-id", "S", "--id", "I"])).unwrap();
-        assert_eq!(a.id, "I");
-        assert_eq!(a.session_id, "S");
-        assert!(Args::parse(argv(&["--id", "I"])).is_err());
-        assert!(Args::parse(argv(&["--session-id", "S"])).is_err());
-        assert!(Args::parse(argv(&["--id", "I", "--session-id", "S", "--x", "y"])).is_err());
-    }
-
-    #[test]
-    fn stdin_content_drives_the_input_fork() {
-        // Non-empty stdin = core piped the [history] output → use it. Empty/whitespace stdin =
-        // the live wiring today (doyle field pin 2026-07-07: core does NOT stdin-feed) →
-        // self-locate.
-        assert_eq!(input_plan("{\"type\":\"user\"}\n"), InputPlan::FromStdin);
-        assert_eq!(input_plan(""), InputPlan::SelfLocate);
-        assert_eq!(input_plan("  \n \n"), InputPlan::SelfLocate);
-    }
-
-    #[test]
-    fn read_env_config_dir_extracts_the_perch_captured_root() {
-        // The doyle-sanctioned rung: info.json read_env.CLAUDE_CONFIG_DIR is the ccs truth.
-        let info = r#"{"id":"flynn","read_env":{"CLAUDE_CONFIG_DIR":"C:\\Users\\decid\\.ccs\\instances\\bigscreen"}}"#;
-        assert_eq!(
-            read_env_config_dir(info).as_deref(),
-            Some(r"C:\Users\decid\.ccs\instances\bigscreen")
-        );
-        assert_eq!(read_env_config_dir(r#"{"id":"x"}"#), None, "no read_env -> rung skipped");
-        assert_eq!(
-            read_env_config_dir(r#"{"read_env":{"CLAUDE_CONFIG_DIR":""}}"#),
-            None,
-            "empty value -> rung skipped"
-        );
-        assert_eq!(read_env_config_dir("not json"), None, "unreadable -> rung skipped, never a panic");
-    }
-
-    #[test]
-    fn locate_miss_yields_the_graceful_marker_not_a_strike() {
-        // The 2026-07-07 regression: exit-1 on locate-miss rode the psyche host's 3-strike
-        // budget and LATCHED two hosts. The marker is the ingested delta; exit 0 keeps the host.
-        let m = no_transcript_delta("doyle", "5edb9f02-aaaa");
-        assert!(m.contains("doyle") && m.contains("5edb9f02-aaaa"), "names the miss: {m}");
-        assert!(m.starts_with("(echo-commune:"), "self-identifying marker: {m}");
-    }
-
-    #[test]
-    fn self_locate_finds_a_ccs_instance_transcript_via_read_env_rung_shape() {
-        // End-shape check on the rung mechanics: a projects root under a ccs-style config dir
-        // resolves through the same digest locate the [history] fetcher uses.
-        let tmp = std::env::temp_dir().join(format!("ec-ccs-{}", std::process::id()));
-        let slug = tmp.join("projects").join("C--proj-slug");
-        std::fs::create_dir_all(&slug).unwrap();
-        std::fs::write(slug.join("sess-ccs.jsonl"), "{\"type\":\"user\"}\n").unwrap();
-        let root = tmp.join("projects");
-        assert!(
-            crate::digest::locate(&root, "sess-ccs").is_some(),
-            "config-dir/projects rung resolves the ccs transcript"
-        );
-        let _ = std::fs::remove_dir_all(&tmp);
-    }
-
-    #[test]
-    fn tail_bound_cuts_at_line_boundaries_only() {
-        let history = "first line dropped\nsecond\nthird\n";
-        // Cap smaller than the whole → the cut-open first line is DROPPED, whole lines kept.
-        let tail = bounded_tail(history, "second\nthird\n".len() + 3);
-        assert_eq!(tail, "second\nthird\n");
-        // Under the cap → verbatim.
-        assert_eq!(bounded_tail(history, history.len()), history);
-        // One giant unterminated line over the cap → nothing whole to keep.
-        assert_eq!(bounded_tail(&"x".repeat(100), 10), "");
-    }
-
-    #[test]
-    fn prompt_carries_id_directive_and_tail() {
-        let p = compose_prompt("flynn", "{\"type\":\"assistant\"}\n");
-        assert!(p.contains("\"flynn\""), "agent id in the directive");
-        assert!(p.contains("ended \\\n         without a signoff") || p.contains("without a signoff"));
-        assert!(p.ends_with("{\"type\":\"assistant\"}\n"), "tail rides below the directive");
-    }
-
-    // [unit->REQ-COMMUNE-CONTEXT-TIER-SLICING] the summarizer directive teaches the two-slice envelope
-    // so core routes project detail to the project tier (untagged → live tier, the pre-fix pollution).
-    #[test]
-    fn prompt_teaches_context_tier_slicing() {
-        let p = compose_prompt("flynn", "tail\n");
-        assert!(p.contains("<project-context>…</project-context>"), "project slice taught: {p}");
-        assert!(p.contains("<live-context>…</live-context>"), "live slice taught: {p}");
-        assert!(p.contains("defaults to the live tier"), "default-tier rule stated: {p}");
-    }
-
-    #[test]
-    fn summarizer_sandbox_is_read_only_and_never_resumes() {
-        let flags = sandbox_flags();
-        let joined = flags.join(" ");
-        assert!(joined.contains("--tools Read"), "Read-only tool surface: {joined}");
-        assert!(!joined.contains("Write") && !joined.contains("Edit"), "never writes: {joined}");
-        assert!(joined.contains("--dangerously-skip-permissions"), "non-interactive turn");
-        assert!(
-            !joined.contains("--resume") && !joined.contains("--session-id"),
-            "throwaway turn — no custody: {joined}"
-        );
-    }
-}
diff --git a/tools/claude-spt/src/echo_commune_omp.rs b/tools/claude-spt/src/echo_commune_omp.rs
deleted file mode 100644
index 07bfb6d..0000000
--- a/tools/claude-spt/src/echo_commune_omp.rs
+++ /dev/null
@@ -1,218 +0,0 @@
-//! `claude-spt echo-commune-omp` — the omp-spt `[session.echo_commune]` bounded end-of-session
-//! summarizer (S4). Same contract as the CC echo_commune.rs, omp-flavored:
-//!
-//!   1. INPUT — history on stdin when the (future) published wiring feeds it; otherwise SELF-LOCATE
-//!      the omp session JSONL by `--session-id` (digest_omp's locator — the same one the [digest]
-//!      and [history] seams use). A locate-miss is GRACEFUL: a no-delta marker + exit 0 (an exit-1
-//!      here has historically ridden the psyche host's 3-strike budget and latched hosts).
-//!   2. BOUND — the transcript TAIL, whole JSONL lines only, ~48KB cap (the delta lives at the end).
-//!   3. TURN — ONE headless `omp -p` turn: the summarization directive + the tail ride a scratch
-//!      @file (omp ignores a stdin-only prompt — verified; and argv content would hit the win32
-//!      cmdline cap). Read-only sandbox: `--tools read` — a summarizer never writes — plus
-//!      `--no-session` (the summarizer needs no continuity of its own), `--auto-approve`,
-//!      `--thinking off --no-title --no-extensions --no-skills --no-rules` (cheap + deterministic).
-//!   4. OUTPUT — the delta on stdout for core to ingest. An omp fault = loud `ECHO_COMMUNE_FAIL:` +
-//!      exit 1 (never a silent vacuous delta).
-//!
-//! Recursion: the CC shim relies on `SPT_ECHO_COMMUNE` + hook bail to stop summarizer-of-summarizer
-//! loops; the omp path has NO hook layer at all (`--no-extensions`, and an `omp -p` turn runs no spt
-//! code), so the loop cannot form — the guard env is still declared in the manifest for parity.
-//! [impl->REQ-SESSION-ECHO-COMMUNE]
-
-use std::io::Read;
-use std::process::{Command, ExitCode, Stdio};
-
-/// Bound on the history tail fed to the turn (whole lines only — a JSONL record split mid-line
-/// would feed the model malformed JSON). Same cap as the CC shim.
-const TAIL_CAP_BYTES: usize = 48 * 1024;
-
-/// The whole-line tail of `history`, capped at `cap` bytes: when the cap lands mid-line, advance to
-/// the next line boundary so only complete records survive.
-fn bounded_tail(history: &str, cap: usize) -> &str {
-    if history.len() <= cap {
-        return history;
-    }
-    let start = history.len() - cap;
-    match history[start..].find('\n') {
-        Some(nl) => &history[start + nl + 1..],
-        None => "", // one giant line — nothing whole survives the cap
-    }
-}
-
-/// The summarization directive fed ABOVE the history tail (same slicing contract as the CC shim:
-/// `<project-context>` = this-project detail, `<live-context>` = cross-project identity).
-fn compose_prompt(id: &str, tail: &str) -> String {
-    format!(
-        "You are the end-of-session context summarizer for agent '{id}'.\n\
-         The input is the tail of an oh-my-pi (omp) session transcript (JSONL, one event per line).\n\
-         Extract the CONTEXT DELTA this session produced: decisions made, state changed, open\n\
-         threads, and anything a resumed agent must know that it would not already know. Be terse.\n\
-         Slice the delta into two tagged blocks: <project-context>…</project-context> for detail\n\
-         specific to this project/repo, and <live-context>…</live-context> for durable\n\
-         cross-project identity facts. Either block may be empty; emit both tags. Output ONLY the\n\
-         two blocks — no preamble.\n\
-         ---- transcript tail ----\n\
-         {tail}"
-    )
-}
-
-fn fail_line(id: &str, cause: &str) -> String {
-    format!("ECHO_COMMUNE_FAIL:{id}: {cause}")
-}
-
-/// The graceful no-transcript marker (exit 0): core ingests a delta that says "nothing to fold".
-fn no_transcript_delta(id: &str, session_id: &str) -> String {
-    format!(
-        "<project-context></project-context><live-context></live-context>\n\
-         <!-- echo-commune-omp: no omp transcript located for {id} session {session_id}; no delta -->"
-    )
-}
-
-/// omp argv for the one summarizer turn (sans the trailing `@<prompt-file>`).
-fn turn_cmd() -> Vec<String> {
-    [
-        "-p",
-        "--no-session",
-        "--tools", "read",
-        "--auto-approve",
-        "--thinking", "off",
-        "--no-title",
-        "--no-extensions",
-        "--no-skills",
-        "--no-rules",
-    ]
-    .iter()
-    .map(|s| (*s).to_string())
-    .collect()
-}
-
-pub fn run() -> ExitCode {
-    let (mut id, mut session_id) = (None, None);
-    let mut it = std::env::args().skip(2);
-    while let Some(a) = it.next() {
-        match a.as_str() {
-            "--id" => id = it.next(),
-            "--session-id" => session_id = it.next(),
-            other if other.starts_with("--") => {
-                let _ = it.next(); // tolerate stray flags (value swallowed)
-            }
-            _ => {}
-        }
-    }
-    let id = id.unwrap_or_default();
-    let session_id = session_id.unwrap_or_default();
-    if id.is_empty() || session_id.is_empty() {
-        eprintln!("{}", fail_line(&id, "need --id and --session-id"));
-        return ExitCode::FAILURE;
-    }
-
-    // 1. INPUT: stdin when fed (future published wiring); else self-locate the omp session file.
-    let mut history = String::new();
-    let _ = std::io::stdin().read_to_string(&mut history);
-    if history.trim().is_empty() {
-        let root = crate::digest_omp::sessions_root(None);
-        match crate::digest_omp::locate(&root, &session_id) {
-            Some(p) => match std::fs::read_to_string(&p) {
-                Ok(h) => history = h,
-                Err(e) => {
-                    eprintln!("{}", fail_line(&id, &format!("transcript unreadable ({}): {e}", p.display())));
-                    return ExitCode::FAILURE;
-                }
-            },
-            None => {
-                // Graceful locate-miss: no-delta marker, exit 0 (never ride the 3-strike budget).
-                println!("{}", no_transcript_delta(&id, &session_id));
-                return ExitCode::SUCCESS;
-            }
-        }
-    }
-
-    // 2+3. BOUND + TURN via a scratch @file prompt.
-    let prompt = compose_prompt(&id, bounded_tail(&history, TAIL_CAP_BYTES));
-    let prompt_file = std::env::temp_dir().join(format!("omp-spt-echo-{}-{}.md", id, std::process::id()));
-    if let Err(e) = std::fs::write(&prompt_file, &prompt) {
-        eprintln!("{}", fail_line(&id, &format!("cannot write prompt scratch {}: {e}", prompt_file.display())));
-        return ExitCode::FAILURE;
-    }
-    let mut cmd = Command::new(crate::bridge::omp_bin());
-    cmd.args(turn_cmd());
-    cmd.arg(format!("@{}", prompt_file.display()));
-    cmd.stdin(Stdio::null()).stdout(Stdio::piped()).stderr(Stdio::piped());
-    let out = cmd.output();
-    let _ = std::fs::remove_file(&prompt_file); // scratch cleanup, success or fail
-
-    let out = match out {
-        Ok(o) => o,
-        Err(e) => {
-            eprintln!("{}", fail_line(&id, &format!("omp spawn failed: {e}")));
-            return ExitCode::FAILURE;
-        }
-    };
-    if !out.status.success() {
-        let err_text = String::from_utf8_lossy(&out.stderr);
-        eprintln!("{}", fail_line(&id, &format!("omp exited {}: {}", out.status, err_text.trim())));
-        return ExitCode::FAILURE;
-    }
-    // 4. OUTPUT: the delta on stdout (loud-fail on an empty one — a silent vacuous delta hides bugs).
-    let text = String::from_utf8_lossy(&out.stdout);
-    if text.trim().is_empty() {
-        eprintln!("{}", fail_line(&id, "omp produced an empty delta"));
-        return ExitCode::FAILURE;
-    }
-    print!("{text}");
-    ExitCode::SUCCESS
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn tail_under_cap_is_identity() {
-        assert_eq!(bounded_tail("a\nb\nc", 100), "a\nb\nc");
-    }
-
-    #[test]
-    fn tail_cuts_only_at_line_boundaries() {
-        let h = "line-one\nline-two\nline-three";
-        let t = bounded_tail(h, 12); // cap lands mid "line-two"
-        assert_eq!(t, "line-three");
-        assert!(!t.starts_with("ne-two")); // never a mid-line fragment
-    }
-
-    #[test]
-    fn one_giant_line_over_cap_survives_as_empty() {
-        let h = "x".repeat(1000);
-        assert_eq!(bounded_tail(&h, 100), "");
-    }
-
-    #[test]
-    fn prompt_carries_id_directive_and_tail() {
-        let p = compose_prompt("lib", "TAIL-MARKER");
-        assert!(p.contains("agent 'lib'"));
-        assert!(p.contains("<project-context>"));
-        assert!(p.contains("<live-context>"));
-        assert!(p.ends_with("TAIL-MARKER"));
-    }
-
-    #[test]
-    fn no_transcript_delta_is_tagged_and_annotated() {
-        let d = no_transcript_delta("lib", "s1");
-        assert!(d.contains("<project-context></project-context>"));
-        assert!(d.contains("<live-context></live-context>"));
-        assert!(d.contains("s1"));
-    }
-
-    #[test]
-    fn turn_is_readonly_sessionless_and_quiet() {
-        let c = turn_cmd();
-        assert_eq!(c[0], "-p");
-        assert!(c.contains(&"--no-session".to_string()));
-        let ti = c.iter().position(|s| s == "--tools").unwrap();
-        assert_eq!(c[ti + 1], "read"); // a summarizer never writes
-        for flag in ["--auto-approve", "--thinking", "--no-title", "--no-extensions", "--no-skills", "--no-rules"] {
-            assert!(c.contains(&flag.to_string()), "missing {flag}");
-        }
-        assert!(!c.contains(&"-c".to_string()));
-    }
-}
diff --git a/tools/claude-spt/src/history.rs b/tools/claude-spt/src/history.rs
deleted file mode 100644
index 7d524ec..0000000
--- a/tools/claude-spt/src/history.rs
+++ /dev/null
@@ -1,152 +0,0 @@
-//! `claude-spt history` — the `[history]` fetcher ([impl->REQ-HISTORY-FETCHER]).
-//!
-//! The transcript-access seam the published contract describes as "opaque + single-session,
-//! feeds the echo-commune verbatim": locate `<session_id>.jsonl` under the CC projects root
-//! (the SAME locate/precedence machinery as the `[digest]` fetcher — digest.rs owns it) and
-//! stream the file to stdout VERBATIM. Core never parses these bytes; the only consumer is our
-//! own `echo-commune` summarizer, so raw CC JSONL is the interchange format by construction.
-//!
-//! Loud-fail discipline: a missing transcript or missing `--session` exits 1 with a
-//! `HISTORY_FAIL:` stderr line — never a silent-empty stdout (an empty history would flow
-//! downstream into a vacuous echo-commune delta with no trace of why).
-
-use std::io::{self, Write};
-use std::process::ExitCode;
-
-use crate::digest::{expand_tilde, locate, resolve_projects_root};
-
-struct Args {
-    session: Option<String>,
-    config_dir: Option<String>,
-}
-
-/// Parse `--session <id> [--config-dir <claude-config-root>]`. Order-independent single-value
-/// flags, mirroring the digest fetcher's parser. [impl->REQ-HISTORY-FETCHER]
-fn parse_args<I: IntoIterator<Item = String>>(argv: I) -> Result<Args, String> {
-    let mut session = None;
-    let mut config_dir = None;
-    let mut it = argv.into_iter();
-    while let Some(a) = it.next() {
-        match a.as_str() {
-            "--session" => session = it.next(),
-            "--config-dir" => config_dir = it.next(),
-            "-h" | "--help" => {
-                println!("claude-spt history --session <id> [--config-dir <claude-config-root>]");
-                std::process::exit(0);
-            }
-            other => return Err(format!("unknown arg: {other}")),
-        }
-    }
-    Ok(Args { session, config_dir })
-}
-
-/// A literally-unsubstituted manifest fill (`{CLAUDE_CONFIG_DIR}` arriving verbatim because the
-/// spawning core did not fill the key) is treated as ABSENT, so the precedence chain falls
-/// through to `$CLAUDE_CONFIG_DIR` / `~/.claude` instead of globbing a bogus `{...}` path — the
-/// F-013 literal-brace guard class (launch.rs `{node}` precedent). [impl->REQ-HISTORY-FETCHER]
-fn drop_literal_brace(v: Option<String>) -> Option<String> {
-    v.filter(|s| !s.trim_start().starts_with('{'))
-}
-
-/// Resolve the transcript path for `session`: config-dir precedence chain → projects root →
-/// locate the `<session>.jsonl` under it. Pure over its inputs (env read stays in run()).
-fn resolve_transcript(
-    session: &str,
-    config_dir: Option<&str>,
-    env_cfg: Option<&str>,
-) -> Option<std::path::PathBuf> {
-    let cfg = config_dir.map(|c| expand_tilde(c).to_string_lossy().into_owned());
-    let root = resolve_projects_root(cfg.as_deref(), env_cfg, None);
-    if !root.is_dir() {
-        return None;
-    }
-    locate(&root, session)
-}
-
-/// `claude-spt history` entry: locate + stream verbatim. [impl->REQ-HISTORY-FETCHER]
-pub fn run() -> ExitCode {
-    let args = match parse_args(std::env::args().skip(2)) {
-        Ok(a) => a,
-        Err(e) => {
-            eprintln!("HISTORY_FAIL: {e}");
-            return ExitCode::FAILURE;
-        }
-    };
-    let Some(session) = args.session.filter(|s| !s.is_empty()) else {
-        eprintln!("HISTORY_FAIL: missing --session");
-        return ExitCode::FAILURE;
-    };
-    let config_dir = drop_literal_brace(args.config_dir);
-    let env_cfg = std::env::var("CLAUDE_CONFIG_DIR").ok();
-    let Some(path) = resolve_transcript(&session, config_dir.as_deref(), env_cfg.as_deref())
-    else {
-        eprintln!("HISTORY_FAIL: no transcript found for session {session}");
-        return ExitCode::FAILURE;
-    };
-    match std::fs::File::open(&path) {
-        Ok(mut f) => {
-            let stdout = io::stdout();
-            let mut out = stdout.lock();
-            if let Err(e) = io::copy(&mut f, &mut out).and_then(|_| out.flush()) {
-                eprintln!("HISTORY_FAIL: stream {}: {e}", path.display());
-                return ExitCode::FAILURE;
-            }
-            ExitCode::SUCCESS
-        }
-        Err(e) => {
-            eprintln!("HISTORY_FAIL: open {}: {e}", path.display());
-            ExitCode::FAILURE
-        }
-    }
-}
-
-// [unit->REQ-HISTORY-FETCHER]
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn argv(parts: &[&str]) -> Vec<String> {
-        parts.iter().map(|s| (*s).to_string()).collect()
-    }
-
-    #[test]
-    fn parses_session_and_config_dir_order_independent() {
-        let a = parse_args(argv(&["--config-dir", "/cfg", "--session", "S"])).unwrap();
-        assert_eq!(a.session.as_deref(), Some("S"));
-        assert_eq!(a.config_dir.as_deref(), Some("/cfg"));
-    }
-
-    #[test]
-    fn unknown_arg_is_rejected() {
-        assert!(parse_args(argv(&["--session", "S", "--bogus", "x"])).is_err());
-    }
-
-    #[test]
-    fn literal_brace_config_dir_is_treated_as_absent() {
-        // An unfilled `{CLAUDE_CONFIG_DIR}` must fall through the precedence chain, never be
-        // globbed as a path (F-013 literal-brace guard class).
-        assert_eq!(drop_literal_brace(Some("{CLAUDE_CONFIG_DIR}".into())), None);
-        assert_eq!(drop_literal_brace(Some("/real/dir".into())), Some("/real/dir".into()));
-        assert_eq!(drop_literal_brace(None), None);
-    }
-
-    #[test]
-    fn locates_and_would_stream_the_transcript_verbatim() {
-        // resolve_transcript finds <session>.jsonl under a cwd-slug subdir of the config root's
-        // projects dir — the digest locate machinery, reused.
-        let tmp = std::env::temp_dir().join(format!("hist-test-{}", std::process::id()));
-        let slug = tmp.join("projects").join("C--some-cwd-slug");
-        std::fs::create_dir_all(&slug).unwrap();
-        let body = "{\"type\":\"user\"}\n{\"type\":\"assistant\"}\n";
-        std::fs::write(slug.join("sess-1.jsonl"), body).unwrap();
-
-        let hit = resolve_transcript("sess-1", Some(tmp.to_str().unwrap()), None).unwrap();
-        assert_eq!(std::fs::read_to_string(&hit).unwrap(), body, "bytes verbatim");
-
-        assert!(
-            resolve_transcript("sess-missing", Some(tmp.to_str().unwrap()), None).is_none(),
-            "missing session is None -> run() exits loud, never silent-empty"
-        );
-        let _ = std::fs::remove_dir_all(&tmp);
-    }
-}
diff --git a/tools/claude-spt/src/history_omp.rs b/tools/claude-spt/src/history_omp.rs
deleted file mode 100644
index c92ce35..0000000
--- a/tools/claude-spt/src/history_omp.rs
+++ /dev/null
@@ -1,62 +0,0 @@
-//! `claude-spt history-omp` — the omp-spt `[history]` fetcher (S4).
-//!
-//! Contract (same as the CC `history`): locate ONE omp session's JSONL and stream the file to
-//! stdout VERBATIM — opaque bytes, single-session; the only consumer is our own echo-commune
-//! summarizer, so raw omp JSONL is the interchange format by construction. A missing transcript is
-//! `HISTORY_FAIL:` + exit 1, never silent-empty stdout. [impl->REQ-HISTORY-FETCHER]
-//!
-//! Locator = digest_omp's (locate `*_<session_id>.jsonl` by id under the omp sessions root,
-//! default `~/.omp/agent/sessions`, `--session-dir` override) — one locator, two seams, no drift.
-
-use std::io::Write;
-use std::process::ExitCode;
-
-pub fn run() -> ExitCode {
-    let mut session: Option<String> = None;
-    let mut session_dir: Option<String> = None;
-    let mut it = std::env::args().skip(2); // skip binary + "history-omp"
-    while let Some(a) = it.next() {
-        match a.as_str() {
-            "--session" => session = it.next(),
-            "--session-dir" => session_dir = it.next(),
-            "-h" | "--help" => {
-                println!("claude-spt history-omp --session <id> [--session-dir <dir>]");
-                return ExitCode::SUCCESS;
-            }
-            // Tolerate stray flags a mid-update manifest might pass (value swallowed).
-            other if other.starts_with("--") => {
-                let _ = it.next();
-            }
-            _ => {}
-        }
-    }
-    let id = match session.as_deref() {
-        Some(s) if !s.is_empty() => s.to_string(),
-        _ => {
-            eprintln!("HISTORY_FAIL: need --session <id>");
-            return ExitCode::FAILURE;
-        }
-    };
-    let root = crate::digest_omp::sessions_root(session_dir.as_deref());
-    let path = match crate::digest_omp::locate(&root, &id) {
-        Some(p) => p,
-        None => {
-            eprintln!("HISTORY_FAIL: no omp session file for '{id}' under {}", root.display());
-            return ExitCode::FAILURE;
-        }
-    };
-    // Verbatim byte stream — no parsing, no re-encoding.
-    let bytes = match std::fs::read(&path) {
-        Ok(b) => b,
-        Err(e) => {
-            eprintln!("HISTORY_FAIL: cannot read {}: {e}", path.display());
-            return ExitCode::FAILURE;
-        }
-    };
-    let stdout = std::io::stdout();
-    let mut out = stdout.lock();
-    if out.write_all(&bytes).and_then(|()| out.flush()).is_err() {
-        return ExitCode::FAILURE;
-    }
-    ExitCode::SUCCESS
-}
diff --git a/tools/claude-spt/src/hook.rs b/tools/claude-spt/src/hook.rs
deleted file mode 100644
index 01125ea..0000000
--- a/tools/claude-spt/src/hook.rs
+++ /dev/null
@@ -1,2934 +0,0 @@
-//! `claude-spt hook <event>` — the consolidated CC hook handler (D1, ADR-0006 ask #1 →
-//! RESOLVE-NOT-EXECUTE; spt-core v0.16.0).
-//!
-//! Before D1 each Claude Code hook was a hand-written `.sh` wrapper in the cplugs plugin, sourcing a
-//! shared `_common.sh`. That put hook LOGIC in the plugin channel, so every hook change forced a
-//! cplugs republish + `claude plugin update` + `/reload-plugins`. D1 moves ALL hook logic here — a
-//! subcommand of the one consolidated `claude-spt` binary — so it rides `spt adapter update` instead.
-//! The plugin now ships only a STATIC-FOREVER `hooks.json` + a thin `dispatch.sh` that resolves this
-//! binary via the lazily-substituted `[strings].hook_cmd = "{adapter_dir}/claude-spt hook"` and execs
-//! `claude-spt hook <event>` with the CC hook payload on stdin. [impl->REQ-DIST-HOOK-BINARY]
-//!
-//! This is a BEHAVIOUR-PRESERVING refactor of the eight wrappers + `_common.sh`: the same `spt api …`
-//! command lines, the same per-event stdout contract (SessionStart → a `hookSpecificOutput` JSON
-//! line; UserPromptSubmit / PreToolUse → raw rendered additionalContext text), the same
-//! no-op-when-no-perch, the same additionalContext spill guard. The pure helpers (envelope render,
-//! brief assembly, checkpoint parse, …) are pure functions with direct unit tests; every external
-//! effect (spawning `spt`, writing stdout / the spill file / the CC env file, reading env) goes
-//! through the [`HookEnv`] trait so the event handlers are unit-testable with a recorder (call
-//! ordering, no-op gating, emitted output) without spawning anything.
-//!
-//! Usage: `claude-spt hook <CCEventName> [--host-pid <pid>]`  (stdin = the CC hook payload JSON).
-//! `<CCEventName>` is the verbatim CC hook event (SessionStart, UserPromptSubmit, PreToolUse, Stop,
-//! SessionEnd, SubagentStart, SubagentStop, PostToolUse). `--host-pid` is the seed pid the dispatch
-//! wrapper captures (`$PPID`) — Rust std has no portable getppid on Windows, so the wrapper passes it.
-//!
-//! [impl->REQ-DIST-HOOKS-API] [impl->REQ-UPS-INJECTION] [impl->REQ-DIST-SESSIONSTART-BRIEF]
-//! [impl->REQ-DIST-PRETOOL-POLL] [impl->REQ-DIST-CHECKPOINT-COMMUNE] [impl->REQ-DIST-RESUME-CONTEXT]
-//! [impl->REQ-DIST-SKELETON-THIN] [impl->REQ-DIST-SHORTCUT-BASENAME]
-
-use serde_json::Value;
-use std::io::Read;
-use std::process::ExitCode;
-
-/// The adapter_name — distinct from the plugin name `sptc`. Every `spt api` call that targets the
-/// adapter explicitly carries `--adapter claude-spt` (the bind/boundary/state/poll/… verbs); `seed`
-/// is adapter-AGNOSTIC (resolved at bind time from the seed's parent pid via host_binaries).
-const ADAPTER: &str = "claude-spt";
-
-/// Default additionalContext cap — CC spills additionalContext over ~10,000 chars to a file (dropping
-/// it from the inline context the agent sees), so we pre-empt under it with margin. Override via
-/// $SPTC_CTX_CAP (tests). (ADR-0002 Open #2.)
-const DEFAULT_CAP: usize = 9000;
-
-// ─────────────────────────── side-effect surface (testable seam) ───────────────────────────
-
-/// Every external interaction the handlers need. The real [`SysEnv`] spawns `spt`, writes stdout /
-/// files / the CC env file and reads process env; a test recorder records calls and serves canned
-/// `spt` output, so the handlers' logic (ordering, gating, emitted text) is unit-testable offline.
-pub trait HookEnv {
-    /// Run `spt <args>` with optional stdin and extra env vars; return stdout with trailing newlines
-    /// stripped (matching shell `$(…)`), or `None` if `spt` could not be spawned. The exit code is
-    /// IGNORED — every shell wrapper ran its `spt` call with `|| true`, treating any output as the
-    /// result and any failure as empty.
-    fn spt(&mut self, args: &[&str], stdin: Option<&str>, extra_env: &[(&str, &str)]) -> Option<String>;
-    /// Run `spt send …` and return its RESULT TOKEN read from STDOUT **and STDERR** merged (trailing
-    /// newlines stripped), or `None` if `spt` could not be spawned. `spt send` emits its
-    /// `SENT`/`QUEUED`/`DEFERRED`/`NO_PERCH:` status on **stderr**, not stdout (spt-core contract) — so
-    /// the stdout-only [`HookEnv::spt`] sees `""` and misreads every DELIVERED send as unreachable
-    /// (field 2026-07-08: every hook tag-send wrongly confirmed `NO PERCH` though it delivered).
-    /// Classify send outcomes through THIS, never `spt`. [impl->REQ-HAZARD-SEND-STATUS-STDERR]
-    fn spt_send(&mut self, args: &[&str], stdin: Option<&str>) -> Option<String>;
-    /// Run `spt <args>` STRICTLY: Ok(stdout) only on exit 0; Err(diagnostic — stderr text, else the
-    /// exit code, else the spawn error). The boundary rotation path needs the refusal reason
-    /// (`AUTH_REFUSED …` prints on stderr, which [`HookEnv::spt`] discards) to log it loudly — a
-    /// silently-failed rotation strands the perch. [impl->REQ-DIST-BOUNDARY-ROTATE]
-    fn spt_strict(&mut self, args: &[&str]) -> Result<String, String>;
-    /// Write text to CC stdout (the additionalContext channel). Verbatim — no added newline.
-    fn emit(&mut self, text: &str);
-    /// Loud diagnostic to stderr (lands in CC's hook log; never the additionalContext channel).
-    fn log(&mut self, msg: &str);
-    /// Read `<adapter_dir>/<rel>` (the dir holding this binary), trimmed; None when absent/blank.
-    fn read_adapter_state(&self, rel: &str) -> Option<String>;
-    /// Write `<adapter_dir>/<rel>` (parent dirs created); false on any failure.
-    fn write_adapter_state(&mut self, rel: &str, content: &str) -> bool;
-    /// Spill oversized content to `path`; return true on success.
-    fn write_spill(&mut self, path: &str, content: &str) -> bool;
-    /// Read `path` from byte `offset` to EOF (tail-following an append-only transcript). Returns
-    /// `(content, start_used)` — `content` begins at `start_used`, which is `offset` normally or `0`
-    /// when the file is shorter than `offset` (rotated/rewritten → re-read from the top). None when the
-    /// file cannot be opened. The next cursor = `start_used + <bytes of complete lines consumed>`.
-    fn read_file_tail(&self, path: &str, offset: u64) -> Option<(String, u64)>;
-    /// Append a `KEY=value` line to $CLAUDE_ENV_FILE (no-op if unset).
-    fn append_env_file(&mut self, line: &str);
-    /// Read a process environment variable.
-    fn env(&self, key: &str) -> Option<String>;
-    /// The seed pid the dispatch wrapper captured (`--host-pid`).
-    fn host_pid(&self) -> Option<String>;
-    /// $HOME (or %USERPROFILE%) — the spill-path root.
-    fn home(&self) -> String;
-    /// The additionalContext byte cap ($SPTC_CTX_CAP, else [`DEFAULT_CAP`]).
-    fn cap(&self) -> usize;
-}
-
-// ─────────────────────────── pure helpers (direct unit tests) ───────────────────────────
-
-/// Top-level string field of the parsed CC hook object (empty if absent / not a string).
-fn field(v: &Value, key: &str) -> String {
-    v.get(key).and_then(Value::as_str).unwrap_or("").to_string()
-}
-
-/// A field nested one level under `parent` (CC's `tool_input.{file_path,content}`), empty if absent.
-fn nested(v: &Value, parent: &str, key: &str) -> String {
-    v.get(parent).and_then(|p| p.get(key)).and_then(Value::as_str).unwrap_or("").to_string()
-}
-
-/// Decode an spt envelope body to plain text: literal `<br>` → newline, then HTML entities
-/// (`&lt; &gt; &quot;` then `&amp;` LAST, so an embedded `&amp;lt;` does not double-decode). Exactly
-/// the live-agent body-parsing rule (spt-proto::event grammar). [impl->REQ-UPS-INJECTION]
-fn unescape(s: &str) -> String {
-    s.replace("<br>", "\n")
-        .replace("&lt;", "<")
-        .replace("&gt;", ">")
-        .replace("&quot;", "\"")
-        .replace("&amp;", "&") // LAST
-}
-
-/// Value of attribute `name` in an EVENT opening tag (the substring before the first `>`), e.g.
-/// `from="doyle"` → `doyle`. Leading-space-anchored so `from` never matches a substring of another
-/// attribute name. None if absent.
-fn opening_attr(opening: &str, name: &str) -> Option<String> {
-    let key = format!(" {name}=\"");
-    let ki = opening.find(&key)?;
-    let rest = &opening[ki + key.len()..];
-    let end = rest.find('"')?;
-    Some(rest[..end].to_string())
-}
-
-/// Render an `api poll` drain for CC. Canonical format: every message is a self-delimiting
-/// `<EVENT type="msg" from="<sender>">body</EVENT>` envelope (spt-proto::event) — the same grammar
-/// the live listener emits; multi-message drains concatenate. Each becomes a `<sptc_messages>` block
-/// (sender preserved as `from=` for reply-correlation, dropped only when the envelope has none).
-/// Multiple blocks are newline-joined. [unit->REQ-UPS-INJECTION]
-///
-/// A frame truncated mid-frame (opening `<EVENT` with no `>`, or a body with no closing `</EVENT>`)
-/// is NEVER dropped silently: the message was already taken from the spool (delivered=1), so a
-/// silent break here is the §2.8 black-hole family one seam upstream. The dangling arm surfaces the
-/// surviving partial content in a loud <sptc_frame_integrity> marker with a spool-recovery pointer.
-/// [impl->REQ-HAZARD-DANGLING-FRAME-LOUD]
-fn render_frames(raw: &str) -> String {
-    let mut out: Vec<String> = Vec::new();
-    // Head-truncated poll output leaves an ORPHANED frame tail (body + `</EVENT>` with no opening
-    // tag) before the first `<EVENT` — the shape a head-loss produces. Surface it, don't skip it.
-    // [impl->REQ-HAZARD-DANGLING-FRAME-LOUD]
-    let head = &raw[..raw.find("<EVENT").unwrap_or(raw.len())];
-    if head.contains("</EVENT>") {
-        out.push(dangling_frame_marker(&unescape(head)));
-    }
-    let mut rest = raw;
-    while let Some(start) = rest.find("<EVENT") {
-        let after = &rest[start..];
-        let (body_start, close_rel) = match after.find('>') {
-            Some(gt) => match after[gt + 1..].find("</EVENT>") {
-                Some(rel) => (gt + 1, rel),
-                None => {
-                    // Whole remainder, opening tag included — the sender rides `from=` there.
-                    out.push(dangling_frame_marker(&unescape(after)));
-                    break;
-                }
-            },
-            None => {
-                out.push(dangling_frame_marker(after));
-                break;
-            }
-        };
-        let opening = &after[..body_start - 1];
-        let body_raw = &after[body_start..body_start + close_rel];
-        let body = unescape(body_raw);
-        match opening_attr(opening, "from") {
-            Some(s) => out.push(format!("<sptc_messages from=\"{s}\">\n{body}\n</sptc_messages>")),
-            None => out.push(format!("<sptc_messages>\n{body}\n</sptc_messages>")),
-        }
-        let consumed = start + body_start + close_rel + "</EVENT>".len();
-        rest = &rest[consumed..];
-    }
-    out.join("\n")
-}
-
-/// The loud marker for a frame the poll output cut off mid-frame. Carries whatever survived so a
-/// partial head (sender, opening lines) is not lost with the framing, and points at the spool —
-/// the row is still there (`delivered=1` marks the take, not a delete of the body).
-/// [impl->REQ-HAZARD-DANGLING-FRAME-LOUD]
-fn dangling_frame_marker(partial: &str) -> String {
-    format!(
-        "<sptc_frame_integrity bytes=\"{}\">\nA message frame arrived TRUNCATED mid-frame; the partial content below is everything that survived. The full body persists in this perch's spool (owlery/<id>/spool.db, messages table) — recover it from there and report the truncation to the operator.\n{}\n</sptc_frame_integrity>",
-        partial.len(),
-        partial
-    )
-}
-
-/// Extract the skill name from a `/sptc:<skill>` slash-command prompt. UPS fires on a slash-command
-/// with the token intact (ADR-0002 validation); the name is leading-only (after optional whitespace)
-/// so prose merely mentioning `/sptc:x` mid-sentence does not fire. Skill ids are `[a-z][a-z0-9-]*`.
-/// Empty if not a leading sptc slash-command. [unit->REQ-UPS-INJECTION]
-fn skill_key(prompt: &str) -> String {
-    let p = prompt.trim_start_matches([' ', '\t']);
-    let Some(after) = p.strip_prefix("/sptc:") else { return String::new() };
-    let mut chars = after.chars();
-    match chars.next() {
-        Some(c) if c.is_ascii_lowercase() => {}
-        _ => return String::new(),
-    }
-    let mut key = String::new();
-    key.push(after.chars().next().unwrap());
-    for c in after.chars().skip(1) {
-        if c.is_ascii_lowercase() || c.is_ascii_digit() || c == '-' {
-            key.push(c);
-        } else {
-            break;
-        }
-    }
-    key
-}
-
-/// The SessionStart registration verb for this spawn. `clear`/`compact` → `boundary` (rebind the
-/// perch to the new session id within a live session); else `bind` when spt-hosted (the broker
-/// injected $SPT_ENDPOINT_ID — the perch already exists, self-register post-spawn) or `seed` when
-/// harness-hosted (user-launched CC — record an ephemeral seed for /sptc:ready|live).
-/// [impl->REQ-DIST-SHORTCUT-BASENAME]
-fn register_verb(source: &str, endpoint_id_present: bool) -> &'static str {
-    match source {
-        "clear" | "compact" => "boundary",
-        _ if endpoint_id_present => "bind",
-        _ => "seed",
-    }
-}
-
-/// Adapter-state path (relative to the adapter install dir) holding an endpoint's CURRENT session
-/// id — the PRIOR-session auth proof the next `/clear`|`compact` boundary rotation must present as
-/// `--session-id` (the departed session's env file dies with it; an adapter-owned state file is the
-/// only carrier — doyle ruling F024D-BOUNDARY-RULING). The id is sanitized to its filename-safe
-/// alphabet so a hostile/degenerate id can never traverse out of the state dir.
-/// [impl->REQ-DIST-BOUNDARY-ROTATE]
-fn sid_state_rel(endpoint_id: &str) -> String {
-    let safe: String = endpoint_id
-        .chars()
-        .filter(|c| c.is_ascii_alphanumeric() || *c == '-' || *c == '_' || *c == '.')
-        .collect();
-    format!("state/session/{safe}.sid")
-}
-
-/// True for a subagent session (CC sets `agent_type`); those get no SessionStart brief.
-/// [impl->REQ-DIST-SESSIONSTART-BRIEF]
-fn is_subagent(agent_type: &str) -> bool {
-    !agent_type.is_empty()
-}
-
-/// Peer-presence gate for the ring brief: `spt subnet status` output has peers iff it has >1
-/// non-empty line (header + ≥1 subnet row). Line-count only — never parses a column value (the
-/// columnar layout is human-formatted, not a hook contract). [impl->REQ-DIST-SESSIONSTART-BRIEF]
-fn has_peers(subnet_status: &str) -> bool {
-    subnet_status.lines().filter(|l| !l.trim().is_empty()).count() > 1
-}
-
-/// Assemble the identity (perched) block, substituting every `{id}` in the identity body (agent ids
-/// are `[a-z0-9-]`, so plain string replace is safe). [impl->REQ-DIST-SESSIONSTART-BRIEF]
-fn assemble_perch(id: &str, identity_body: &str, messaging_body: &str, roster: &str) -> String {
-    format!(
-        "<sptc-active-perch id=\"{id}\">\n{}\n\n{messaging_body}\n\n{roster}\n</sptc-active-perch>",
-        identity_body.replace("{id}", id)
-    )
-}
-
-/// Assemble the ring (no-perch) block. [impl->REQ-DIST-SESSIONSTART-BRIEF]
-fn assemble_noperch(messaging_body: &str, roster: &str) -> String {
-    format!("<sptc-reach>\n{messaging_body}\n\n{roster}\n</sptc-reach>")
-}
-
-/// JSON-escape a string into a value (no surrounding quotes): `\` then `"` then tab then CR, and
-/// newlines become a literal `\n`. Mirrors the awk escaper so multi-line bodies survive.
-/// [impl->REQ-DIST-SESSIONSTART-BRIEF]
-fn json_escape(s: &str) -> String {
-    let mut out = String::new();
-    for (i, line) in s.split('\n').enumerate() {
-        if i > 0 {
-            out.push_str("\\n");
-        }
-        out.push_str(
-            &line
-                .replace('\\', "\\\\")
-                .replace('"', "\\\"")
-                .replace('\t', "\\t")
-                .replace('\r', "\\r"),
-        );
-    }
-    out
-}
-
-/// The SessionStart `hookSpecificOutput` JSON line carrying `text` as additionalContext, or empty
-/// (no output) when `text` is empty. [impl->REQ-DIST-SESSIONSTART-BRIEF]
-fn emit_additional_context(text: &str) -> String {
-    if text.is_empty() {
-        return String::new();
-    }
-    format!(
-        "{{\"hookSpecificOutput\":{{\"hookEventName\":\"SessionStart\",\"additionalContext\":\"{}\"}}}}\n",
-        json_escape(text)
-    )
-}
-
-/// Append the durable RESUME context below a SessionStart brief, skipping cleanly (brief unchanged,
-/// no trailing newline) when the resume is empty (NO-CONTEXT). [impl->REQ-DIST-RESUME-CONTEXT]
-fn append_resume(brief: &str, resume: &str) -> String {
-    if resume.is_empty() {
-        brief.to_string()
-    } else {
-        format!("{brief}\n{resume}")
-    }
-}
-
-/// Does this commune content carry the checkpoint trigger? [unit->REQ-DIST-CHECKPOINT-COMMUNE]
-fn has_checkpoint(content: &str) -> bool {
-    content.contains("!!checkpoint!!")
-}
-
-/// Extract a CUSTOM wake directive from commune content — the trimmed text between the first PAIR of
-/// `!!checkpoint!!` markers. Empty when there is fewer than one pair (a single marker = default wake,
-/// supplied by the translation binary; none = not a checkpoint). [unit->REQ-DIST-CHECKPOINT-COMMUNE]
-fn checkpoint_wake(content: &str) -> String {
-    const M: &str = "!!checkpoint!!";
-    let Some(first) = content.find(M) else { return String::new() };
-    let after_first = first + M.len();
-    let Some(rel) = content[after_first..].find(M) else { return String::new() };
-    content[after_first..after_first + rel].trim().to_string()
-}
-
-/// Is this tool call a Write to THIS agent's own commune file `<id>-commune.md`? Suffix match
-/// tolerates a JSON-escaped Windows path (doubled backslashes) and either separator.
-/// [unit->REQ-DIST-CHECKPOINT-COMMUNE]
-fn is_commune_write(tool: &str, file_path: &str, id: &str) -> bool {
-    tool == "Write" && !id.is_empty() && file_path.ends_with(&format!("{id}-commune.md"))
-}
-
-/// Build the structured checkpoint self-send payload: a custom wake rides as `wake`, otherwise it is
-/// omitted so the translation binary applies its own default. [impl->REQ-DIST-CHECKPOINT-COMMUNE]
-fn checkpoint_payload(wake: &str) -> String {
-    if wake.is_empty() {
-        "{\"checkpoint\":\"v1\"}".to_string()
-    } else {
-        format!("{{\"checkpoint\":\"v1\",\"wake\":\"{}\"}}", json_escape(wake))
-    }
-}
-
-/// The capped-emit decision (pure). Under the cap → inline verbatim; over → spill the full text and
-/// emit only a pointer marker (never a head-cut that would split a `<sptc_messages>`/`<EVENT>` block
-/// and silently drop a message); empty → no output. [impl->REQ-UPS-INJECTION]
-enum Cap {
-    Empty,
-    Inline(String),
-    Overflow { len: usize },
-}
-
-fn cap_decide(text: &str, cap: usize) -> Cap {
-    if text.is_empty() {
-        Cap::Empty
-    } else if text.len() <= cap {
-        Cap::Inline(text.to_string())
-    } else {
-        Cap::Overflow { len: text.len() }
-    }
-}
-
-/// Emit additionalContext under CC's spill threshold: inline if it fits, else spill the FULL text to
-/// `spill_path` (agent-readable) and emit a concise `<sptc_overflow>` pointer. [impl->REQ-UPS-INJECTION]
-fn emit_capped(env: &mut dyn HookEnv, text: &str, spill_path: &str) {
-    match cap_decide(text, env.cap()) {
-        Cap::Empty => {}
-        Cap::Inline(t) => env.emit(&t),
-        Cap::Overflow { len } => {
-            let path = if env.write_spill(spill_path, text) {
-                spill_path.to_string()
-            } else {
-                "(spill failed; content too large to inline)".to_string()
-            };
-            let cap = env.cap();
-            env.emit(&format!(
-                "<sptc_overflow bytes=\"{len}\" cap=\"{cap}\" spilled_to=\"{path}\">\nDelivery exceeded CC's additionalContext cap. The full content (skill instructions and/or {len} message bytes) was written to the file above — read it now to see everything; it is NOT inlined here to avoid silently dropping a message.\n</sptc_overflow>\n"
-            ));
-        }
-    }
-}
-
-/// The PreToolUse `hookSpecificOutput` JSON envelope. CC DISCARDS plain stdout on PreToolUse —
-/// additionalContext reaches the agent ONLY inside this envelope (unlike UserPromptSubmit, where
-/// raw stdout IS the context channel). The adapter emitted raw text here since the F-021 mid-turn
-/// delivery leg, so every message drained mid-turn was taken (delivered=1) then thrown away by CC:
-/// the 2026-07-07 node-wide silent message black hole (doyle RCA; every claude-spt session
-/// affected). [impl->REQ-HAZARD-PRETOOL-CONTEXT-ENVELOPE]
-fn wrap_pretool_context(text: &str) -> String {
-    if text.is_empty() {
-        return String::new();
-    }
-    format!(
-        "{{\"hookSpecificOutput\":{{\"hookEventName\":\"PreToolUse\",\"additionalContext\":\"{}\"}}}}\n",
-        json_escape(text)
-    )
-}
-
-/// PreToolUse sibling of `emit_capped`: cap-decides on the WRAPPED envelope size (the escaped JSON
-/// is what actually rides stdout — newline-heavy drains can double in size under escaping, so
-/// capping the raw text alone could still blow CC's spill threshold). Over-cap spills the RAW text
-/// (agent-readable file) and sends only a wrapped pointer. [impl->REQ-HAZARD-PRETOOL-CONTEXT-ENVELOPE]
-fn emit_capped_pretool(env: &mut dyn HookEnv, text: &str, spill_path: &str) {
-    if text.is_empty() {
-        return;
-    }
-    let wrapped = wrap_pretool_context(text);
-    if wrapped.len() <= env.cap() {
-        env.emit(&wrapped);
-        return;
-    }
-    let len = text.len();
-    let path = if env.write_spill(spill_path, text) {
-        spill_path.to_string()
-    } else {
-        "(spill failed; content too large to inline)".to_string()
-    };
-    let cap = env.cap();
-    env.emit(&wrap_pretool_context(&format!(
-        "<sptc_overflow bytes=\"{len}\" cap=\"{cap}\" spilled_to=\"{path}\">\nDelivery exceeded CC's additionalContext cap. The full content ({len} message bytes) was written to the file above — read it now to see everything; it is NOT inlined here to avoid silently dropping a message.\n</sptc_overflow>"
-    )));
-}
-
-// ─────────────────────────── impure resolvers (use HookEnv) ───────────────────────────
-
-/// Resolve this session's perch id via `spt whoami --json` (off $OWL_SESSION_ID / $SPT_AGENT_ID).
-/// Empty ⇒ no perch yet (session never readied) ⇒ caller no-ops. The whoami call is given
-/// $OWL_SESSION_ID set to the env value if present, else the stdin session id (mirrors the shell
-/// `${OWL_SESSION_ID:-$sid}`).
-///
-/// `--json` is REQUIRED here (global read/status flag, spt-core v0.16.0 — always on our floor):
-/// the identity is `.self.id`, `null` when the session has no perch. NEVER take a line of the
-/// human view — it is a grouped roster whose first line is a `SUBNET <name>` header on any node
-/// with subnet membership (and `SELF: <id> …` when perched), so first-line parsing crowned an
-/// agent "SUBNET SPT_DEV" and told it not to run whoami (doyle bug report 2026-07-01; the wrong
-/// identity self-reinforced through a whole orchestration round).
-/// [impl->REQ-DIST-WHOAMI-JSON]
-fn self_id(env: &mut dyn HookEnv, sid: &str) -> String {
-    let owl = env.env("OWL_SESSION_ID").filter(|s| !s.is_empty()).unwrap_or_else(|| sid.to_string());
-    let out = env
-        .spt(&["whoami", "--json"], None, &[("OWL_SESSION_ID", &owl)])
-        .unwrap_or_default();
-    parse_whoami_self(&out)
-}
-
-/// Extract `.self.id` from `spt whoami --json` output. Pure over the string so the contract is
-/// unit-testable: JSON with `self:null` (or any parse failure, e.g. a pre-JSON binary's human
-/// roster) resolves to "" — no-perch, NEVER a roster header. [impl->REQ-DIST-WHOAMI-JSON]
-fn parse_whoami_self(out: &str) -> String {
-    serde_json::from_str::<serde_json::Value>(out.trim())
-        .ok()
-        .and_then(|v| v.get("self").and_then(|s| s.get("id")).and_then(|i| i.as_str()).map(String::from))
-        .unwrap_or_default()
-}
-
-/// Resolve a `[strings]` value by dot-path on the registered adapter (file-backed values resolve to
-/// file contents at read time). Empty on absent key / unregistered adapter / missing spt.
-fn get_string(env: &mut dyn HookEnv, key: &str) -> String {
-    env.spt(&["adapter", "get-string", ADAPTER, key], None, &[]).unwrap_or_default()
-}
-
-/// Inject a skill's operative instructions as additionalContext, resolved from
-/// `[strings.skills].<skill>`. No-op (empty) if the name is empty or the body is unset.
-/// [impl->REQ-UPS-INJECTION]
-fn inject_skill(env: &mut dyn HookEnv, skill: &str) -> String {
-    if skill.is_empty() {
-        return String::new();
-    }
-    let body = get_string(env, &format!("skills.{skill}"));
-    if body.is_empty() {
-        return String::new();
-    }
-    format!("<sptc_skill name=\"{skill}\">\n{body}\n</sptc_skill>\n")
-}
-
-/// Resolve + assemble the perched-session identity brief. The live-ops block (commune incl
-/// --checkpoint, signoff — U4) is composed into the messaging block so a perched/live agent is
-/// briefed on upkeep proactively. [impl->REQ-DIST-SESSIONSTART-BRIEF] [impl->REQ-DIST-SKELETON-THIN]
-fn perch_brief(env: &mut dyn HookEnv, id: &str) -> String {
-    let mut msg = get_string(env, "briefs.messaging-perch");
-    let ops = get_string(env, "briefs.live-ops");
-    if !ops.is_empty() {
-        msg = format!("{msg}\n\n{ops}");
-    }
-    let identity = get_string(env, "briefs.identity");
-    let roster = get_string(env, "briefs.endpoint-list");
-    assemble_perch(id, &identity, &msg, &roster)
-}
-
-/// Resolve + assemble the no-perch ring brief. [impl->REQ-DIST-SESSIONSTART-BRIEF]
-fn noperch_brief(env: &mut dyn HookEnv) -> String {
-    let msg = get_string(env, "briefs.messaging-no-perch");
-    let roster = get_string(env, "briefs.endpoint-list");
-    assemble_noperch(&msg, &roster)
-}
-
-/// Pull the live-agent durable RESUME context via `spt api psyche-download` (closes F-020). Empty on
-/// NO-CONTEXT / the verb absent (pre-v0.15.0) / unregistered — caller appends nothing. Mirrors the
-/// id-scoped `api poll` auth shape (--session-id; project resolves from the bound cwd).
-/// [impl->REQ-DIST-RESUME-CONTEXT]
-fn psyche_download(env: &mut dyn HookEnv, id: &str, sid: &str) -> String {
-    if id.is_empty() {
-        return String::new();
-    }
-    if sid.is_empty() {
-        env.spt(&["api", "--adapter", ADAPTER, "psyche-download", id], None, &[]).unwrap_or_default()
-    } else {
-        env.spt(&["api", "--adapter", ADAPTER, "psyche-download", id, "--session-id", sid], None, &[])
-            .unwrap_or_default()
-    }
-}
-
-/// The additionalContext spill path for a session (absolute, agent-readable, keyed by session id).
-fn spill_path(env: &dyn HookEnv, sid: &str) -> String {
-    let sid = if sid.is_empty() { "unknown" } else { sid };
-    format!("{}/.claude/sptc-drain-{sid}.txt", env.home())
-}
-
-// ─────────────────────────── per-event handlers ───────────────────────────
-
-/// SessionStart: register the perch (bind / seed / boundary) + persist session env, then relay an
-/// agent-facing brief as additionalContext. Non-blocking (never `listen`). The invisible-installer
-/// bootstrap (install spt-core if absent) + the $SPTC_HOOK_BIN cache live in the dispatch wrapper —
-/// the binary cannot exist before spt-core + the adapter are installed. [impl->REQ-DIST-HOOKS-API]
-fn handle_session_start(env: &mut dyn HookEnv, v: &Value) {
-    let sid = field(v, "session_id");
-    let src = field(v, "source");
-    let endpoint_id = env.env("SPT_ENDPOINT_ID").filter(|s| !s.is_empty());
-    let verb = register_verb(&src, endpoint_id.is_some());
-
-    match verb {
-        "boundary" => {
-            // $SPT_ENDPOINT_ID FIRST (the brief path's proven preference): whoami-by-NEW-sid is the
-            // F-024 catch-22 — the new sid is not registered until this very call succeeds, so it
-            // resolves self:null and rotation used to be silently skipped, stranding the perch on
-            // the departed sid (every later id-scoped call AUTH_REFUSED, no self-heal).
-            // [impl->REQ-DIST-BOUNDARY-ROTATE]
-            let id = endpoint_id.clone().unwrap_or_else(|| self_id(env, &sid));
-            if id.is_empty() {
-                // A skipped rotation is a stranded perch — NEVER silent.
-                // [impl->REQ-HAZARD-SESSION-PIN-WEDGE]
-                env.log(&format!(
-                    "claude-spt hook: boundary({src}) SKIPPED — no endpoint id resolvable; the perch stays pinned to the departed session id and will strand (AUTH_REFUSED on every id-scoped call)"
-                ));
-            } else {
-                // The DEPARTED session's sid is the auth proof; it lives in the adapter-owned state
-                // file because the old session's env file is gone by the time this hook fires.
-                let prior = env.read_adapter_state(&sid_state_rel(&id)).unwrap_or_default();
-                let mut args = vec!["api", "--adapter", ADAPTER, "boundary", &src, &id, "--to-session-id", &sid];
-                if prior.is_empty() {
-                    env.log(&format!(
-                        "claude-spt hook: boundary({src}) for {id} has no prior-session proof (state file absent) — attempting unproven rotation; expect AUTH_REFUSED on spt-core >=0.19"
-                    ));
-                } else {
-                    args.extend(["--session-id", &prior]);
-                }
-                if let Err(e) = env.spt_strict(&args) {
-                    // Surface the refusal reason (AUTH_REFUSED prints on stderr) — a silent failure
-                    // here is the F-024 wedge. [impl->REQ-HAZARD-SESSION-PIN-WEDGE]
-                    env.log(&format!("claude-spt hook: boundary({src}) rotation FAILED for {id}: {e}"));
-                }
-            }
-        }
-        "bind" => {
-            // spt-hosted post-spawn bind. endpoint_id is Some here by construction of register_verb.
-            // Two shapes:
-            //   • FIRST bind (fresh spawn, source=startup): the perch has no recorded sid yet, so a
-            //     bare --set-session-id bind — broker parentage is the credential.
-            //   • RE-BIND of an already-bound perch: CC's in-TUI /resume ends the session
-            //     (SessionEnd reason=resume) and re-fires SessionStart(source=resume) in the SAME
-            //     broker child, so $SPT_ENDPOINT_ID is still set and register_verb (only clear/compact
-            //     → boundary) routes here. The perch already records the DEPARTED pre-resume sid, so a
-            //     proofless re-pin to the resumed sid is squat-protection REFUSED and — swallowed by
-            //     the old exit-ignored `spt` seam — strands the perch on the departed sid (the
-            //     SESSION-PIN-WEDGE via /resume). Present the departed sid from adapter state as the
-            //     `--session-id` ownership proof (bind accepts it, matching the perch info.json;
-            //     `boundary <MODE>` is a hard {clear,compact} enum so a `resume` mode is core-blocked
-            //     — the proof rides bind). Strict + loud on refusal, never a silent swallow.
-            // [impl->REQ-HAZARD-RESUME-REBIND-WEDGE] [impl->REQ-HAZARD-SESSION-PIN-WEDGE]
-            if let Some(eid) = endpoint_id.as_deref() {
-                let prior = env.read_adapter_state(&sid_state_rel(eid)).unwrap_or_default();
-                let mut args = vec!["api", "--adapter", ADAPTER, "bind", eid, "--set-session-id", &sid];
-                if !prior.is_empty() && prior != sid {
-                    args.extend(["--session-id", &prior]);
-                }
-                if let Err(e) = env.spt_strict(&args) {
-                    env.log(&format!("claude-spt hook: bind({src}) re-pin FAILED for {eid}: {e}"));
-                }
-                // A freshly-bound spt-hosted session sits at an empty input box = IDLE, ready to
-                // receive. The daemon defers inbound to the spool while an endpoint is ACTIVE and
-                // drains only on the NEXT idle transition; the adapter otherwise marks idle ONLY on
-                // Stop (turn end) / clear / checkpoint, so a session that never completes a turn
-                // (launched-then-left, or a /login with no ensuing agent turn) would stay ACTIVE
-                // forever and SILENTLY spool every message, never draining (field 2026-07-08: `lia`
-                // — 14 messages parked delivered=0, never taken; translation binary healthy, just
-                // never fed). Assert idle at bringup so a fresh endpoint is immediately receivable.
-                // [impl->REQ-HAZARD-STUCK-ACTIVE-NO-IDLE]
-                env.spt(&["api", "--adapter", ADAPTER, "state", "idle", eid, "--session-id", &sid], None, &[]);
-            }
-        }
-        _ => {
-            // seed (harness-hosted): adapter-agnostic (NO --adapter) — resolved at bind time from the
-            // seed's parent pid via host_binaries. The host pid is passed by dispatch (--host-pid).
-            let pid = env.host_pid().unwrap_or_default();
-            env.spt(&["api", "seed", "--pid", &pid, "--session-id", &sid], None, &[]);
-        }
-    }
-
-    // Persist the CURRENT sid as the NEXT rotation's auth proof — EVERY SessionStart, after
-    // registration (a boundary success included: this sid is the prior of the next /clear). The
-    // per-session CLAUDE_ENV_FILE is deliberately NOT the carrier — it dies with the session, which
-    // is exactly the failure this file exists to survive. [impl->REQ-DIST-BOUNDARY-ROTATE]
-    if let Some(eid) = endpoint_id.as_deref() {
-        if !env.write_adapter_state(&sid_state_rel(eid), &sid) {
-            env.log(&format!(
-                "claude-spt hook: could not persist the session id for {eid} — the next /clear|compact rotation will lack its auth proof"
-            ));
-        }
-    }
-
-    // FIRE the armed checkpoint wake AFTER a /clear rebuild. The translation binary withheld the wake
-    // (it emitted /clear-only) until CC finished the clear and re-ran THIS SessionStart. On a `clear`
-    // boundary we mark idle + self-send {"checkpoint_fire":"v1"} through our OWN translation binary
-    // (--force-native — never spool to the active poll); the binary emits the armed wake into the now-
-    // clean session, or no-ops if nothing was armed (this fires on EVERY clear, statelessly). Ordering
-    // is guaranteed: the wake can only land after this hook, which only runs after /clear completes.
-    // ONLY `clear` — no checkpoint variant leverages /compact. [impl->REQ-HAZARD-CHECKPOINT-CLEAR-RACE]
-    if src == "clear" {
-        if let Some(eid) = endpoint_id.as_deref() {
-            env.spt(&["api", "--adapter", ADAPTER, "state", "idle", eid, "--session-id", &sid], None, &[]);
-            // BOUNDARY RENAME first: CC drops the `-n` display name when the clear rotates the
-            // session, stranding the operator without a rendered TUI anchor. Re-assert the spawn
-            // name (verbatim from $SPT_SESSION_NAME — the launch shim's env thread, the same string
-            // that fed `-n`) via a rename delivery. BEFORE the fire: /rename is a local no-turn
-            // command, so the session is still idle when any armed wake lands; inverted, the wake's
-            // turn would strand the rename text in a busy input box. Missing name (pre-0.14.1
-            // spawn, non-shim spawn) skips LOUDLY — a silent skip is an unnamed session with no
-            // diagnosis trail; heals on respawn. [impl->REQ-DIST-BOUNDARY-RENAME]
-            match env.env(crate::launch::SESSION_NAME_ENV).filter(|s| !s.trim().is_empty()) {
-                Some(name) => {
-                    env.spt(
-                        &["send", "--from", eid, eid, "--json-payload", &rename_payload(&name), "--force-native"],
-                        Some("boundary rename"),
-                        &[],
-                    );
-                }
-                None => env.log(&format!(
-                    "claude-spt hook: RENAME_SKIP:no-name — ${} absent/blank (pre-0.14.1 spawn?); the post-clear session stays unnamed until this endpoint respawns",
-                    crate::launch::SESSION_NAME_ENV
-                )),
-            }
-            env.spt(
-                &["send", "--from", eid, eid, "--json-payload", checkpoint_fire_payload(), "--force-native"],
-                Some("checkpoint fire"),
-                &[],
-            );
-        }
-    }
-
-    // Persist for the rest of the session (whoami fallback + parity with the shell wrapper).
-    env.append_env_file(&format!("OWL_SESSION_ID={sid}"));
-    env.append_env_file(&format!("SPT_ADAPTER={ADAPTER}"));
-
-    // Brief (skip subagent sessions). Perched (bind/boundary) → identity brief + durable resume;
-    // no-perch seed on a node WITH peers → ring brief; seed without peers → nothing.
-    if is_subagent(&field(v, "agent_type")) {
-        return;
-    }
-    let brief = match verb {
-        "bind" | "boundary" => {
-            let bid = endpoint_id.clone().unwrap_or_else(|| self_id(env, &sid));
-            if bid.is_empty() {
-                String::new()
-            } else {
-                let b = perch_brief(env, &bid);
-                append_resume(&b, &psyche_download(env, &bid, &sid))
-            }
-        }
-        _ => {
-            let status = env.spt(&["subnet", "status"], None, &[]).unwrap_or_default();
-            if has_peers(&status) {
-                noperch_brief(env)
-            } else {
-                String::new()
-            }
-        }
-    };
-    let line = emit_additional_context(&brief);
-    if !line.is_empty() {
-        env.emit(&line);
-    }
-}
-
-/// The spt reachability notice — ported from legacy owl's `<owl_reachability_notice>` (sibling
-/// claude_skill_owl: hook_prompt.rs's every-prompt append + hook_check.rs's Agent-tool nudge),
-/// renamed to spt semantics. WHY: a perched agent that runs subagents or long commands in the
-/// FOREGROUND is unreachable for incoming messages for the whole task — the notice steers every
-/// turn toward `run_in_background: true` so the perch stays responsive. Two variants: the GENERAL
-/// notice rides every UserPromptSubmit on a perched session; the AGENT nudge rides PreToolUse when
-/// the tool about to run is a subagent spawn. [impl->REQ-DIST-REACHABILITY-NOTICE]
-fn reachability_notice(agent_nudge: bool) -> String {
-    let body = if agent_nudge {
-        "Launch this Agent with run_in_background: true so you stay reachable for incoming messages while it works."
-    } else {
-        "When spawning subagents or running long tasks, use run_in_background: true so you stay reachable for incoming messages."
-    };
-    format!("<spt_reachability_notice>\nYou have an active spt perch. {body}\n</spt_reachability_notice>")
-}
-
-/// Is this PreToolUse tool a subagent spawn? "Agent" is CC's current tool name (what legacy owl
-/// matched); "Task" is its older payload name — matched too so the nudge survives CC renames in
-/// EITHER direction. [impl->REQ-DIST-REACHABILITY-NOTICE]
-fn is_agent_spawn_tool(tool_name: &str) -> bool {
-    tool_name == "Agent" || tool_name == "Task"
-}
-
-/// UserPromptSubmit (turn-start): inject a `/sptc:<skill>` body if present, mark the perch BUSY so
-/// inbound DEFERS for mid-turn PreToolUse delivery, then DRAIN the inbox (incl. deferred), then
-/// append the reachability notice. All ride the combined, once-capped additionalContext.
-/// [impl->REQ-UPS-INJECTION] [impl->REQ-DIST-PRETOOL-POLL] [impl->REQ-DIST-REACHABILITY-NOTICE]
-fn handle_user_prompt_submit(env: &mut dyn HookEnv, v: &Value) {
-    let sid = field(v, "session_id");
-    // Skill-injection runs BEFORE the perch check — /sptc:version|setup are valid without a perch.
-    let mut out = inject_skill(env, &skill_key(&field(v, "prompt")));
-
-    let id = self_id(env, &sid);
-    if !id.is_empty() {
-        // Mark busy BEFORE the drain so a message arriving mid-drain also defers (F-021).
-        env.spt(&["api", "--adapter", ADAPTER, "state", "busy", &id, "--session-id", &sid], None, &[]);
-        let frames = env
-            .spt(&["api", "--adapter", ADAPTER, "poll", &id, "--session-id", &sid, "--include-deferred"], None, &[])
-            .unwrap_or_default();
-        if !frames.is_empty() {
-            let rendered = render_frames(&frames);
-            if !rendered.is_empty() {
-                out = if out.is_empty() { rendered } else { format!("{out}\n{rendered}") };
-            }
-        }
-        // Perched turns always close with the reachability notice (legacy-owl always-append).
-        let notice = reachability_notice(false);
-        out = if out.is_empty() { notice } else { format!("{out}\n{notice}") };
-    }
-    let spill = spill_path(env, &sid);
-    emit_capped(env, &out, &spill);
-}
-
-/// `state/digest/<eid>.pos` — the tag-scan cursor path (same filename sanitization as
-/// [`sid_state_rel`]). Holds the BYTE OFFSET into the CC transcript already scanned; a hook reads only
-/// the newly-appended tail, so a section fires exactly once across PreToolUse and Stop. (New basename
-/// `.pos`, not the v0.17.0/1 `.seq`: that file held a digest SEQ — reusing it as a byte offset would
-/// read as "file shorter than offset" and reprocess the whole transcript. A fresh `.pos` initializes
-/// to the transcript's current EOF, so pre-upgrade history is never re-dispatched.)
-fn digest_cursor_rel(endpoint_id: &str) -> String {
-    let safe: String = endpoint_id
-        .chars()
-        .filter(|c| c.is_ascii_alphanumeric() || *c == '-' || *c == '_' || *c == '.')
-        .collect();
-    format!("state/digest/{safe}.pos")
-}
-
-/// A `spt send` stdout that means the message reached its channel (delivered live, spooled for a
-/// next listen, or deferred to the target's own poll). Anything else — `NO_PERCH:…`, empty, a spawn
-/// failure — means it did NOT land and must be surfaced to the sender (never silent-dropped).
-fn send_landed(out: &str) -> bool {
-    let o = out.trim_start();
-    o.starts_with("SENT") || o.starts_with("QUEUED") || o.starts_with("DEFERRED")
-}
-
-/// Write the commune body to this agent's own `.claude/<id>-commune.md` under the session cwd (the
-/// project dir CC runs the hook in) — the same file the `/sptc:commune` Write path targets, so the
-/// daemon's watch ingests+deletes it identically. Best-effort. [impl->REQ-COMMUNE-OUTPUT-SHORTCUT]
-fn write_commune_file(env: &mut dyn HookEnv, id: &str, body: &str) -> bool {
-    let Ok(cwd) = std::env::current_dir() else { return false };
-    let dir = cwd.join(".claude");
-    let _ = std::fs::create_dir_all(&dir);
-    env.write_spill(&dir.join(format!("{id}-commune.md")).to_string_lossy(), body)
-}
-
-/// The tag-driven peer-messaging + commune-output scan (NEXT-WORKLOAD-PLAN Item 2). Tails this
-/// session's CC TRANSCRIPT from a byte cursor — NOT the async `endpoint digest` (whose per-entry `seq`
-/// is assigned AFTER the Stop hook fires, so a tag that is the turn's LAST output was missed until the
-/// next hook, v0.17.0/1). CC writes the completed assistant message to the transcript BEFORE it fires
-/// Stop, so reading it here delivers an end-of-turn tag immediately, universally (live + spt-hosted),
-/// with no background poll. Dispatches every `@<targets body @>` peer message and every `>>commune<<`
-/// shortcut in the newly-appended output, fires ONE confirm-back to the sender's own perch, and
-/// advances the cursor by the bytes consumed. `transcript_path` is the CC hook payload's common field.
-/// No-op when there is no self perch or no transcript path. [impl->REQ-TAG-PEER-MESSAGING]
-/// [impl->REQ-COMMUNE-OUTPUT-SHORTCUT]
-fn scan_and_dispatch(env: &mut dyn HookEnv, id: &str, sid: &str, transcript_path: &str) {
-    if id.is_empty() || transcript_path.is_empty() {
-        return;
-    }
-    let rel = digest_cursor_rel(id);
-    let cursor_opt = env.read_adapter_state(&rel).and_then(|s| s.trim().parse::<u64>().ok());
-    let Some((chunk, start)) = env.read_file_tail(transcript_path, cursor_opt.unwrap_or(0)) else {
-        return;
-    };
-    // First run (no cursor yet): initialize to the transcript's current EOF so pre-existing history is
-    // NOT re-dispatched, and process nothing this pass. Only appends from here on are scanned.
-    if cursor_opt.is_none() {
-        let eof = start + chunk.len() as u64;
-        env.write_adapter_state(&rel, &eof.to_string());
-        return;
-    }
-    // Consume only COMPLETE (newline-terminated) lines; a trailing partial (CC mid-write) is held and
-    // re-read whole next hook. Advancing the cursor by exactly the consumed bytes is the double-send
-    // guard across PreToolUse and Stop.
-    let (complete, consumed) = crate::tag_scan::complete_line_prefix(&chunk);
-    if consumed == 0 {
-        return;
-    }
-    let new_cursor = start + consumed as u64;
-    let texts = crate::tag_scan::assistant_texts_from_jsonl(complete);
-    let plan = crate::tag_scan::plan_dispatch(&texts);
-
-    // Peer sends: one `spt send` per (section × target); self-targets dropped; results tallied.
-    let mut delivered: Vec<String> = Vec::new();
-    let mut unreachable: Vec<String> = Vec::new();
-    let mut self_dropped = false;
-    for section in &plan.sends {
-        for target in &section.targets {
-            if target == id {
-                self_dropped = true;
-                continue;
-            }
-            // Classify through `spt_send` (stdout+stderr): `spt send`'s status token is on STDERR, so
-            // the stdout-only `spt` sees "" and misreads every delivered send as NO_PERCH (the
-            // 2026-07-08 field bug). [impl->REQ-HAZARD-SEND-STATUS-STDERR]
-            let landed = env
-                .spt_send(&["send", "--from", id, target], Some(&section.body))
-                .map(|o| send_landed(&o))
-                .unwrap_or(false);
-            if landed {
-                delivered.push(target.clone());
-            } else {
-                unreachable.push(target.clone());
-            }
-        }
-    }
-    // Confirm-back to our OWN perch (--active-only --ephemeral: lands mid-turn, never stale). Without
-    // it the agent re-sends via Bash, defeating the feature. Fired only when a send was attempted.
-    if !plan.sends.is_empty() {
-        let mut parts: Vec<String> = Vec::new();
-        if !delivered.is_empty() {
-            parts.push(format!("delivered → {}", delivered.join(", ")));
-        }
-        if !unreachable.is_empty() {
-            parts.push(format!("NO PERCH (not delivered) → {}", unreachable.join(", ")));
-        }
-        if self_dropped {
-            parts.push("self-target dropped".to_string());
-        }
-        let confirm = format!("[tag-send] {}", parts.join(" · "));
-        env.spt(&["send", "--from", id, id, "--active-only", "--ephemeral"], Some(&confirm), &[]);
-    }
-
-    // Commune shortcut: write the file (daemon ingests+deletes), and if the body carries the
-    // checkpoint marker, fire the SAME self-send loopback as the Write-path PostToolUse handler.
-    for body in &plan.communes {
-        write_commune_file(env, id, body);
-        if has_checkpoint(body) {
-            env.spt(&["api", "--adapter", ADAPTER, "state", "idle", id, "--session-id", sid], None, &[]);
-            let payload = checkpoint_payload(&checkpoint_wake(body));
-            env.spt(
-                &["send", "--from", id, id, "--json-payload", &payload, "--force-native"],
-                Some("checkpoint requested"),
-                &[],
-            );
-        }
-    }
-
-    env.write_adapter_state(&rel, &new_cursor.to_string());
-}
-
-/// PreToolUse: mid-turn delivery (F-021) + the Agent-spawn reachability nudge. Marks the perch busy
-/// (idempotent; the only busy mark for a turn that started without a UserPromptSubmit), drains
-/// messages deferred while busy, and — when the tool about to run is a subagent spawn — appends the
-/// targeted background-launch nudge (messages first, nudge last: the legacy-owl ordering).
-/// [impl->REQ-DIST-PRETOOL-POLL] [impl->REQ-DIST-REACHABILITY-NOTICE]
-fn handle_pre_tool_use(env: &mut dyn HookEnv, v: &Value) {
-    let sid = field(v, "session_id");
-    let id = self_id(env, &sid);
-    if id.is_empty() {
-        return;
-    }
-    env.spt(&["api", "--adapter", ADAPTER, "state", "busy", &id, "--session-id", &sid], None, &[]);
-    // Dispatch any peer-message / commune markers this agent emitted so far this turn (mid-turn leg).
-    scan_and_dispatch(env, &id, &sid, &field(v, "transcript_path"));
-    let frames = env
-        .spt(&["api", "--adapter", ADAPTER, "poll", &id, "--session-id", &sid, "--include-deferred"], None, &[])
-        .unwrap_or_default();
-    let mut out = if frames.is_empty() { String::new() } else { render_frames(&frames) };
-    if is_agent_spawn_tool(&field(v, "tool_name")) {
-        let nudge = reachability_notice(true);
-        out = if out.is_empty() { nudge } else { format!("{out}\n{nudge}") };
-    }
-    if out.is_empty() {
-        return;
-    }
-    let spill = spill_path(env, &sid);
-    // JSON envelope, NOT raw stdout — CC discards raw PreToolUse stdout (the 2026-07-07 black
-    // hole). [impl->REQ-HAZARD-PRETOOL-CONTEXT-ENVELOPE]
-    emit_capped_pretool(env, &out, &spill);
-}
-
-/// Stop (turn-end): mark the perch idle (also arms the echo-gate fallback). [impl->REQ-DIST-HOOKS-API]
-fn handle_stop(env: &mut dyn HookEnv, v: &Value) {
-    let sid = field(v, "session_id");
-    let id = self_id(env, &sid);
-    if id.is_empty() {
-        return;
-    }
-    // Step-0 instrumentation (trace-gated — Stop is the hot per-turn path): confirms whether an
-    // Esc-interrupted turn produces a `Stop` at all (field says no; the repro proves it). Off by
-    // default (zero noise); operator sets $SPTC_HOOK_TRACE=1 for the coverage-boundary repro.
-    if env.env("SPTC_HOOK_TRACE").filter(|s| !s.is_empty()).is_some() {
-        env.log("claude-spt hook: STOP fired — normal turn-end idle mark");
-    }
-    // Backstop leg: a tag/commune emitted as the turn's FINAL output (no subsequent tool call) is not
-    // seen by PreToolUse — catch it here. CC has written the final assistant message to the transcript
-    // before this Stop fires, so the end-of-turn tag is visible; the byte cursor dedups vs the mid-turn
-    // scan.
-    scan_and_dispatch(env, &id, &sid, &field(v, "transcript_path"));
-    env.spt(&["api", "--adapter", ADAPTER, "state", "idle", &id, "--session-id", &sid], None, &[]);
-}
-
-/// Notification (`*` matcher — every notification type routes here): CC signals a session event at
-/// the prompt. The adapter otherwise marks idle ONLY on Stop / clear / checkpoint, so any submission
-/// that does NOT complete an agent turn — a `/login`, a client-side slash command, a cancelled turn —
-/// leaves the endpoint stuck ACTIVE and the daemon spools every inbound message without ever draining
-/// it (field 2026-07-08: `lia` stuck ACTIVE after a logged-out-boot `/login`, 14 messages parked and
-/// silently undelivered). The SELF-HEAL: on an `idle_prompt` (session back at its input box, no turn
-/// running) re-assert `state idle` so the daemon drains the parked spool (IDLE_PARKED_DRAIN).
-///
-/// TYPE-AWARE (v0.16.0): the matcher was widened from `idle_prompt` to `*` so the handler observes
-/// EVERY type — but it marks idle ONLY for `idle_prompt`. A `permission_prompt` / `elicitation_dialog`
-/// is NOT idle (a turn is mid-flight awaiting the operator), and marking idle then would wrongly drain
-/// the spool INTO a live turn. Every routed type is LOGGED (Step-0 instrumentation: a live Esc-repro
-/// reveals which types CC actually fires and where the no-Stop coverage gaps are — permanent
-/// defense-in-depth observability, kept). Gated on $SPT_ENDPOINT_ID — only spt-hosted endpoints ride
-/// the daemon's idle-gated delivery path. [impl->REQ-HAZARD-STUCK-ACTIVE-NO-IDLE]
-fn handle_notification(env: &mut dyn HookEnv, v: &Value) {
-    let Some(id) = env.env("SPT_ENDPOINT_ID").filter(|s| !s.is_empty()) else { return };
-    let ntype = field(v, "notification_type");
-    env.log(&format!("claude-spt hook: NOTIFICATION type={ntype:?} (idle-heal fires only on idle_prompt)"));
-    if ntype != "idle_prompt" {
-        return;
-    }
-    let sid = field(v, "session_id");
-    if sid.is_empty() {
-        return;
-    }
-    env.spt(&["api", "--adapter", ADAPTER, "state", "idle", &id, "--session-id", &sid], None, &[]);
-}
-
-/// Resolve `(endpoint id, session id)` for a receive-heal `state idle`, then fire it (or log a SKIP).
-/// The daemon's idle-gated delivery — the black-hole path these hooks close — is spt-hosted, so PREFER
-/// the proven spt-hosted resolution (the one `handle_notification` already uses): id = $SPT_ENDPOINT_ID,
-/// sid = the payload's `session_id` ELSE the bind-time carrier `state/session/<id>.sid` (written by
-/// `handle_session_start`). This is the v0.16.1 hardening: `PostToolUseFailure` (and possibly
-/// `StopFailure`) payloads may OMIT `session_id`, and a `state idle` with an empty `--session-id` is
-/// AUTH-refused by core — the silent miss that left `lia` deaf after a real-turn interrupt while its
-/// input box sat at "Interrupted · What should Claude do instead?" (field 2026-07-08). A live agent
-/// (no $SPT_ENDPOINT_ID — Monitor-relay delivery) resolves via `self_id` + the payload sid. NEVER fires
-/// with an empty id or sid (logs `RECEIVE_HEAL_SKIP` instead — visible in hook-trace.log).
-/// [impl->REQ-HAZARD-INTERRUPT-STUCK-BUSY] [impl->REQ-HAZARD-STOPFAILURE-STUCK-BUSY]
-fn mark_idle_receive_heal(env: &mut dyn HookEnv, sid_payload: &str, why: &str) {
-    let (id, sid) = match env.env("SPT_ENDPOINT_ID").filter(|s| !s.is_empty()) {
-        Some(eid) => {
-            let sid = if sid_payload.is_empty() {
-                env.read_adapter_state(&sid_state_rel(&eid)).unwrap_or_default()
-            } else {
-                sid_payload.to_string()
-            };
-            (eid, sid)
-        }
-        None => {
-            let id = self_id(env, sid_payload);
-            (id, sid_payload.to_string())
-        }
-    };
-    if id.is_empty() || sid.is_empty() {
-        env.log(&format!(
-            "claude-spt hook: RECEIVE_HEAL_SKIP ({why}) — id={id:?} sid_empty={} (cannot prove ownership to state idle)",
-            sid.is_empty()
-        ));
-        return;
-    }
-    env.log(&format!("claude-spt hook: RECEIVE_HEAL ({why}) — state idle {id} --session-id {sid}"));
-    env.spt(&["api", "--adapter", ADAPTER, "state", "idle", &id, "--session-id", &sid], None, &[]);
-}
-
-/// StopFailure (a turn ends with an API error — rate_limit, server_error, max_output_tokens, …): CC
-/// fires NO `Stop` on an errored turn-end, so the perch never gets its turn-end idle mark and an
-/// spt-hosted endpoint stays ACTIVE → the daemon spools every inbound and never drains (the same
-/// black-hole class as the stuck-ACTIVE idle bug, reached via API error instead of a never-completed
-/// first turn). Mark idle via the hardened receive-heal. Logs the error_type + whether the payload
-/// carried a sid (hook-trace.log; Step-0 instrument + permanent observability).
-/// [impl->REQ-HAZARD-STOPFAILURE-STUCK-BUSY]
-fn handle_stop_failure(env: &mut dyn HookEnv, v: &Value) {
-    let sid = field(v, "session_id");
-    let etype = field(v, "error_type");
-    env.log(&format!("claude-spt hook: STOP_FAILURE error_type={etype:?} sid_in_payload={}", !sid.is_empty()));
-    mark_idle_receive_heal(env, &sid, "StopFailure");
-}
-
-/// PostToolUseFailure: a tool call ended in failure. When `is_interrupt == true` the failure is an
-/// operator Esc DURING a tool call — CC fires NO `Stop` and NO `idle_prompt`, so the endpoint stays
-/// ACTIVE and black-holes inbound (field `lia` 2026-07-08). Heal at zero latency via the hardened
-/// receive-heal. A NON-interrupt failure (a command exited nonzero) is NOT a turn-end — the agent keeps
-/// working — so it must NOT mark idle. EVERY invocation logs `is_interrupt` + sid presence to
-/// hook-trace.log (the Step-0 ground truth: does CC even fire this on an Esc-mid-tool, and does the
-/// payload carry a sid). [impl->REQ-HAZARD-INTERRUPT-STUCK-BUSY]
-fn handle_post_tool_use_failure(env: &mut dyn HookEnv, v: &Value) {
-    let is_interrupt = v.get("is_interrupt").and_then(Value::as_bool).unwrap_or(false);
-    let sid = field(v, "session_id");
-    env.log(&format!("claude-spt hook: POST_TOOL_USE_FAILURE is_interrupt={is_interrupt} sid_in_payload={}", !sid.is_empty()));
-    if !is_interrupt {
-        return;
-    }
-    mark_idle_receive_heal(env, &sid, "PostToolUseFailure/interrupt");
-}
-
-/// SessionEnd: soft teardown of the perch (spool/history preserved). [impl->REQ-DIST-HOOKS-API]
-fn handle_session_end(env: &mut dyn HookEnv, v: &Value) {
-    let sid = field(v, "session_id");
-    let id = self_id(env, &sid);
-    if id.is_empty() {
-        return;
-    }
-    env.spt(&["api", "--adapter", ADAPTER, "session-end", &id, "--session-id", &sid], None, &[]);
-}
-
-/// Adapter-state path holding the CORE-MINTED worker id for a CC agent_id — the SubagentStop
-/// payload carries only the CC agent_id, so this mapping is the adapter's to hold between the
-/// start and stop hooks (same contract-clean carrier as the F-024 sid proof). Sanitized to the
-/// filename-safe alphabet like `sid_state_rel`. [impl->REQ-DIST-WORKER-LIFECYCLE]
-fn worker_state_rel(agent_id: &str) -> String {
-    let safe: String = agent_id
-        .chars()
-        .filter(|c| c.is_ascii_alphanumeric() || *c == '-' || *c == '_' || *c == '.')
-        .collect();
-    format!("state/worker/{safe}.wid")
-}
-
-/// SubagentStart (fires in the PARENT's context): register a nested worker perch under the parent
-/// per the WORKER-TRUTH wave-1 contract (spt-core v0.27.0): NO worker-id positional — core
-/// hard-mints `{parent}-w{N}` and answers it on BARE STDOUT (empty = refusal); NO token (auth is
-/// sid-symmetric). The CC agent_id/agent_type ride as correlation metadata, and the minted id is
-/// persisted keyed by agent_id for the stop hook. Every skip/refusal is LOUD — the pre-0.27.0
-/// silent-swallow class leaked 100% of workers (2026-07-06). [impl->REQ-DIST-WORKER-LIFECYCLE]
-fn handle_subagent_start(env: &mut dyn HookEnv, v: &Value) {
-    let sid = field(v, "session_id");
-    let agent_id = field(v, "agent_id");
-    let agent_type = field(v, "agent_type");
-    let parent = self_id(env, &sid);
-    if parent.is_empty() || agent_id.is_empty() {
-        env.log(&format!(
-            "claude-spt hook: WORKER_START_SKIP — unresolvable parent ({parent:?}) or missing agent_id ({agent_id:?}); no worker perch will exist for this subagent"
-        ));
-        return;
-    }
-    let mut args = vec!["api", "--adapter", ADAPTER, "worker-start", &parent, "--session-id", &sid, "--agent-id", &agent_id];
-    if !agent_type.is_empty() {
-        args.extend(["--agent-type", &agent_type]);
-    }
-    match env.spt_strict(&args) {
-        Ok(minted) if !minted.trim().is_empty() => {
-            let minted = minted.trim().to_string();
-            if !env.write_adapter_state(&worker_state_rel(&agent_id), &minted) {
-                env.log(&format!(
-                    "claude-spt hook: WORKER_START_UNMAPPED — worker {minted} registered but the agent_id→minted-id mapping could not be persisted; SubagentStop cannot stop it (core TTL reap is the backstop)"
-                ));
-            }
-        }
-        Ok(_) => env.log(&format!(
-            "claude-spt hook: WORKER_START_REFUSED — worker-start for agent {agent_id} under {parent} answered no minted id; no worker perch registered"
-        )),
-        Err(e) => env.log(&format!(
-            "claude-spt hook: WORKER_START_REFUSED — worker-start for agent {agent_id} under {parent} failed: {e}"
-        )),
-    }
-}
-
-/// SubagentStop (fires in the PARENT's context): stop the worker perch by its CORE-MINTED id
-/// (looked up from the adapter-state mapping the start hook persisted), sid-symmetric auth, zero
-/// tokens. STRICT + LOUD: the pre-0.27.0 silent-swallowed refusal is exactly how the 2026-07-06
-/// six-worker leak stayed invisible. The mapping row is cleared on success.
-/// [impl->REQ-DIST-WORKER-LIFECYCLE]
-fn handle_subagent_stop(env: &mut dyn HookEnv, v: &Value) {
-    let sid = field(v, "session_id");
-    let agent_id = field(v, "agent_id");
-    if agent_id.is_empty() {
-        env.log("claude-spt hook: WORKER_STOP_SKIP — SubagentStop payload carries no agent_id; cannot resolve a worker to stop");
-        return;
-    }
-    let rel = worker_state_rel(&agent_id);
-    let Some(minted) = env.read_adapter_state(&rel) else {
-        env.log(&format!(
-            "claude-spt hook: WORKER_STOP_SKIP — no minted-id mapping for agent {agent_id} (start refused, pre-0.15.0 start, or mapping lost); core TTL reap is the backstop"
-        ));
-        return;
-    };
-    match env.spt_strict(&["api", "--adapter", ADAPTER, "worker-stop", &minted, "--session-id", &sid]) {
-        Ok(_) => {
-            // Clear the mapping row (empty content reads back as absent).
-            env.write_adapter_state(&rel, "");
-        }
-        Err(e) => env.log(&format!(
-            "claude-spt hook: WORKER_STOP_REFUSED — worker-stop {minted} (agent {agent_id}) failed: {e}; the worker perch may linger until core TTL reap"
-        )),
-    }
-}
-
-/// PostToolUse (Write matcher): the agent-driven CHECKPOINT detector. On a Write to THIS spt-hosted
-/// live agent's own `.claude/<id>-commune.md` whose content carries `!!checkpoint!!`, mark the perch
-/// idle and self-send a reserved `{"checkpoint":"v1",…}` signal that loops back through the endpoint's
-/// own translation binary (the clear+wake macro). spt-hosted live sessions only ($SPT_ENDPOINT_ID).
-/// [impl->REQ-DIST-CHECKPOINT-COMMUNE]
-fn handle_post_tool_use(env: &mut dyn HookEnv, v: &Value) {
-    let Some(id) = env.env("SPT_ENDPOINT_ID").filter(|s| !s.is_empty()) else { return };
-    let tool = field(v, "tool_name");
-    let file_path = nested(v, "tool_input", "file_path");
-    if !is_commune_write(&tool, &file_path, &id) {
-        return;
-    }
-    let content = nested(v, "tool_input", "content");
-    if !has_checkpoint(&content) {
-        return;
-    }
-    let sid = field(v, "session_id");
-    // Mark idle so the loopback delivery lands on an idle input box, not mid-turn.
-    env.spt(&["api", "--adapter", ADAPTER, "state", "idle", &id, "--session-id", &sid], None, &[]);
-    let payload = checkpoint_payload(&checkpoint_wake(&content));
-    // Self-send the signal back through our own endpoint's translation binary (the proven loopback).
-    // Body is a harmless note; the structured trigger rides the json attr (collision-proof).
-    // --force-native: deliver ONLY through the translation binary's stdin (where the marker parses) —
-    // never spool to the active-poll channel, which would surface the envelope as a plain message the
-    // agent reads instead of firing the macro (the ENLYZEAM misdelivery mode).
-    // [impl->REQ-HAZARD-CHECKPOINT-CLEAR-RACE]
-    env.spt(
-        &["send", "--from", &id, &id, "--json-payload", &payload, "--force-native"],
-        Some("checkpoint requested"),
-        &[],
-    );
-}
-
-/// The post-clear FIRE signal payload — a fixed marker carried in the json attr. The translation
-/// binary, on seeing `{"checkpoint_fire":"v1"}`, emits the armed wake (or no-ops if none is armed).
-/// [impl->REQ-HAZARD-CHECKPOINT-CLEAR-RACE]
-fn checkpoint_fire_payload() -> &'static str {
-    "{\"checkpoint_fire\":\"v1\"}"
-}
-
-/// The boundary-rename signal payload: carries the spawn display name (from $SPT_SESSION_NAME, the
-/// launch shim's env thread) so the translation binary can re-assert it on the fresh post-clear
-/// session via `/rename <name>`. [impl->REQ-DIST-BOUNDARY-RENAME]
-fn rename_payload(name: &str) -> String {
-    format!("{{\"rename\":\"v1\",\"name\":\"{}\"}}", json_escape(name))
-}
-
-/// Dispatch a parsed CC hook payload to the handler for `event` (the verbatim CC event name).
-/// Unknown events are a silent no-op (forward-compat with a newer plugin wiring an event this binary
-/// does not yet handle). [impl->REQ-DIST-HOOK-BINARY]
-fn dispatch(env: &mut dyn HookEnv, event: &str, v: &Value) {
-    match event {
-        "SessionStart" => handle_session_start(env, v),
-        "UserPromptSubmit" => handle_user_prompt_submit(env, v),
-        "PreToolUse" => handle_pre_tool_use(env, v),
-        "Stop" => handle_stop(env, v),
-        "SessionEnd" => handle_session_end(env, v),
-        "SubagentStart" => handle_subagent_start(env, v),
-        "SubagentStop" => handle_subagent_stop(env, v),
-        "PostToolUse" => handle_post_tool_use(env, v),
-        "PostToolUseFailure" => handle_post_tool_use_failure(env, v),
-        "Notification" => handle_notification(env, v),
-        "StopFailure" => handle_stop_failure(env, v),
-        _ => {}
-    }
-}
-
-// ─────────────────────────── real environment + entry ───────────────────────────
-
-/// The production [`HookEnv`]: spawns `spt`, writes real stdout / files / env, reads process env.
-struct SysEnv {
-    host_pid: Option<String>,
-}
-
-impl SysEnv {
-    /// Append one hook-log line to a ROLLING `hook-trace.log` beside the binary (adapter_dir). The
-    /// readable Step-0 instrument (CC hides hook stderr on a broker session). Bounded: at >512 KB the
-    /// file is reset (never unbounded). Best-effort — every error is swallowed so a trace write can
-    /// never fail a hook. [impl->REQ-HAZARD-INTERRUPT-STUCK-BUSY]
-    fn append_trace(msg: &str) {
-        let Ok(exe) = std::env::current_exe() else { return };
-        let Some(dir) = exe.parent() else { return };
-        let path = dir.join("hook-trace.log");
-        if std::fs::metadata(&path).map(|m| m.len() > 512 * 1024).unwrap_or(false) {
-            let _ = std::fs::write(&path, b"");
-        }
-        let ts = std::time::SystemTime::now()
-            .duration_since(std::time::UNIX_EPOCH)
-            .map(|d| d.as_millis())
-            .unwrap_or(0);
-        use std::io::Write;
-        if let Ok(mut f) = std::fs::OpenOptions::new().create(true).append(true).open(&path) {
-            let _ = writeln!(f, "[{ts} pid {}] {msg}", std::process::id());
-        }
-    }
-
-    /// Resolve the `spt` binary: PATH first (post-bootstrap), then known install locations.
-    fn spt_bin() -> String {
-        if which("spt") {
-            return "spt".to_string();
-        }
-        let home = std::env::var("HOME").unwrap_or_default();
-        let local = std::env::var("LOCALAPPDATA").unwrap_or_default();
-        for p in [
-            format!("{home}/.local/bin/spt"),
-            format!("{local}/spt-core/bin/spt.exe"),
-            format!("{home}/AppData/Local/spt-core/bin/spt.exe"),
-        ] {
-            if std::path::Path::new(&p).is_file() {
-                return p;
-            }
-        }
-        "spt".to_string() // last resort; the caller tolerates failure
-    }
-}
-
-/// Is `name` resolvable on PATH? (cross-platform `command -v`).
-fn which(name: &str) -> bool {
-    let path = std::env::var_os("PATH").unwrap_or_default();
-    let exts: Vec<String> = if cfg!(windows) {
-        std::env::var("PATHEXT")
-            .unwrap_or_else(|_| ".EXE;.CMD;.BAT;.COM".into())
-            .split(';')
-            .map(|e| e.to_ascii_lowercase())
-            .collect()
-    } else {
-        vec![String::new()]
-    };
-    for dir in std::env::split_paths(&path) {
-        let cand = dir.join(name);
-        if cand.is_file() {
-            return true;
-        }
-        for ext in &exts {
-            if ext.is_empty() {
-                continue;
-            }
-            if dir.join(format!("{name}{ext}")).is_file() {
-                return true;
-            }
-        }
-    }
-    false
-}
-
-impl HookEnv for SysEnv {
-    fn spt(&mut self, args: &[&str], stdin: Option<&str>, extra_env: &[(&str, &str)]) -> Option<String> {
-        use std::io::Write;
-        use std::process::{Command, Stdio};
-        let mut cmd = Command::new(SysEnv::spt_bin());
-        cmd.args(args);
-        for (k, val) in extra_env {
-            cmd.env(k, val);
-        }
-        cmd.stdout(Stdio::piped()).stderr(Stdio::null());
-        cmd.stdin(if stdin.is_some() { Stdio::piped() } else { Stdio::null() });
-        let mut child = cmd.spawn().ok()?;
-        if let Some(s) = stdin {
-            if let Some(mut si) = child.stdin.take() {
-                let _ = si.write_all(s.as_bytes());
-            }
-        }
-        let out = child.wait_with_output().ok()?;
-        let mut s = String::from_utf8_lossy(&out.stdout).into_owned();
-        // Match shell `$(…)`: strip ALL trailing newlines.
-        while s.ends_with('\n') || s.ends_with('\r') {
-            s.pop();
-        }
-        Some(s)
-    }
-
-    fn spt_send(&mut self, args: &[&str], stdin: Option<&str>) -> Option<String> {
-        use std::io::Write;
-        use std::process::{Command, Stdio};
-        let mut cmd = Command::new(SysEnv::spt_bin());
-        cmd.args(args);
-        // Capture BOTH streams: `spt send`'s SENT/QUEUED/DEFERRED/NO_PERCH token is on stderr.
-        cmd.stdout(Stdio::piped()).stderr(Stdio::piped());
-        cmd.stdin(if stdin.is_some() { Stdio::piped() } else { Stdio::null() });
-        let mut child = cmd.spawn().ok()?;
-        if let Some(s) = stdin {
-            if let Some(mut si) = child.stdin.take() {
-                let _ = si.write_all(s.as_bytes());
-            }
-        }
-        let out = child.wait_with_output().ok()?;
-        // Merge stdout then stderr so `send_landed`'s prefix check finds the token wherever spt-core
-        // emits it (today: stderr, stdout empty). Strip ALL trailing newlines, matching `spt`.
-        let mut s = String::from_utf8_lossy(&out.stdout).into_owned();
-        s.push_str(&String::from_utf8_lossy(&out.stderr));
-        while s.ends_with('\n') || s.ends_with('\r') {
-            s.pop();
-        }
-        Some(s)
-    }
-
-    fn spt_strict(&mut self, args: &[&str]) -> Result<String, String> {
-        use std::process::{Command, Stdio};
-        let mut cmd = Command::new(SysEnv::spt_bin());
-        cmd.args(args);
-        cmd.stdout(Stdio::piped()).stderr(Stdio::piped()).stdin(Stdio::null());
-        let out = match cmd.output() {
-            Ok(o) => o,
-            Err(e) => return Err(format!("spt could not be spawned: {e}")),
-        };
-        if out.status.success() {
-            let mut s = String::from_utf8_lossy(&out.stdout).into_owned();
-            while s.ends_with('\n') || s.ends_with('\r') {
-                s.pop();
-            }
-            Ok(s)
-        } else {
-            let err = String::from_utf8_lossy(&out.stderr).trim().to_string();
-            if err.is_empty() {
-                Err(format!("exit {}", out.status.code().unwrap_or(-1)))
-            } else {
-                Err(err)
-            }
-        }
-    }
-
-    fn emit(&mut self, text: &str) {
-        use std::io::Write;
-        let mut so = std::io::stdout();
-        let _ = so.write_all(text.as_bytes());
-        let _ = so.flush();
-    }
-
-    fn log(&mut self, msg: &str) {
-        eprintln!("{msg}");
-        // Tee to a rolling file beside the binary so hook activity is READABLE off an spt-hosted
-        // broker session: CC hides/discards hook stderr, and the daemon captures only the stderr of
-        // adapters IT spawns (psyche/echo-commune), never CC-hook stderr — the Step-0 blind spot
-        // (2026-07-08, v0.16.1). Best-effort; a failure here never fails the hook.
-        SysEnv::append_trace(msg);
-    }
-
-    fn read_adapter_state(&self, rel: &str) -> Option<String> {
-        let dir = std::env::current_exe().ok()?.parent()?.to_path_buf();
-        let s = std::fs::read_to_string(dir.join(rel)).ok()?;
-        let t = s.trim().to_string();
-        if t.is_empty() { None } else { Some(t) }
-    }
-
-    fn write_adapter_state(&mut self, rel: &str, content: &str) -> bool {
-        let Ok(exe) = std::env::current_exe() else { return false };
-        let Some(dir) = exe.parent() else { return false };
-        let path = dir.join(rel);
-        if let Some(parent) = path.parent() {
-            if std::fs::create_dir_all(parent).is_err() {
-                return false;
-            }
-        }
-        std::fs::write(&path, content).is_ok()
-    }
-
-    fn write_spill(&mut self, path: &str, content: &str) -> bool {
-        std::fs::write(path, content).is_ok()
-    }
-
-    fn read_file_tail(&self, path: &str, offset: u64) -> Option<(String, u64)> {
-        use std::io::{Read, Seek, SeekFrom};
-        let mut f = std::fs::File::open(path).ok()?;
-        let len = f.metadata().ok()?.len();
-        let start = if len < offset { 0 } else { offset };
-        f.seek(SeekFrom::Start(start)).ok()?;
-        let mut buf = Vec::new();
-        f.read_to_end(&mut buf).ok()?;
-        Some((String::from_utf8_lossy(&buf).into_owned(), start))
-    }
-
-    fn append_env_file(&mut self, line: &str) {
-        use std::io::Write;
-        if let Ok(path) = std::env::var("CLAUDE_ENV_FILE") {
-            if !path.is_empty() {
-                if let Ok(mut f) = std::fs::OpenOptions::new().create(true).append(true).open(&path) {
-                    let _ = writeln!(f, "{line}");
-                }
-            }
-        }
-    }
-
-    fn env(&self, key: &str) -> Option<String> {
-        std::env::var(key).ok()
-    }
-
-    fn host_pid(&self) -> Option<String> {
-        self.host_pid.clone()
-    }
-
-    fn home(&self) -> String {
-        std::env::var("HOME")
-            .or_else(|_| std::env::var("USERPROFILE"))
-            .unwrap_or_else(|_| ".".to_string())
-    }
-
-    fn cap(&self) -> usize {
-        std::env::var("SPTC_CTX_CAP").ok().and_then(|s| s.parse().ok()).unwrap_or(DEFAULT_CAP)
-    }
-}
-
-/// The CC hook event names this binary handles — the SINGLE source of truth, shared by [`dispatch`]
-/// and the stale-dispatch pass-through recognizer [`is_cc_hook_event`] that `main` uses to DEGRADE
-/// (not brick) when a stale plugin dispatch.sh execs `claude-spt <Event>` without the `hook` token.
-/// [impl->REQ-HAZARD-HOOKCMD-DISPATCH-LOCKSTEP]
-pub const CC_HOOK_EVENTS: &[&str] = &[
-    "SessionStart",
-    "UserPromptSubmit",
-    "PreToolUse",
-    "Stop",
-    "SessionEnd",
-    "SubagentStart",
-    "SubagentStop",
-    "PostToolUse",
-    "PostToolUseFailure",
-    "Notification",
-    "StopFailure",
-];
-
-/// True if `name` is a CC hook event this binary handles. `main` uses this to recognise the
-/// stale-dispatch skew (a bare `claude-spt UserPromptSubmit` — the `hook` token dropped by an old
-/// plugin dispatch.sh) and route it through as a hook instead of exiting nonzero → blocking CC.
-/// [impl->REQ-HAZARD-HOOKCMD-DISPATCH-LOCKSTEP]
-pub fn is_cc_hook_event(name: &str) -> bool {
-    CC_HOOK_EVENTS.contains(&name)
-}
-
-/// Is this process running under the echo-commune recursion guard? Pure over the env VALUE so
-/// the decision is unit-testable without env races: set-and-non-empty = guarded (an empty var
-/// is treated as unset — shells export empties by accident). [impl->REQ-SESSION-ECHO-COMMUNE]
-fn echo_commune_guarded(val: Option<&str>) -> bool {
-    val.is_some_and(|v| !v.is_empty())
-}
-
-/// `claude-spt hook <event> [--host-pid <pid>]` entry. Reads the CC hook payload from stdin, parses
-/// it once, and dispatches to the event handler. A missing event or unparseable stdin is a silent
-/// no-op exit 0 (a hook must never break the CC session). [impl->REQ-DIST-HOOK-BINARY]
-pub fn run() -> ExitCode {
-    let Some(event) = std::env::args().nth(2) else {
-        // skip "claude-spt" + "hook"
-        eprintln!("claude-spt hook: missing <event>");
-        return ExitCode::SUCCESS;
-    };
-    run_event(&event)
-}
-
-/// Handle a CC hook `event` given the event name explicitly. Scans argv for `--host-pid`
-/// POSITION-INDEPENDENTLY so it serves both the normal `claude-spt hook <event> --host-pid <pid>`
-/// path and the stale-dispatch pass-through `claude-spt <event> --host-pid <pid>` (where the `hook`
-/// token is missing, so a fixed `skip(2)` would mis-read the event). Reads the CC hook payload from
-/// stdin; always exits 0 — a hook must never break the CC session.
-/// [impl->REQ-DIST-HOOK-BINARY] [impl->REQ-HAZARD-HOOKCMD-DISPATCH-LOCKSTEP]
-pub fn run_event(event: &str) -> ExitCode {
-    // RECURSION-GUARD BAIL (REQ-SESSION-ECHO-COMMUNE): core sets SPT_ECHO_COMMUNE on the
-    // echo-commune summarizer (recursion_guard_env), and the claude that shim spawns inherits
-    // it. That inner session's hooks must do NOTHING — no api seed/bind, no perch stamps, no
-    // sessions.log writes — or the summarizer would rebind/stomp the very perch it is
-    // summarizing (and could recurse: summarizer → session end → summarizer). Exit 0 before
-    // reading stdin so the bail can never block or slow the inner session.
-    if echo_commune_guarded(std::env::var("SPT_ECHO_COMMUNE").ok().as_deref()) {
-        return ExitCode::SUCCESS;
-    }
-    let mut host_pid: Option<String> = None;
-    let mut it = std::env::args();
-    while let Some(a) = it.next() {
-        if a == "--host-pid" {
-            host_pid = it.next();
-        }
-    }
-
-    let mut input = String::new();
-    let _ = std::io::stdin().read_to_string(&mut input);
-    let v: Value = serde_json::from_str(input.trim()).unwrap_or(Value::Null);
-
-    let mut env = SysEnv { host_pid };
-    dispatch(&mut env, event, &v);
-    ExitCode::SUCCESS
-}
-
-// ─────────────────────────── tests ───────────────────────────
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use serde_json::json;
-
-    // ---- pure helpers (port of tests/hooks-parse.sh coverage) ----
-
-    // [unit->REQ-SESSION-ECHO-COMMUNE]
-    #[test]
-    fn echo_commune_guard_set_and_nonempty_only() {
-        // Guarded ⟺ SPT_ECHO_COMMUNE set AND non-empty: the summarizer's inner claude session
-        // must run ZERO hook logic (no seed/bind/perch writes); an accidentally-exported empty
-        // var must NOT silence a real agent's hooks.
-        assert!(echo_commune_guarded(Some("1")));
-        assert!(echo_commune_guarded(Some("sess-guard")));
-        assert!(!echo_commune_guarded(Some("")));
-        assert!(!echo_commune_guarded(None));
-    }
-
-    #[test]
-    fn field_and_nested_extraction() {
-        let v = json!({"session_id":"s1","prompt":"/sptc:send doyle","tool_input":{"file_path":"/x/p.md","content":"c"}});
-        assert_eq!(field(&v, "session_id"), "s1");
-        assert_eq!(field(&v, "prompt"), "/sptc:send doyle");
-        assert_eq!(field(&v, "nope"), "");
-        assert_eq!(nested(&v, "tool_input", "file_path"), "/x/p.md");
-        assert_eq!(nested(&v, "tool_input", "content"), "c");
-        assert_eq!(nested(&v, "tool_input", "nope"), "");
-    }
-
-    // [unit->REQ-UPS-INJECTION]
-    #[test]
-    fn unescape_br_entities_amp_last() {
-        assert_eq!(unescape("a &lt;b&gt;<br>&quot;c&quot; &amp; &amp;lt;"), "a <b>\n\"c\" & &lt;");
-    }
-
-    // [unit->REQ-UPS-INJECTION]
-    #[test]
-    fn render_frames_named_entity_multi_nofrom_empty() {
-        assert_eq!(
-            render_frames("<EVENT type=\"msg\" from=\"doyle\">hello<br>world</EVENT>"),
-            "<sptc_messages from=\"doyle\">\nhello\nworld\n</sptc_messages>"
-        );
-        assert_eq!(
-            render_frames("<EVENT type=\"msg\" from=\"kit\">a &lt;tag&gt; &amp; b</EVENT>"),
-            "<sptc_messages from=\"kit\">\na <tag> & b\n</sptc_messages>"
-        );
-        assert_eq!(
-            render_frames("<EVENT type=\"msg\" from=\"a\">one</EVENT><EVENT type=\"msg\" from=\"b\">two</EVENT>"),
-            "<sptc_messages from=\"a\">\none\n</sptc_messages>\n<sptc_messages from=\"b\">\ntwo\n</sptc_messages>"
-        );
-        assert_eq!(
-            render_frames("<EVENT type=\"msg\">sys note</EVENT>"),
-            "<sptc_messages>\nsys note\n</sptc_messages>"
-        );
-        assert_eq!(render_frames(""), "");
-    }
-
-    // [unit->REQ-HAZARD-DANGLING-FRAME-LOUD]
-    #[test]
-    fn render_frames_dangling_frame_is_loud_never_silent() {
-        // Body with no closing tag: partial content surfaces in the marker, sender included.
-        let r = render_frames("<EVENT type=\"msg\" from=\"doyle\">head of a cut message");
-        assert!(r.starts_with("<sptc_frame_integrity bytes=\"52\">"));
-        assert!(r.contains("from=\"doyle\""));
-        assert!(r.contains("head of a cut message"));
-        assert!(r.contains("spool.db"));
-        // Mangled opening (no '>'): raw remainder surfaces.
-        let r = render_frames("<EVENT type=\"msg\" fr");
-        assert!(r.contains("<sptc_frame_integrity"));
-        assert!(r.contains("<EVENT type=\"msg\" fr"));
-        // Complete frame then a dangling one: the good frame still renders, then the marker.
-        let r = render_frames("<EVENT type=\"msg\" from=\"a\">one</EVENT><EVENT type=\"msg\" from=\"b\">cut ta");
-        assert!(r.starts_with("<sptc_messages from=\"a\">\none\n</sptc_messages>\n<sptc_frame_integrity"));
-        assert!(r.contains("cut ta"));
-        // Entities in the surviving partial body are unescaped like a normal body.
-        let r = render_frames("<EVENT type=\"msg\" from=\"a\">a &lt;tag&gt; cut");
-        assert!(r.contains("a <tag> cut"));
-    }
-
-    // [unit->REQ-HAZARD-DANGLING-FRAME-LOUD]
-    #[test]
-    fn render_frames_orphaned_head_tail_is_loud_and_clean_input_is_not() {
-        // Head-truncated poll output: orphaned tail (no opening tag) before a complete frame.
-        let r = render_frames("pply under my ccs instance</EVENT><EVENT type=\"msg\" from=\"b\">two</EVENT>");
-        assert!(r.starts_with("<sptc_frame_integrity"));
-        assert!(r.contains("pply under my ccs instance"));
-        assert!(r.contains("<sptc_messages from=\"b\">\ntwo\n</sptc_messages>"));
-        // Orphaned tail alone (whole poll output is a frame's tail).
-        let r = render_frames("only a tail survives</EVENT>");
-        assert!(r.contains("<sptc_frame_integrity"));
-        assert!(r.contains("only a tail survives"));
-        // Clean inputs never grow a marker; plain non-frame garbage stays silent (no </EVENT>).
-        assert!(!render_frames("<EVENT type=\"msg\" from=\"a\">one</EVENT>").contains("sptc_frame_integrity"));
-        assert_eq!(render_frames("no frames here"), "");
-    }
-
-    // [unit->REQ-UPS-INJECTION]
-    #[test]
-    fn skill_key_cases() {
-        assert_eq!(skill_key("/sptc:ready"), "ready");
-        assert_eq!(skill_key("/sptc:send doyle hi"), "send");
-        assert_eq!(skill_key("   /sptc:setup"), "setup");
-        assert_eq!(skill_key("/sptc:list-agents"), "list-agents");
-        assert_eq!(skill_key("please run /sptc:ready for me"), "");
-        assert_eq!(skill_key("/other:ready"), "");
-        assert_eq!(skill_key("ready set go"), "");
-        assert_eq!(skill_key(""), "");
-    }
-
-    // [unit->REQ-DIST-SHORTCUT-BASENAME]
-    #[test]
-    fn register_verb_branches() {
-        assert_eq!(register_verb("startup", false), "seed");
-        assert_eq!(register_verb("", false), "seed");
-        assert_eq!(register_verb("clear", false), "boundary");
-        assert_eq!(register_verb("compact", false), "boundary");
-        assert_eq!(register_verb("startup", true), "bind");
-        assert_eq!(register_verb("clear", true), "boundary"); // boundary wins even when spt-hosted
-    }
-
-    // [unit->REQ-UPS-INJECTION]
-    #[test]
-    fn cap_decide_thresholds() {
-        assert!(matches!(cap_decide("small body", 9000), Cap::Inline(t) if t == "small body"));
-        assert!(matches!(cap_decide("abcdefghij", 5), Cap::Overflow { len: 10 }));
-        assert!(matches!(cap_decide("", 5), Cap::Empty));
-    }
-
-    // [unit->REQ-DIST-SESSIONSTART-BRIEF]
-    #[test]
-    fn assemble_perch_structure_and_global_subst() {
-        assert_eq!(
-            assemble_perch("perri", "you are {id}.", "send body", "roster line"),
-            "<sptc-active-perch id=\"perri\">\nyou are perri.\n\nsend body\n\nroster line\n</sptc-active-perch>"
-        );
-        let multi = assemble_perch("kit", "a {id} b {id}", "m", "r");
-        assert!(multi.contains("a kit b kit"), "global subst");
-        assert!(!multi.contains("{id}"), "no leftover");
-    }
-
-    // [unit->REQ-DIST-SESSIONSTART-BRIEF]
-    #[test]
-    fn assemble_noperch_structure() {
-        assert_eq!(
-            assemble_noperch("ring body", "roster line"),
-            "<sptc-reach>\nring body\n\nroster line\n</sptc-reach>"
-        );
-    }
-
-    // [unit->REQ-DIST-SESSIONSTART-BRIEF]
-    #[test]
-    fn is_subagent_and_peers() {
-        assert!(!is_subagent(""));
-        assert!(is_subagent("general-purpose"));
-        assert!(has_peers("SUBNET NODES ENDPOINTS\nSPT_DEV 3 4\n"));
-        assert!(!has_peers("no subnets\n"));
-        assert!(!has_peers(""));
-    }
-
-    // [unit->REQ-DIST-SESSIONSTART-BRIEF]
-    #[test]
-    fn json_escape_and_emit() {
-        assert_eq!(json_escape("say \"hi\""), "say \\\"hi\\\"");
-        assert_eq!(json_escape("a\\b"), "a\\\\b");
-        assert_eq!(json_escape("a\nb"), "a\\nb");
-        assert_eq!(emit_additional_context(""), "");
-        assert_eq!(
-            emit_additional_context("hi \"x\""),
-            "{\"hookSpecificOutput\":{\"hookEventName\":\"SessionStart\",\"additionalContext\":\"hi \\\"x\\\"\"}}\n"
-        );
-        assert_eq!(
-            emit_additional_context("a\nb"),
-            "{\"hookSpecificOutput\":{\"hookEventName\":\"SessionStart\",\"additionalContext\":\"a\\nb\"}}\n"
-        );
-    }
-
-    // [unit->REQ-DIST-CHECKPOINT-COMMUNE]
-    #[test]
-    fn checkpoint_detect_and_wake() {
-        assert!(has_checkpoint("delta ... !!checkpoint!!"));
-        assert!(has_checkpoint("!!checkpoint!! wake !!checkpoint!!"));
-        assert!(!has_checkpoint("an ordinary commune delta"));
-        assert!(!has_checkpoint(""));
-        assert_eq!(checkpoint_wake("work ... !!checkpoint!!"), ""); // single → default
-        assert_eq!(checkpoint_wake("body !!checkpoint!! Resume T2c now !!checkpoint!! more"), "Resume T2c now");
-        assert_eq!(checkpoint_wake("delta\n!!checkpoint!! wire the hook !!checkpoint!!\nend"), "wire the hook");
-        assert_eq!(checkpoint_wake("no markers here"), "");
-    }
-
-    // [unit->REQ-DIST-CHECKPOINT-COMMUNE]
-    #[test]
-    fn commune_write_guard() {
-        assert!(is_commune_write("Write", "/home/x/.claude/perri-commune.md", "perri"));
-        assert!(is_commune_write("Write", "C:\\\\Users\\\\d\\\\.claude\\\\perri-commune.md", "perri"));
-        assert!(!is_commune_write("Write", "/home/x/.claude/notes.md", "perri"));
-        assert!(!is_commune_write("Write", "/home/x/.claude/doyle-commune.md", "perri"));
-        assert!(!is_commune_write("Edit", "/home/x/.claude/perri-commune.md", "perri"));
-        assert!(!is_commune_write("Write", "/home/x/.claude/perri-commune.md", ""));
-    }
-
-    // [unit->REQ-DIST-CHECKPOINT-COMMUNE]
-    #[test]
-    fn checkpoint_payload_shape() {
-        assert_eq!(checkpoint_payload(""), "{\"checkpoint\":\"v1\"}");
-        assert_eq!(checkpoint_payload("Resume now"), "{\"checkpoint\":\"v1\",\"wake\":\"Resume now\"}");
-        assert_eq!(checkpoint_payload("a\"b"), "{\"checkpoint\":\"v1\",\"wake\":\"a\\\"b\"}");
-    }
-
-    // [unit->REQ-DIST-RESUME-CONTEXT]
-    #[test]
-    fn append_resume_cases() {
-        assert_eq!(append_resume("<brief/>", "<live-context>ctx</live-context>"), "<brief/>\n<live-context>ctx</live-context>");
-        assert_eq!(append_resume("<brief/>", ""), "<brief/>");
-        assert_eq!(append_resume("", ""), "");
-    }
-
-    // ---- recorder-driven handler tests (ordering / gating / emitted output) ----
-
-    /// A recording [`HookEnv`]: serves canned `spt` output via a responder keyed on the full argv,
-    /// records every `spt` call (args only) and every emit, and captures the latest spill.
-    struct Recorder {
-        responder: Box<dyn Fn(&[&str]) -> Option<String>>,
-        /// Optional distinct responder for `spt_send` (stdout+stderr merged). When None, `spt_send`
-        /// falls back to `responder`. Lets a test model the field bug: `spt` (stdout) returns "" while
-        /// `spt_send` (merged) returns the stderr status token.
-        send_responder: Option<Box<dyn Fn(&[&str]) -> Option<String>>>,
-        strict_err: Option<String>,
-        calls: Vec<Vec<String>>,
-        /// The stdin passed to each recorded `spt`/`spt_send` call, parallel to `calls` (None = no stdin).
-        stdins: Vec<Option<String>>,
-        emitted: Vec<String>,
-        spills: Vec<(String, String)>,
-        env_lines: Vec<String>,
-        envs: std::collections::HashMap<String, String>,
-        logs: Vec<String>,
-        state: std::collections::HashMap<String, String>,
-        state_writes: Vec<(String, String)>,
-        files: std::collections::HashMap<String, String>,
-        host_pid: Option<String>,
-        cap: usize,
-    }
-
-    impl Recorder {
-        fn new(responder: impl Fn(&[&str]) -> Option<String> + 'static) -> Self {
-            Recorder {
-                responder: Box::new(responder),
-                send_responder: None,
-                strict_err: None,
-                calls: Vec::new(),
-                stdins: Vec::new(),
-                emitted: Vec::new(),
-                spills: Vec::new(),
-                env_lines: Vec::new(),
-                envs: std::collections::HashMap::new(),
-                logs: Vec::new(),
-                state: std::collections::HashMap::new(),
-                state_writes: Vec::new(),
-                files: std::collections::HashMap::new(),
-                host_pid: Some("4242".into()),
-                cap: 9000,
-            }
-        }
-        /// Preload a file readable by `read_file_tail` (e.g. a synthetic CC transcript).
-        fn with_file(mut self, path: &str, content: &str) -> Self {
-            self.files.insert(path.into(), content.into());
-            self
-        }
-        fn with_env(mut self, k: &str, v: &str) -> Self {
-            self.envs.insert(k.into(), v.into());
-            self
-        }
-        /// Preload an adapter-state file (e.g. the prior-sid rotation proof).
-        fn with_state(mut self, rel: &str, content: &str) -> Self {
-            self.state.insert(rel.into(), content.into());
-            self
-        }
-        /// Make every `spt_strict` call fail with this diagnostic (the AUTH_REFUSED shape).
-        fn with_strict_err(mut self, err: &str) -> Self {
-            self.strict_err = Some(err.into());
-            self
-        }
-        /// Serve a DISTINCT canned result for `spt_send` (stdout+stderr merged), independent of the
-        /// stdout-only `spt` responder — models `spt send`'s stderr-borne status token.
-        fn with_send_responder(mut self, r: impl Fn(&[&str]) -> Option<String> + 'static) -> Self {
-            self.send_responder = Some(Box::new(r));
-            self
-        }
-        /// The stdin body recorded for the first call whose argv joins to `argv` (None if unmatched or
-        /// no stdin). Used to assert the confirm-back body (delivered vs NO PERCH).
-        fn stdin_for(&self, argv: &str) -> Option<String> {
-            self.calls.iter().position(|c| c.join(" ") == argv).and_then(|i| self.stdins[i].clone())
-        }
-        /// The recorded `spt` call argv strings joined for readable assertions.
-        fn call_lines(&self) -> Vec<String> {
-            self.calls.iter().map(|c| c.join(" ")).collect()
-        }
-        fn out(&self) -> String {
-            self.emitted.concat()
-        }
-    }
-
-    impl HookEnv for Recorder {
-        fn spt(&mut self, args: &[&str], stdin: Option<&str>, _extra_env: &[(&str, &str)]) -> Option<String> {
-            self.calls.push(args.iter().map(|s| s.to_string()).collect());
-            self.stdins.push(stdin.map(str::to_string));
-            (self.responder)(args)
-        }
-        fn spt_send(&mut self, args: &[&str], stdin: Option<&str>) -> Option<String> {
-            self.calls.push(args.iter().map(|s| s.to_string()).collect());
-            self.stdins.push(stdin.map(str::to_string));
-            match &self.send_responder {
-                Some(r) => r(args),
-                None => (self.responder)(args),
-            }
-        }
-        fn spt_strict(&mut self, args: &[&str]) -> Result<String, String> {
-            self.calls.push(args.iter().map(|s| s.to_string()).collect());
-            self.stdins.push(None);
-            match &self.strict_err {
-                Some(e) => Err(e.clone()),
-                None => Ok((self.responder)(args).unwrap_or_default()),
-            }
-        }
-        fn emit(&mut self, text: &str) {
-            self.emitted.push(text.to_string());
-        }
-        fn log(&mut self, msg: &str) {
-            self.logs.push(msg.to_string());
-        }
-        fn read_adapter_state(&self, rel: &str) -> Option<String> {
-            self.state.get(rel).cloned().filter(|s| !s.trim().is_empty())
-        }
-        fn write_adapter_state(&mut self, rel: &str, content: &str) -> bool {
-            self.state_writes.push((rel.to_string(), content.to_string()));
-            self.state.insert(rel.to_string(), content.to_string());
-            true
-        }
-        fn write_spill(&mut self, path: &str, content: &str) -> bool {
-            self.spills.push((path.to_string(), content.to_string()));
-            true
-        }
-        fn read_file_tail(&self, path: &str, offset: u64) -> Option<(String, u64)> {
-            let content = self.files.get(path)?;
-            let len = content.len() as u64;
-            let start = if len < offset { 0 } else { offset };
-            Some((content[start as usize..].to_string(), start))
-        }
-        fn append_env_file(&mut self, line: &str) {
-            self.env_lines.push(line.to_string());
-        }
-        fn env(&self, key: &str) -> Option<String> {
-            self.envs.get(key).cloned()
-        }
-        fn host_pid(&self) -> Option<String> {
-            self.host_pid.clone()
-        }
-        fn home(&self) -> String {
-            "/home/x".to_string()
-        }
-        fn cap(&self) -> usize {
-            self.cap
-        }
-    }
-
-    // [unit->REQ-DIST-WHOAMI-JSON] the doyle bug (2026-07-01): a node with subnet membership makes
-    // the HUMAN whoami/list view start with a "SUBNET <name>" header — first-line parsing crowned
-    // the agent "SUBNET SPT_DEV" and the injected brief forbade running whoami, so the wrong
-    // identity self-reinforced. The load-bearing regression: human-roster input resolves EMPTY.
-    #[test]
-    fn whoami_human_roster_is_never_an_id() {
-        let human = "SUBNET SPT_DEV\n  hall-a  HFENDULEAM (14efb80c…)  ■ ONLINE\nSUBNET BIGNET\n  hall-a  HFENDULEAM (14efb80c…)  ■ ONLINE\nENDPOINTS:2\nThis node: HFENDULEAM (14efb80c…)\n  (no local perches)";
-        assert_eq!(parse_whoami_self(human), "", "a grouped roster header must resolve to no-perch");
-        // The perched human shape must not leak either — only --json is the contract.
-        let perched = "SELF: perri  live_agent  ready=true alive=true\nSUBNET SPT_DEV\n  …";
-        assert_eq!(parse_whoami_self(perched), "", "human SELF line is not the contract");
-    }
-
-    // [unit->REQ-DIST-WHOAMI-JSON] the --json contract: .self.id when perched, "" on self:null,
-    // "" on garbage (defensive — a pre-JSON binary or a transport error must read as no-perch).
-    #[test]
-    fn whoami_json_self_id_contract() {
-        assert_eq!(
-            parse_whoami_self(r#"{"self":{"id":"doyle","status":"live_agent","ready":true,"alive":true},"subnets":[]}"#),
-            "doyle"
-        );
-        assert_eq!(parse_whoami_self(r#"{"self":null,"subnets":[{"name":"SPT_DEV"}]}"#), "");
-        assert_eq!(parse_whoami_self(""), "");
-        assert_eq!(parse_whoami_self("ERROR: daemon unreachable"), "");
-        assert_eq!(parse_whoami_self(r#"{"subnets":[]}"#), "", "missing self key reads as no-perch");
-    }
-
-    // [unit->REQ-DIST-PRETOOL-POLL]
-    #[test]
-    fn ups_marks_busy_before_drain_and_includes_deferred() {
-        let mut env = Recorder::new(|args| match args {
-            ["whoami", "--json"] => Some(r#"{"self":{"id":"perri","status":"live_agent","ready":true,"alive":true}}"#.into()),
-            a if a.contains(&"poll") => Some("<EVENT type=\"msg\" from=\"doyle\">hi</EVENT>".into()),
-            _ => Some(String::new()),
-        });
-        handle_user_prompt_submit(&mut env, &json!({"session_id":"s1","prompt":"hello"}));
-        let lines = env.call_lines();
-        let busy = lines.iter().position(|l| l.contains("state busy")).expect("busy");
-        let poll = lines.iter().position(|l| l.contains("poll")).expect("poll");
-        assert!(busy < poll, "busy must precede the drain");
-        assert!(lines[poll].contains("--include-deferred"), "drain includes deferred");
-        assert!(env.out().contains("<sptc_messages from=\"doyle\">"), "rendered drain emitted");
-    }
-
-    #[test]
-    fn ups_skill_injection_without_perch() {
-        // No perch (whoami empty) → no busy/poll, but the skill body still injects.
-        let mut env = Recorder::new(|args| match args {
-            ["whoami", "--json"] => Some(r#"{"self":null,"subnets":[]}"#.into()),
-            ["adapter", "get-string", _, key] if *key == "skills.ready" => Some("# /sptc:ready\nbody".into()),
-            _ => Some(String::new()),
-        });
-        handle_user_prompt_submit(&mut env, &json!({"session_id":"s1","prompt":"/sptc:ready go"}));
-        assert!(env.out().starts_with("<sptc_skill name=\"ready\">\n# /sptc:ready"), "skill injected");
-        assert!(!env.call_lines().iter().any(|l| l.contains("poll")), "no drain without a perch");
-    }
-
-    // [unit->REQ-DIST-REACHABILITY-NOTICE]
-    #[test]
-    fn ups_appends_reachability_notice_on_perched_turns_only() {
-        // Perched: the notice closes EVERY UserPromptSubmit (legacy-owl always-append, spt-renamed).
-        let mut env = Recorder::new(|args| match args {
-            ["whoami", "--json"] => Some(r#"{"self":{"id":"perri","status":"live_agent","ready":true,"alive":true}}"#.into()),
-            _ => Some(String::new()),
-        });
-        handle_user_prompt_submit(&mut env, &json!({"session_id":"s1","prompt":"hello"}));
-        assert!(env.out().contains("<spt_reachability_notice>"), "notice on a perched turn: {}", env.out());
-        assert!(env.out().contains("run_in_background: true"), "steers to background");
-
-        // No perch: no notice (a plain CC session must not be told it has a perch).
-        let mut env2 = Recorder::new(|args| match args {
-            ["whoami", "--json"] => Some(r#"{"self":null,"subnets":[]}"#.into()),
-            _ => Some(String::new()),
-        });
-        handle_user_prompt_submit(&mut env2, &json!({"session_id":"s1","prompt":"hello"}));
-        assert!(!env2.out().contains("<spt_reachability_notice>"), "no perch, no notice");
-    }
-
-    // [unit->REQ-DIST-REACHABILITY-NOTICE]
-    #[test]
-    fn ups_notice_rides_after_drained_messages() {
-        // Messages first, notice last — the notice never displaces or precedes a delivery.
-        let mut env = Recorder::new(|args| match args {
-            ["whoami", "--json"] => Some(r#"{"self":{"id":"perri","status":"live_agent","ready":true,"alive":true}}"#.into()),
-            a if a.contains(&"poll") => Some("<EVENT type=\"msg\" from=\"doyle\">hi</EVENT>".into()),
-            _ => Some(String::new()),
-        });
-        handle_user_prompt_submit(&mut env, &json!({"session_id":"s1","prompt":"hello"}));
-        let out = env.out();
-        let msg = out.find("<sptc_messages").expect("messages present");
-        let notice = out.find("<spt_reachability_notice>").expect("notice present");
-        assert!(msg < notice, "messages precede the notice: {out}");
-    }
-
-    // [unit->REQ-DIST-REACHABILITY-NOTICE]
-    #[test]
-    fn pre_tool_use_agent_spawn_gets_the_nudge_other_tools_do_not() {
-        // Agent tool + empty drain → the nudge alone still emits (the whole point: catch the
-        // foreground spawn BEFORE it happens, messages or not).
-        let mut env = Recorder::new(|args| match args {
-            ["whoami", "--json"] => Some(r#"{"self":{"id":"perri","status":"live_agent","ready":true,"alive":true}}"#.into()),
-            _ => Some(String::new()),
-        });
-        handle_pre_tool_use(&mut env, &json!({"session_id":"s1","tool_name":"Agent"}));
-        assert!(env.out().contains("<spt_reachability_notice>"), "Agent spawn nudged: {}", env.out());
-        assert!(env.out().contains("run_in_background: true"));
-
-        // Non-spawn tool + empty drain → silent (no per-Bash noise).
-        let mut env2 = Recorder::new(|args| match args {
-            ["whoami", "--json"] => Some(r#"{"self":{"id":"perri","status":"live_agent","ready":true,"alive":true}}"#.into()),
-            _ => Some(String::new()),
-        });
-        handle_pre_tool_use(&mut env2, &json!({"session_id":"s1","tool_name":"Bash"}));
-        assert!(env2.out().is_empty(), "no nudge for non-spawn tools: {}", env2.out());
-    }
-
-    // [unit->REQ-DIST-REACHABILITY-NOTICE]
-    #[test]
-    fn agent_spawn_tool_matcher_covers_both_cc_names() {
-        assert!(is_agent_spawn_tool("Agent"));
-        assert!(is_agent_spawn_tool("Task"));
-        assert!(!is_agent_spawn_tool("Bash"));
-        assert!(!is_agent_spawn_tool(""));
-        assert!(!is_agent_spawn_tool("AgentX"));
-    }
-
-    #[test]
-    fn pre_tool_use_noop_without_perch() {
-        let mut env = Recorder::new(|args| match args {
-            ["whoami", "--json"] => Some(r#"{"self":null,"subnets":[]}"#.into()),
-            _ => Some(String::new()),
-        });
-        handle_pre_tool_use(&mut env, &json!({"session_id":"s1"}));
-        assert!(!env.call_lines().iter().any(|l| l.contains("poll")), "no drain");
-        assert!(env.out().is_empty());
-    }
-
-    // [unit->REQ-DIST-PRETOOL-POLL]
-    #[test]
-    fn pre_tool_use_busy_before_drain() {
-        let mut env = Recorder::new(|args| match args {
-            ["whoami", "--json"] => Some(r#"{"self":{"id":"perri","status":"live_agent","ready":true,"alive":true}}"#.into()),
-            a if a.contains(&"poll") => Some("<EVENT type=\"msg\" from=\"a\">m</EVENT>".into()),
-            _ => Some(String::new()),
-        });
-        handle_pre_tool_use(&mut env, &json!({"session_id":"s1"}));
-        let lines = env.call_lines();
-        let busy = lines.iter().position(|l| l.contains("state busy")).expect("busy");
-        let poll = lines.iter().position(|l| l.contains("poll")).expect("poll");
-        assert!(busy < poll);
-        // The drain rides the PreToolUse hookSpecificOutput envelope (raw stdout is discarded
-        // by CC — the 2026-07-07 black hole). [unit->REQ-HAZARD-PRETOOL-CONTEXT-ENVELOPE]
-        assert!(
-            env.out().starts_with("{\"hookSpecificOutput\":{\"hookEventName\":\"PreToolUse\",\"additionalContext\":\""),
-            "wrapped: {}",
-            env.out()
-        );
-        assert!(env.out().contains("<sptc_messages from=\\\"a\\\">"), "escaped content: {}", env.out());
-    }
-
-    // [unit->REQ-HAZARD-PRETOOL-CONTEXT-ENVELOPE]
-    #[test]
-    fn pretool_envelope_shape_and_escaping() {
-        assert_eq!(wrap_pretool_context(""), "");
-        let w = wrap_pretool_context("line1\nsay \"hi\"");
-        assert_eq!(
-            w,
-            "{\"hookSpecificOutput\":{\"hookEventName\":\"PreToolUse\",\"additionalContext\":\"line1\\nsay \\\"hi\\\"\"}}\n"
-        );
-        let v: serde_json::Value = serde_json::from_str(w.trim()).expect("valid JSON");
-        assert_eq!(
-            v["hookSpecificOutput"]["additionalContext"].as_str().unwrap(),
-            "line1\nsay \"hi\"",
-            "round-trips to the original text"
-        );
-    }
-
-    // [unit->REQ-HAZARD-PRETOOL-CONTEXT-ENVELOPE]
-    #[test]
-    fn pretool_overflow_spills_raw_and_wraps_the_pointer() {
-        // Cap decided on the WRAPPED size: a text just under the cap whose escaped form goes over
-        // must spill, not emit an over-cap line.
-        let mut env = Recorder::new(|args| match args {
-            ["whoami", "--json"] => Some(r#"{"self":{"id":"perri","status":"live_agent","ready":true,"alive":true}}"#.into()),
-            a if a.contains(&"poll") => {
-                Some(format!("<EVENT type=\"msg\" from=\"a\">{}</EVENT>", "x\n".repeat(3000)))
-            }
-            _ => Some(String::new()),
-        });
-        handle_pre_tool_use(&mut env, &json!({"session_id":"s1","tool_name":"Bash"}));
-        let out = env.out();
-        assert!(out.starts_with("{\"hookSpecificOutput\":"), "pointer still wrapped: {out}");
-        assert!(out.contains("sptc_overflow"), "overflow pointer: {out}");
-        assert!(out.len() < 2000, "pointer emit is small, never the over-cap body: {}", out.len());
-        assert!(!env.spills.is_empty(), "raw text spilled to file");
-    }
-
-    #[test]
-    fn stop_marks_idle_when_perched_else_noop() {
-        let mut env = Recorder::new(|args| match args {
-            ["whoami", "--json"] => Some(r#"{"self":{"id":"perri","status":"live_agent","ready":true,"alive":true}}"#.into()),
-            _ => Some(String::new()),
-        });
-        handle_stop(&mut env, &json!({"session_id":"s1"}));
-        assert!(env.call_lines().iter().any(|l| l == "api --adapter claude-spt state idle perri --session-id s1"));
-
-        let mut env2 = Recorder::new(|_| Some(String::new())); // whoami empty
-        handle_stop(&mut env2, &json!({"session_id":"s1"}));
-        assert!(!env2.call_lines().iter().any(|l| l.contains("state idle")));
-    }
-
-    #[test]
-    fn session_start_seed_path_uses_host_pid_and_writes_env() {
-        // No SPT_ENDPOINT_ID, source startup, no peers → seed + env-file writes, no brief.
-        let mut env = Recorder::new(|args| match args {
-            ["subnet", "status"] => Some("no subnets".into()),
-            _ => Some(String::new()),
-        });
-        handle_session_start(&mut env, &json!({"session_id":"s9","source":"startup"}));
-        assert!(env.call_lines().iter().any(|l| l == "api seed --pid 4242 --session-id s9"), "seed by host pid");
-        assert!(env.env_lines.iter().any(|l| l == "OWL_SESSION_ID=s9"));
-        assert!(env.env_lines.iter().any(|l| l == "SPT_ADAPTER=claude-spt"));
-        assert!(env.out().is_empty(), "no brief for a peerless seed");
-    }
-
-    #[test]
-    fn session_start_bind_path_binds_and_briefs() {
-        let mut env = Recorder::new(|args| match args {
-            ["adapter", "get-string", _, k] => Some(format!("[{k}]")), // non-empty brief parts
-            a if a.contains(&"psyche-download") => Some(String::new()), // NO-CONTEXT
-            _ => Some(String::new()),
-        })
-        .with_env("SPT_ENDPOINT_ID", "cc-1");
-        handle_session_start(&mut env, &json!({"session_id":"s1","source":"startup"}));
-        assert!(env.call_lines().iter().any(|l| l == "api --adapter claude-spt bind cc-1 --set-session-id s1"), "bind");
-        let out = env.out();
-        assert!(out.contains("\"hookEventName\":\"SessionStart\""), "emits SessionStart additionalContext");
-        assert!(out.contains("sptc-active-perch id=\\\"cc-1\\\""), "perched identity brief for the endpoint id");
-    }
-
-    // [unit->REQ-HAZARD-RESUME-REBIND-WEDGE] CC's in-TUI /resume re-fires SessionStart(source=resume)
-    // in the SAME broker child (SPT_ENDPOINT_ID still set). The already-bound perch records the
-    // DEPARTED sid; the re-bind must carry it as --session-id ownership proof or core squat-protects
-    // and the perch strands (the /resume wedge).
-    #[test]
-    fn resume_rebind_presents_prior_proof() {
-        let mut env = Recorder::new(|args| match args {
-            ["adapter", "get-string", _, k] => Some(format!("[{k}]")),
-            a if a.contains(&"psyche-download") => Some(String::new()),
-            _ => Some(String::new()),
-        })
-        .with_env("SPT_ENDPOINT_ID", "cc-1")
-        .with_state("state/session/cc-1.sid", "s-old");
-        handle_session_start(&mut env, &json!({"session_id":"s-new","source":"resume"}));
-        assert!(
-            env.call_lines()
-                .iter()
-                .any(|l| l == "api --adapter claude-spt bind cc-1 --set-session-id s-new --session-id s-old"),
-            "resume re-bind carries the departed sid as ownership proof: {:?}",
-            env.call_lines()
-        );
-        assert!(env.logs.is_empty(), "a proven re-bind is quiet: {:?}", env.logs);
-    }
-
-    // [unit->REQ-HAZARD-RESUME-REBIND-WEDGE] the FIRST bind (fresh spawn, no recorded sid) has no
-    // proof to present — broker parentage is the credential — but is now strict (no silent swallow).
-    #[test]
-    fn fresh_bind_has_no_proof_and_is_strict() {
-        let mut env = Recorder::new(|_| Some(String::new())).with_env("SPT_ENDPOINT_ID", "cc-1");
-        handle_session_start(&mut env, &json!({"session_id":"s1","source":"startup"}));
-        assert!(
-            env.call_lines().iter().any(|l| l == "api --adapter claude-spt bind cc-1 --set-session-id s1"),
-            "fresh bind is proofless: {:?}",
-            env.call_lines()
-        );
-        assert!(
-            !env.call_lines()
-                .iter()
-                .any(|l| l.starts_with("api --adapter claude-spt bind ") && l.contains("--session-id ")),
-            "no ownership proof on the bind when there is no prior sid: {:?}",
-            env.call_lines()
-        );
-        assert!(env.logs.is_empty(), "a clean fresh bind is quiet: {:?}", env.logs);
-    }
-
-    // [unit->REQ-HAZARD-RESUME-REBIND-WEDGE][unit->REQ-HAZARD-SESSION-PIN-WEDGE] a refused re-bind
-    // must be LOUD with its reason — the silent swallow was the /resume wedge.
-    #[test]
-    fn resume_rebind_refusal_is_loud() {
-        let mut env = Recorder::new(|_| Some(String::new()))
-            .with_env("SPT_ENDPOINT_ID", "cc-1")
-            .with_state("state/session/cc-1.sid", "s-old")
-            .with_strict_err("AUTH_REFUSED:cc-1 (need --token or matching --session-id)");
-        handle_session_start(&mut env, &json!({"session_id":"s-new","source":"resume"}));
-        assert!(
-            env.logs.iter().any(|l| l.contains("re-pin FAILED") && l.contains("AUTH_REFUSED")),
-            "the re-bind refusal must be loud with its reason: {:?}",
-            env.logs
-        );
-    }
-
-    // [unit->REQ-HAZARD-RESUME-REBIND-WEDGE] a re-fire whose sid did not change (prior==current) is
-    // not a rotation — no proof appended (an idempotent bind).
-    #[test]
-    fn resume_rebind_same_sid_omits_proof() {
-        let mut env = Recorder::new(|_| Some(String::new()))
-            .with_env("SPT_ENDPOINT_ID", "cc-1")
-            .with_state("state/session/cc-1.sid", "s-same");
-        handle_session_start(&mut env, &json!({"session_id":"s-same","source":"resume"}));
-        assert!(
-            env.call_lines().iter().any(|l| l == "api --adapter claude-spt bind cc-1 --set-session-id s-same"),
-            "same-sid re-fire binds without proof: {:?}",
-            env.call_lines()
-        );
-        assert!(
-            !env.call_lines()
-                .iter()
-                .any(|l| l.starts_with("api --adapter claude-spt bind ") && l.contains("--session-id ")),
-            "no proof on the bind when the sid is unchanged: {:?}",
-            env.call_lines()
-        );
-    }
-
-    #[test]
-    fn session_start_subagent_gets_no_brief() {
-        let mut env = Recorder::new(|_| Some("x".into())).with_env("SPT_ENDPOINT_ID", "cc-1");
-        handle_session_start(&mut env, &json!({"session_id":"s1","source":"startup","agent_type":"general-purpose"}));
-        assert!(env.out().is_empty(), "subagent sessions get no brief");
-    }
-
-    // [unit->REQ-DIST-BOUNDARY-ROTATE]
-    #[test]
-    fn sid_state_rel_shape_and_sanitize() {
-        assert_eq!(sid_state_rel("ball-b"), "state/session/ball-b.sid");
-        assert_eq!(sid_state_rel("cc_1.x"), "state/session/cc_1.x.sid");
-        // Separators and traversal characters never reach the path.
-        assert_eq!(sid_state_rel("../evil"), "state/session/..evil.sid");
-        assert_eq!(sid_state_rel("a/b\\c"), "state/session/abc.sid");
-    }
-
-    // [unit->REQ-DIST-BOUNDARY-ROTATE] the F-024 fix: /clear resolves the id from $SPT_ENDPOINT_ID
-    // (whoami-by-NEW-sid is the catch-22 — the new sid is unregistered until this call succeeds)
-    // and presents the DEPARTED session's sid from the adapter state file as the auth proof.
-    #[test]
-    fn boundary_prefers_endpoint_id_and_presents_prior_proof() {
-        let mut env = Recorder::new(|_| Some(String::new()))
-            .with_env("SPT_ENDPOINT_ID", "ball-b")
-            // Name present so the boundary-rename leg has nothing to say — this test's quiet
-            // invariant is about the ROTATION (a shim-spawned endpoint has the name in practice).
-            .with_env("SPT_SESSION_NAME", "ball-b @ NODE (proj/)")
-            .with_state("state/session/ball-b.sid", "s-old");
-        handle_session_start(&mut env, &json!({"session_id":"s-new","source":"clear"}));
-        let lines = env.call_lines();
-        assert!(
-            lines.iter().any(|l| l == "api --adapter claude-spt boundary clear ball-b --to-session-id s-new --session-id s-old"),
-            "boundary carries the prior-sid proof: {lines:?}"
-        );
-        assert!(!lines.iter().any(|l| l.starts_with("whoami")), "no whoami catch-22 when spt-hosted");
-        assert!(env.logs.is_empty(), "a proven rotation is quiet: {:?}", env.logs);
-    }
-
-    // [unit->REQ-DIST-BOUNDARY-ROTATE] every SessionStart persists the CURRENT sid as the NEXT
-    // rotation's proof — the bind path seeds the file, the boundary path rolls it forward.
-    #[test]
-    fn bind_and_boundary_persist_sid_as_rotation_proof() {
-        let mut env = Recorder::new(|_| Some(String::new())).with_env("SPT_ENDPOINT_ID", "cc-1");
-        handle_session_start(&mut env, &json!({"session_id":"s1","source":"startup"}));
-        assert!(
-            env.state_writes.contains(&("state/session/cc-1.sid".to_string(), "s1".to_string())),
-            "bind persists the sid: {:?}",
-            env.state_writes
-        );
-        // Rotation rolls the proof forward to the NEW sid.
-        handle_session_start(&mut env, &json!({"session_id":"s2","source":"clear"}));
-        assert!(
-            env.state_writes.contains(&("state/session/cc-1.sid".to_string(), "s2".to_string())),
-            "boundary persists the new sid for the next rotation: {:?}",
-            env.state_writes
-        );
-    }
-
-    // [unit->REQ-HAZARD-SESSION-PIN-WEDGE] a rotation with no resolvable id must be LOUD — the old
-    // silent skip is exactly the ENLYZEAM wedge (perch pinned to a dead sid, no self-heal).
-    #[test]
-    fn boundary_empty_id_is_loud_never_silent() {
-        // Harness-hosted (no SPT_ENDPOINT_ID) and whoami resolves nothing (fresh env post-/clear).
-        let mut env = Recorder::new(|args| match args {
-            ["whoami", "--json"] => Some(r#"{"self":null,"subnets":[]}"#.into()),
-            _ => Some(String::new()),
-        });
-        handle_session_start(&mut env, &json!({"session_id":"s-new","source":"clear"}));
-        assert!(!env.call_lines().iter().any(|l| l.contains("boundary")), "no unproven boundary call");
-        assert!(
-            env.logs.iter().any(|l| l.contains("SKIPPED") && l.contains("strand")),
-            "the skip must be loud: {:?}",
-            env.logs
-        );
-    }
-
-    // [unit->REQ-HAZARD-SESSION-PIN-WEDGE] a refused rotation surfaces the refusal reason (it prints
-    // on stderr, which the exit-ignored `spt` seam discards — hence the strict seam).
-    #[test]
-    fn boundary_refusal_is_loud_with_reason() {
-        let mut env = Recorder::new(|_| Some(String::new()))
-            .with_env("SPT_ENDPOINT_ID", "ball-b")
-            .with_state("state/session/ball-b.sid", "s-old")
-            .with_strict_err("AUTH_REFUSED:ball-b (need --token or matching --session-id)");
-        handle_session_start(&mut env, &json!({"session_id":"s-new","source":"clear"}));
-        assert!(
-            env.logs.iter().any(|l| l.contains("FAILED") && l.contains("AUTH_REFUSED")),
-            "the refusal must be loud with its reason: {:?}",
-            env.logs
-        );
-    }
-
-    // [unit->REQ-DIST-BOUNDARY-ROTATE] first rotation after an update (state file absent): still
-    // attempts, but says loudly that the proof is missing.
-    #[test]
-    fn boundary_without_prior_proof_attempts_and_warns() {
-        let mut env = Recorder::new(|_| Some(String::new())).with_env("SPT_ENDPOINT_ID", "ball-b");
-        handle_session_start(&mut env, &json!({"session_id":"s-new","source":"compact"}));
-        assert!(
-            env.call_lines()
-                .iter()
-                .any(|l| l == "api --adapter claude-spt boundary compact ball-b --to-session-id s-new"),
-            "unproven rotation still attempted: {:?}",
-            env.call_lines()
-        );
-        assert!(
-            env.logs.iter().any(|l| l.contains("no prior-session proof")),
-            "missing proof must be loud: {:?}",
-            env.logs
-        );
-    }
-
-    // [unit->REQ-DIST-CHECKPOINT-COMMUNE]
-    #[test]
-    fn post_tool_use_fires_checkpoint_self_send() {
-        let mut env = Recorder::new(|_| Some(String::new())).with_env("SPT_ENDPOINT_ID", "perri");
-        handle_post_tool_use(
-            &mut env,
-            &json!({
-                "session_id":"s1","tool_name":"Write",
-                "tool_input":{"file_path":"/p/.claude/perri-commune.md","content":"delta !!checkpoint!! go now !!checkpoint!! tail"}
-            }),
-        );
-        let lines = env.call_lines();
-        assert!(lines.iter().any(|l| l == "api --adapter claude-spt state idle perri --session-id s1"), "idle first");
-        assert!(
-            lines.iter().any(|l| l == "send --from perri perri --json-payload {\"checkpoint\":\"v1\",\"wake\":\"go now\"} --force-native"),
-            "self-send carries the custom wake AND --force-native; got {:?}",
-            lines
-        );
-    }
-
-    // [unit->REQ-HAZARD-CHECKPOINT-CLEAR-RACE]
-    #[test]
-    fn clear_boundary_fires_checkpoint_fire_force_native() {
-        // A `clear` SessionStart on an spt-hosted endpoint marks idle + self-sends the FIRE signal
-        // through the translation binary (--force-native) so the armed wake lands post-clear.
-        let mut env = Recorder::new(|_| Some(String::new())).with_env("SPT_ENDPOINT_ID", "ball-b");
-        handle_session_start(&mut env, &json!({"session_id":"s-new","source":"clear"}));
-        let lines = env.call_lines();
-        assert!(
-            lines.iter().any(|l| l == "api --adapter claude-spt state idle ball-b --session-id s-new"),
-            "marks idle before firing; got {:?}",
-            lines
-        );
-        assert!(
-            lines.iter().any(|l| l == "send --from ball-b ball-b --json-payload {\"checkpoint_fire\":\"v1\"} --force-native"),
-            "fires checkpoint_fire via --force-native; got {:?}",
-            lines
-        );
-    }
-
-    // [unit->REQ-HAZARD-CHECKPOINT-CLEAR-RACE]
-    // [unit->REQ-DIST-BOUNDARY-RENAME]
-    #[test]
-    fn clear_boundary_renames_before_fire() {
-        // With the shim-threaded name present, a clear boundary self-sends the rename BEFORE the
-        // fire: /rename is a local no-turn command, so any armed wake still lands on an idle box;
-        // inverted, the wake's turn would strand the rename text.
-        let mut env = Recorder::new(|_| Some(String::new()))
-            .with_env("SPT_ENDPOINT_ID", "ball-b")
-            .with_env("SPT_SESSION_NAME", "ball-b @ NODE (proj/)");
-        handle_session_start(&mut env, &json!({"session_id":"s-new","source":"clear"}));
-        let lines = env.call_lines();
-        let rename = lines.iter().position(|l| {
-            l == "send --from ball-b ball-b --json-payload {\"rename\":\"v1\",\"name\":\"ball-b @ NODE (proj/)\"} --force-native"
-        });
-        let fire = lines.iter().position(|l| l.contains("checkpoint_fire"));
-        assert!(rename.is_some(), "rename send (verbatim name, --force-native) present; got {lines:?}");
-        assert!(fire.is_some(), "fire send still present; got {lines:?}");
-        assert!(rename.unwrap() < fire.unwrap(), "rename must precede fire; got {lines:?}");
-    }
-
-    // [unit->REQ-DIST-BOUNDARY-RENAME]
-    #[test]
-    fn clear_without_name_skips_rename_loud() {
-        // No $SPT_SESSION_NAME (pre-0.14.1 spawn / non-shim spawn): the rename send is skipped with
-        // a LOUD breadcrumb — never silently — and the fire still goes out.
-        let mut env = Recorder::new(|_| Some(String::new())).with_env("SPT_ENDPOINT_ID", "ball-b");
-        handle_session_start(&mut env, &json!({"session_id":"s-new","source":"clear"}));
-        let lines = env.call_lines();
-        assert!(!lines.iter().any(|l| l.contains("\"rename\"")), "no rename send without a name: {lines:?}");
-        assert!(lines.iter().any(|l| l.contains("checkpoint_fire")), "fire unaffected: {lines:?}");
-        assert!(
-            env.logs.iter().any(|l| l.contains("RENAME_SKIP:no-name")),
-            "loud skip breadcrumb required; got {:?}",
-            env.logs
-        );
-    }
-
-    // [unit->REQ-DIST-BOUNDARY-RENAME]
-    #[test]
-    fn non_clear_starts_never_send_rename() {
-        // compact retains the CC display name (empirically confirmed 2026-07-05) and startup just
-        // set it via -n — neither boundary sends a rename, even with the name env present.
-        for src in ["compact", "startup"] {
-            let mut env = Recorder::new(|_| Some(String::new()))
-                .with_env("SPT_ENDPOINT_ID", "ball-b")
-                .with_env("SPT_SESSION_NAME", "ball-b @ NODE (proj/)");
-            handle_session_start(&mut env, &json!({"session_id":"s","source":src}));
-            assert!(
-                !env.call_lines().iter().any(|l| l.contains("\"rename\"")),
-                "source={src} must not rename: {:?}",
-                env.call_lines()
-            );
-        }
-    }
-
-    // [unit->REQ-DIST-BOUNDARY-RENAME]
-    #[test]
-    fn rename_payload_shape() {
-        assert_eq!(
-            rename_payload("perri @ NODE (proj/)"),
-            "{\"rename\":\"v1\",\"name\":\"perri @ NODE (proj/)\"}"
-        );
-        assert_eq!(rename_payload("a\"b"), "{\"rename\":\"v1\",\"name\":\"a\\\"b\"}");
-    }
-
-    #[test]
-    fn non_clear_starts_do_not_fire_checkpoint() {
-        // Only `clear` fires. A compact boundary, a bind, and a plain startup must NOT self-send it
-        // (no checkpoint variant leverages /compact; bind/startup never armed a wake).
-        for (src, eid) in [("compact", Some("ball-b")), ("startup", Some("ball-b")), ("startup", None)] {
-            let mut env = Recorder::new(|_| Some(String::new()));
-            if let Some(e) = eid {
-                env = env.with_env("SPT_ENDPOINT_ID", e);
-            }
-            handle_session_start(&mut env, &json!({"session_id":"s","source":src}));
-            assert!(
-                !env.call_lines().iter().any(|l| l.contains("checkpoint_fire")),
-                "source={src} eid={eid:?} must NOT fire: {:?}",
-                env.call_lines()
-            );
-        }
-    }
-
-    #[test]
-    fn post_tool_use_noop_without_endpoint_or_marker() {
-        // No SPT_ENDPOINT_ID → inert (harness-hosted).
-        let mut env = Recorder::new(|_| Some(String::new()));
-        handle_post_tool_use(&mut env, &json!({"tool_name":"Write","tool_input":{"file_path":"/p/.claude/perri-commune.md","content":"!!checkpoint!!"}}));
-        assert!(env.calls.is_empty());
-
-        // spt-hosted but a Write to a non-commune file, or no marker → no self-send.
-        let mut env2 = Recorder::new(|_| Some(String::new())).with_env("SPT_ENDPOINT_ID", "perri");
-        handle_post_tool_use(&mut env2, &json!({"session_id":"s","tool_name":"Write","tool_input":{"file_path":"/p/.claude/notes.md","content":"!!checkpoint!!"}}));
-        assert!(!env2.call_lines().iter().any(|l| l.contains("send --from")));
-
-        let mut env3 = Recorder::new(|_| Some(String::new())).with_env("SPT_ENDPOINT_ID", "perri");
-        handle_post_tool_use(&mut env3, &json!({"session_id":"s","tool_name":"Write","tool_input":{"file_path":"/p/.claude/perri-commune.md","content":"ordinary delta"}}));
-        assert!(!env3.call_lines().iter().any(|l| l.contains("send --from")));
-    }
-
-    /// Responder for the worker tests: whoami resolves the parent; worker-start answers the
-    /// core-minted id on bare stdout (the WORKER-TRUTH wave-1 contract).
-    fn worker_responder(args: &[&str]) -> Option<String> {
-        match args {
-            ["whoami", "--json"] => Some(r#"{"self":{"id":"parent","status":"live_agent","ready":true,"alive":true}}"#.into()),
-            a if a.get(3) == Some(&"worker-start") => Some("parent-w4".into()),
-            _ => Some(String::new()),
-        }
-    }
-
-    // [unit->REQ-DIST-WORKER-LIFECYCLE]
-    #[test]
-    fn subagent_start_mints_and_persists() {
-        // No worker-id positional (core mints), agent_id/agent_type ride as metadata, and the
-        // minted id from bare stdout lands in the agent_id-keyed state mapping.
-        let mut env = Recorder::new(worker_responder);
-        handle_subagent_start(&mut env, &json!({"session_id":"s1","agent_id":"w7","agent_type":"Explore"}));
-        assert!(
-            env.call_lines().iter().any(|l| l == "api --adapter claude-spt worker-start parent --session-id s1 --agent-id w7 --agent-type Explore"),
-            "id-less worker-start with correlation metadata; got {:?}",
-            env.call_lines()
-        );
-        assert_eq!(env.state.get("state/worker/w7.wid").map(String::as_str), Some("parent-w4"), "minted id persisted");
-        assert!(env.logs.is_empty(), "clean start is quiet: {:?}", env.logs);
-    }
-
-    // [unit->REQ-DIST-WORKER-LIFECYCLE]
-    #[test]
-    fn subagent_start_refusal_and_empty_are_loud() {
-        // A refused start (strict Err) and an empty-stdout answer both log LOUDLY — a silently
-        // unregistered worker is invisible (the 2026-07-06 leak class).
-        let mut env = Recorder::new(worker_responder).with_strict_err("AUTH_REFUSED:parent");
-        handle_subagent_start(&mut env, &json!({"session_id":"s1","agent_id":"w7"}));
-        assert!(env.logs.iter().any(|l| l.contains("WORKER_START_REFUSED") && l.contains("AUTH_REFUSED")), "{:?}", env.logs);
-
-        let mut env2 = Recorder::new(|args| match args {
-            ["whoami", "--json"] => Some(r#"{"self":{"id":"parent","status":"live_agent","ready":true,"alive":true}}"#.into()),
-            _ => Some(String::new()), // worker-start answers EMPTY stdout
-        });
-        handle_subagent_start(&mut env2, &json!({"session_id":"s1","agent_id":"w7"}));
-        assert!(env2.logs.iter().any(|l| l.contains("WORKER_START_REFUSED") && l.contains("no minted id")), "{:?}", env2.logs);
-        assert!(env2.state.get("state/worker/w7.wid").is_none(), "no mapping on refusal");
-    }
-
-    // [unit->REQ-DIST-WORKER-LIFECYCLE]
-    #[test]
-    fn subagent_stop_uses_minted_id_and_clears_state() {
-        let mut env = Recorder::new(|_| Some(String::new())).with_state("state/worker/w7.wid", "parent-w4");
-        handle_subagent_stop(&mut env, &json!({"session_id":"s1","agent_id":"w7"}));
-        assert!(
-            env.call_lines().iter().any(|l| l == "api --adapter claude-spt worker-stop parent-w4 --session-id s1"),
-            "stop by MINTED id, sid-symmetric, zero tokens; got {:?}",
-            env.call_lines()
-        );
-        assert_eq!(env.state.get("state/worker/w7.wid").map(String::as_str), Some(""), "mapping cleared on success");
-        assert!(env.logs.is_empty(), "clean stop is quiet: {:?}", env.logs);
-    }
-
-    // [unit->REQ-DIST-WORKER-LIFECYCLE]
-    #[test]
-    fn subagent_stop_missing_mapping_and_refusal_are_loud() {
-        // Missing mapping (start refused / pre-0.15.0 start) → loud skip, no blind stop call.
-        let mut env = Recorder::new(|_| Some(String::new()));
-        handle_subagent_stop(&mut env, &json!({"session_id":"s1","agent_id":"w7"}));
-        assert!(!env.call_lines().iter().any(|l| l.contains("worker-stop")), "no stop without a minted id");
-        assert!(env.logs.iter().any(|l| l.contains("WORKER_STOP_SKIP")), "{:?}", env.logs);
-
-        // A refused stop surfaces the reason — the silent swallow leaked 100% of workers.
-        let mut env2 = Recorder::new(|_| Some(String::new()))
-            .with_state("state/worker/w7.wid", "parent-w4")
-            .with_strict_err("AUTH_REFUSED:parent-w4");
-        handle_subagent_stop(&mut env2, &json!({"session_id":"s1","agent_id":"w7"}));
-        assert!(env2.logs.iter().any(|l| l.contains("WORKER_STOP_REFUSED") && l.contains("AUTH_REFUSED")), "{:?}", env2.logs);
-        assert_eq!(env2.state.get("state/worker/w7.wid").map(String::as_str), Some("parent-w4"), "mapping kept on refusal");
-    }
-
-    // [unit->REQ-DIST-WORKER-LIFECYCLE]
-    #[test]
-    fn worker_missing_agent_id_is_loud_never_silent() {
-        for (name, f) in [
-            ("start", handle_subagent_start as fn(&mut dyn HookEnv, &Value)),
-            ("stop", handle_subagent_stop as fn(&mut dyn HookEnv, &Value)),
-        ] {
-            let mut env = Recorder::new(worker_responder);
-            f(&mut env, &json!({"session_id":"s1"}));
-            assert!(
-                !env.call_lines().iter().any(|l| l.contains("worker-st")),
-                "{name}: no worker verb without agent_id"
-            );
-            assert!(
-                env.logs.iter().any(|l| l.contains("SKIP")),
-                "{name} must be loud on missing agent_id: {:?}",
-                env.logs
-            );
-        }
-    }
-
-    // [unit->REQ-DIST-WORKER-LIFECYCLE]
-    #[test]
-    fn worker_state_rel_shape_and_sanitize() {
-        assert_eq!(worker_state_rel("a003345a913f1448b"), "state/worker/a003345a913f1448b.wid");
-        assert_eq!(worker_state_rel("../evil"), "state/worker/..evil.wid");
-        assert_eq!(worker_state_rel("a/b\\c"), "state/worker/abc.wid");
-    }
-
-    #[test]
-    fn emit_capped_overflow_spills_full_and_emits_marker_only() {
-        let mut env = Recorder::new(|_| Some(String::new()));
-        env.cap = 5;
-        emit_capped(&mut env, "abcdefghij", "/home/x/.claude/spill.txt");
-        assert_eq!(env.spills.len(), 1);
-        assert_eq!(env.spills[0].1, "abcdefghij", "full body spilled");
-        let out = env.out();
-        assert!(out.contains("<sptc_overflow"), "marker emitted");
-        assert!(out.contains("bytes=\"10\""));
-        assert!(!out.contains("abcdefghij"), "body never inlined in the marker");
-    }
-
-    // [unit->REQ-DIST-HOOK-BINARY]
-    #[test]
-    fn dispatch_routes_known_events_and_noops_unknown() {
-        // Every CC event the static hooks.json wires routes to a handler; an event the binary does
-        // not yet know is a silent no-op (forward-compat with a newer plugin wiring).
-        let mut env = Recorder::new(|args| match args {
-            ["whoami", "--json"] => Some(r#"{"self":{"id":"perri","status":"live_agent","ready":true,"alive":true}}"#.into()),
-            _ => Some(String::new()),
-        });
-        dispatch(&mut env, "Stop", &json!({"session_id":"s"}));
-        assert!(env.call_lines().iter().any(|l| l.contains("state idle")), "Stop routed");
-    }
-
-    // [unit->REQ-HAZARD-STUCK-ACTIVE-NO-IDLE] a freshly-bound spt-hosted session is marked idle at
-    // bringup — a never-turned session used to stay ACTIVE and silently spool every message (`lia`,
-    // 2026-07-08). The startup bind now asserts idle so the endpoint is immediately receivable.
-    #[test]
-    fn startup_bind_marks_idle_for_immediate_receivability() {
-        let mut env = Recorder::new(|args| match args {
-            ["adapter", "get-string", _, k] => Some(format!("[{k}]")),
-            a if a.contains(&"psyche-download") => Some(String::new()),
-            _ => Some(String::new()),
-        })
-        .with_env("SPT_ENDPOINT_ID", "cc-1");
-        handle_session_start(&mut env, &json!({"session_id":"s1","source":"startup"}));
-        assert!(
-            env.call_lines().iter().any(|l| l == "api --adapter claude-spt state idle cc-1 --session-id s1"),
-            "startup bind asserts idle: {:?}",
-            env.call_lines()
-        );
-    }
-
-    // [unit->REQ-HAZARD-STUCK-ACTIVE-NO-IDLE] the self-heal: an idle_prompt Notification (session back
-    // at its input box, no turn running) re-asserts idle so the daemon drains the parked spool — the
-    // recovery from a /login or any no-Stop submission that left the endpoint stuck ACTIVE.
-    #[test]
-    fn notification_idle_prompt_marks_idle_when_spt_hosted() {
-        let mut env = Recorder::new(|_| Some(String::new())).with_env("SPT_ENDPOINT_ID", "cc-1");
-        handle_notification(&mut env, &json!({"session_id":"s1","notification_type":"idle_prompt"}));
-        assert!(
-            env.call_lines().iter().any(|l| l == "api --adapter claude-spt state idle cc-1 --session-id s1"),
-            "idle_prompt notification re-asserts idle: {:?}",
-            env.call_lines()
-        );
-    }
-
-    // [unit->REQ-HAZARD-STUCK-ACTIVE-NO-IDLE] TYPE-AWARE: the `*` matcher routes every notification
-    // type here, but a permission_prompt is NOT idle (a turn is mid-flight awaiting the operator) —
-    // marking idle then would drain the spool INTO a live turn. Only idle_prompt heals; every type
-    // is still logged (the Step-0 instrument).
-    #[test]
-    fn notification_non_idle_type_logs_but_does_not_mark_idle() {
-        let mut env = Recorder::new(|_| Some(String::new())).with_env("SPT_ENDPOINT_ID", "cc-1");
-        handle_notification(&mut env, &json!({"session_id":"s1","notification_type":"permission_prompt"}));
-        assert!(!env.call_lines().iter().any(|l| l.contains("state idle")), "no idle mark on permission_prompt: {:?}", env.call_lines());
-        assert!(env.logs.iter().any(|l| l.contains("NOTIFICATION type=\"permission_prompt\"")), "type still logged: {:?}", env.logs);
-    }
-
-    // [unit->REQ-HAZARD-STOPFAILURE-STUCK-BUSY] an API-error turn-end (no `Stop` fires) marks the
-    // perch idle so the daemon drains the spool — heals the API-error stuck-busy black hole.
-    #[test]
-    fn stop_failure_marks_idle_when_perched_else_noop() {
-        let mut env = Recorder::new(|args| match args {
-            ["whoami", "--json"] => Some(r#"{"self":{"id":"perri"}}"#.into()),
-            _ => Some(String::new()),
-        });
-        handle_stop_failure(&mut env, &json!({"session_id":"s1","error_type":"rate_limit"}));
-        assert!(env.call_lines().iter().any(|l| l == "api --adapter claude-spt state idle perri --session-id s1"), "stop-failure marks idle: {:?}", env.call_lines());
-
-        let mut env2 = Recorder::new(|_| Some(String::new())); // whoami empty → no perch
-        handle_stop_failure(&mut env2, &json!({"session_id":"s1","error_type":"server_error"}));
-        assert!(!env2.call_lines().iter().any(|l| l.contains("state idle")), "no-perch is a noop");
-    }
-
-    // [unit->REQ-HAZARD-INTERRUPT-STUCK-BUSY] an Esc DURING a tool call (is_interrupt=true, no Stop /
-    // no idle_prompt fires) marks idle at zero latency.
-    #[test]
-    fn post_tool_use_failure_interrupt_marks_idle() {
-        let mut env = Recorder::new(|args| match args {
-            ["whoami", "--json"] => Some(r#"{"self":{"id":"perri"}}"#.into()),
-            _ => Some(String::new()),
-        });
-        handle_post_tool_use_failure(&mut env, &json!({"session_id":"s1","tool_name":"Bash","is_interrupt":true}));
-        assert!(env.call_lines().iter().any(|l| l == "api --adapter claude-spt state idle perri --session-id s1"), "interrupt marks idle: {:?}", env.call_lines());
-    }
-
-    // [unit->REQ-HAZARD-INTERRUPT-STUCK-BUSY] a NON-interrupt tool failure (a command exited nonzero)
-    // is NOT a turn-end — the agent keeps going — so it must NOT mark idle.
-    #[test]
-    fn post_tool_use_failure_noninterrupt_does_not_mark_idle() {
-        let mut env = Recorder::new(|args| match args {
-            ["whoami", "--json"] => Some(r#"{"self":{"id":"perri"}}"#.into()),
-            _ => Some(String::new()),
-        });
-        handle_post_tool_use_failure(&mut env, &json!({"session_id":"s1","tool_name":"Bash","is_interrupt":false}));
-        assert!(!env.call_lines().iter().any(|l| l.contains("state idle")), "non-interrupt failure is not idle: {:?}", env.call_lines());
-        // is_interrupt absent defaults false → also a noop (never mark idle on an ambiguous payload).
-        let mut env2 = Recorder::new(|args| match args {
-            ["whoami", "--json"] => Some(r#"{"self":{"id":"perri"}}"#.into()),
-            _ => Some(String::new()),
-        });
-        handle_post_tool_use_failure(&mut env2, &json!({"session_id":"s1","tool_name":"Bash"}));
-        assert!(!env2.call_lines().iter().any(|l| l.contains("state idle")), "absent is_interrupt is not idle");
-    }
-
-    // [unit->REQ-HAZARD-INTERRUPT-STUCK-BUSY] v0.16.1 HARDENING — the field miss that left lia deaf: a
-    // PostToolUseFailure payload OMITS session_id, so the old self_id+payload-sid path fired `state idle`
-    // with an EMPTY --session-id (AUTH-refused, silent). The spt-hosted heal now takes id from
-    // $SPT_ENDPOINT_ID and the sid from the bind-time carrier state/session/<id>.sid.
-    #[test]
-    fn receive_heal_spt_hosted_uses_sid_carrier_when_payload_omits_sid() {
-        let mut env = Recorder::new(|_| Some(String::new()))
-            .with_env("SPT_ENDPOINT_ID", "lia")
-            .with_state("state/session/lia.sid", "s-cur");
-        // No session_id in the payload (the real PostToolUseFailure shape on an Esc-mid-tool).
-        handle_post_tool_use_failure(&mut env, &json!({"tool_name":"Bash","is_interrupt":true}));
-        assert!(
-            env.call_lines().iter().any(|l| l == "api --adapter claude-spt state idle lia --session-id s-cur"),
-            "sid resolved from the carrier, never an empty --session-id: {:?}",
-            env.call_lines()
-        );
-    }
-
-    // [unit->REQ-HAZARD-INTERRUPT-STUCK-BUSY] the payload sid still WINS when present (carrier is only the
-    // fallback), and StopFailure rides the same hardened heal.
-    #[test]
-    fn receive_heal_spt_hosted_prefers_payload_sid_and_covers_stop_failure() {
-        let mut env = Recorder::new(|_| Some(String::new()))
-            .with_env("SPT_ENDPOINT_ID", "lia")
-            .with_state("state/session/lia.sid", "s-carrier");
-        handle_stop_failure(&mut env, &json!({"session_id":"s-payload","error_type":"rate_limit"}));
-        assert!(
-            env.call_lines().iter().any(|l| l == "api --adapter claude-spt state idle lia --session-id s-payload"),
-            "payload sid preferred over the carrier: {:?}",
-            env.call_lines()
-        );
-    }
-
-    // [unit->REQ-HAZARD-INTERRUPT-STUCK-BUSY] no sid anywhere (no payload, no carrier) → SKIP, never a
-    // bare `state idle ... --session-id` with an empty sid (which core AUTH-refuses).
-    #[test]
-    fn receive_heal_skips_when_no_sid_anywhere() {
-        let mut env = Recorder::new(|_| Some(String::new())).with_env("SPT_ENDPOINT_ID", "lia");
-        handle_post_tool_use_failure(&mut env, &json!({"tool_name":"Bash","is_interrupt":true}));
-        assert!(!env.call_lines().iter().any(|l| l.contains("state idle")), "no idle call without a sid: {:?}", env.call_lines());
-        assert!(env.logs.iter().any(|l| l.contains("RECEIVE_HEAL_SKIP")), "skip is logged for the trace: {:?}", env.logs);
-    }
-
-    // [unit->REQ-HAZARD-STUCK-ACTIVE-NO-IDLE] a NON-spt-hosted session (no SPT_ENDPOINT_ID — a
-    // /sptc:ready|live seed whose delivery is the Monitor relay, not the daemon idle-gate) does not
-    // touch state on a notification.
-    #[test]
-    fn notification_noop_when_not_spt_hosted() {
-        let mut env = Recorder::new(|_| Some(String::new()));
-        handle_notification(&mut env, &json!({"session_id":"s1"}));
-        assert!(env.call_lines().is_empty(), "no state call off-perch: {:?}", env.call_lines());
-    }
-
-    // [unit->REQ-HAZARD-STUCK-ACTIVE-NO-IDLE] no session_id in the payload => cannot prove ownership
-    // to the state verb => skip (never a bare unauthenticated call).
-    #[test]
-    fn notification_without_sid_is_a_noop() {
-        let mut env = Recorder::new(|_| Some(String::new())).with_env("SPT_ENDPOINT_ID", "cc-1");
-        handle_notification(&mut env, &json!({}));
-        assert!(env.call_lines().is_empty(), "no state call without a sid: {:?}", env.call_lines());
-    }
-
-    #[test]
-    fn dispatch_unknown_event_is_noop() {
-        let mut env = Recorder::new(|_| Some("x".into()));
-        dispatch(&mut env, "FutureEvent", &json!({"session_id":"s"}));
-        assert!(env.calls.is_empty());
-        assert!(env.out().is_empty());
-    }
-
-    // [unit->REQ-HAZARD-HOOKCMD-DISPATCH-LOCKSTEP]
-    #[test]
-    fn cc_hook_events_recognizer_matches_the_dispatch_arms() {
-        // `is_cc_hook_event` is what `main` uses to tell a stale-dispatch skew (`claude-spt <CCEvent>`,
-        // degrade + pass-through) from a genuine typo (loud exit 2). Every event `dispatch` has a real
-        // arm for MUST be recognised (else a real event misjudged as a typo → brick), and a name with
-        // NO dispatch arm must NOT be (else a typo silently swallowed). We assert both directions
-        // against the exact set `dispatch` routes — the two lists move in lockstep or this fails.
-        let dispatched: &[&str] = &[
-            "SessionStart", "UserPromptSubmit", "PreToolUse", "Stop", "SessionEnd", "SubagentStart",
-            "SubagentStop", "PostToolUse", "PostToolUseFailure", "Notification", "StopFailure",
-        ];
-        assert_eq!(CC_HOOK_EVENTS, dispatched, "CC_HOOK_EVENTS drifted from dispatch's arms");
-        for ev in dispatched {
-            assert!(is_cc_hook_event(ev), "{ev} has a dispatch arm but is not recognised");
-        }
-        assert!(!is_cc_hook_event("FutureEvent")); // no arm (dispatch `_ => {}`) → typo branch
-        assert!(!is_cc_hook_event("digest")); // a real subcommand is never a hook event
-    }
-
-    // ─────────────────────── Item 2: tag-driven peer messaging + commune shortcut ───────────────
-
-    // [unit->REQ-TAG-PEER-MESSAGING] the `spt send` result classifier — delivery tokens (live /
-    // spooled / deferred) mean landed; NO_PERCH / empty / error mean surface-to-sender.
-    #[test]
-    fn send_landed_recognizes_delivery_tokens_only() {
-        assert!(send_landed("SENT:doyle"));
-        assert!(send_landed("QUEUED:bob offline, spooled for next listen"));
-        assert!(send_landed("DEFERRED:perri"));
-        assert!(!send_landed("NO_PERCH:ghost is not listening"));
-        assert!(!send_landed(""));
-        assert!(!send_landed("error: daemon unreachable"));
-    }
-
-    // [unit->REQ-TAG-PEER-MESSAGING] the cursor path shares sid_state_rel's filename sanitization
-    // (basename `.pos` - a byte offset into the transcript, not the retired `.seq` digest cursor).
-    #[test]
-    fn digest_cursor_rel_sanitizes_like_the_sid_carrier() {
-        assert_eq!(digest_cursor_rel("perri"), "state/digest/perri.pos");
-        assert_eq!(digest_cursor_rel("cc @ n (p/)"), "state/digest/ccnp.pos");
-    }
-
-    /// One CC-transcript assistant line carrying `text`.
-    fn asst_line(text: &str) -> String {
-        let esc = json_escape(text);
-        format!(
-            "{{\"type\":\"assistant\",\"message\":{{\"role\":\"assistant\",\"content\":[{{\"type\":\"text\",\"text\":\"{esc}\"}}]}}}}\n"
-        )
-    }
-
-    // [unit->REQ-TAG-PEER-MESSAGING] a bare tag in the newly-appended transcript dispatches one send
-    // per target, fires the self confirm-back, and advances the byte cursor past the consumed line.
-    #[test]
-    fn scan_dispatches_multi_target_send_and_advances_cursor() {
-        let transcript = asst_line("@<doyle,carol status green @>");
-        let end = transcript.len().to_string();
-        let mut env = Recorder::new(move |args| match args {
-            ["send", "--from", "perri", "doyle"] => Some("SENT:doyle".into()),
-            ["send", "--from", "perri", "carol"] => Some("QUEUED:carol".into()),
-            _ => Some(String::new()),
-        })
-        .with_file("/t.jsonl", &transcript)
-        .with_state("state/digest/perri.pos", "0");
-        scan_and_dispatch(&mut env, "perri", "sid-1", "/t.jsonl");
-        let lines = env.call_lines();
-        assert!(lines.iter().any(|l| l == "send --from perri doyle"), "{lines:?}");
-        assert!(lines.iter().any(|l| l == "send --from perri carol"), "{lines:?}");
-        assert!(
-            lines.iter().any(|l| l == "send --from perri perri --active-only --ephemeral"),
-            "confirm-back fires: {lines:?}"
-        );
-        assert!(
-            env.state_writes.iter().any(|(k, v)| k == "state/digest/perri.pos" && *v == end),
-            "cursor advanced to EOF ({end}): {:?}",
-            env.state_writes
-        );
-    }
-
-    // [unit->REQ-TAG-PEER-MESSAGING] first run with NO cursor: initialize to the transcript's EOF so
-    // pre-existing history is NOT re-dispatched, and send nothing this pass.
-    #[test]
-    fn scan_first_run_skips_history() {
-        let transcript = asst_line("@<bob old history @>");
-        let end = transcript.len().to_string();
-        let mut env = Recorder::new(|_| Some(String::new())).with_file("/t.jsonl", &transcript);
-        scan_and_dispatch(&mut env, "perri", "s", "/t.jsonl");
-        assert!(
-            !env.call_lines().iter().any(|l| l.starts_with("send --from perri bob")),
-            "history must not be sent on first run"
-        );
-        assert!(
-            env.state_writes.iter().any(|(k, v)| k == "state/digest/perri.pos" && *v == end),
-            "cursor initialized to EOF: {:?}",
-            env.state_writes
-        );
-    }
-
-    // [unit->REQ-HAZARD-SEND-STATUS-STDERR] `spt send` emits its status token on STDERR (stdout empty).
-    // The classifier MUST read it via `spt_send` (stdout+stderr), not the stdout-only `spt`. Model the
-    // exact field bug: `spt` returns "" for every call (empty stdout), while `spt_send` returns the
-    // stderr-borne `QUEUED:lia`. The confirm-back body must report DELIVERED — the OLD stdout-only path
-    // saw "" and wrongly reported `NO PERCH` though the send delivered (2026-07-08, every hook tag-send).
-    #[test]
-    fn scan_classifies_send_by_stderr_token_not_empty_stdout() {
-        let transcript = asst_line("@<lia ping @>");
-        let mut env = Recorder::new(|_| Some(String::new())) // stdout: EMPTY for every call (the bug shape)
-            .with_send_responder(|args| match args {
-                ["send", "--from", "perri", "lia"] => Some("QUEUED:lia".into()), // token merged from stderr
-                _ => Some(String::new()),
-            })
-            .with_file("/t.jsonl", &transcript)
-            .with_state("state/digest/perri.pos", "0");
-        scan_and_dispatch(&mut env, "perri", "s", "/t.jsonl");
-        // The peer send is classified through spt_send (the recorded call still fires)...
-        assert!(env.call_lines().iter().any(|l| l == "send --from perri lia"));
-        // ...and the confirm-back body reports lia as DELIVERED, never NO PERCH.
-        let confirm = env
-            .stdin_for("send --from perri perri --active-only --ephemeral")
-            .expect("confirm-back fired with a body");
-        assert!(confirm.contains("delivered → lia"), "confirm reports delivered: {confirm:?}");
-        assert!(!confirm.contains("NO PERCH"), "no false NO PERCH: {confirm:?}");
-    }
-
-    // [unit->REQ-TAG-PEER-MESSAGING] an unreachable target is surfaced (confirm-back still fires, never
-    // a silent drop) and the cursor still advances (the section is consumed, not retried forever).
-    #[test]
-    fn scan_surfaces_unreachable_and_still_advances() {
-        let transcript = asst_line("@<ghost hi @>");
-        let end = transcript.len().to_string();
-        let mut env = Recorder::new(move |args| match args {
-            ["send", "--from", "perri", "ghost"] => Some("NO_PERCH:ghost is not listening".into()),
-            _ => Some(String::new()),
-        })
-        .with_file("/t.jsonl", &transcript)
-        .with_state("state/digest/perri.pos", "0");
-        scan_and_dispatch(&mut env, "perri", "s", "/t.jsonl");
-        assert!(env
-            .call_lines()
-            .iter()
-            .any(|l| l == "send --from perri perri --active-only --ephemeral"));
-        assert!(env.state_writes.iter().any(|(k, v)| k == "state/digest/perri.pos" && *v == end));
-    }
-
-    // [unit->REQ-TAG-PEER-MESSAGING] a self-target is dropped (no peer-send to self), but the
-    // confirm-back to the sender's own perch (active-only ephemeral) still fires.
-    #[test]
-    fn scan_drops_self_target_but_confirms() {
-        let transcript = asst_line("@<perri note to self @>");
-        let mut env = Recorder::new(|_| Some(String::new()))
-            .with_file("/t.jsonl", &transcript)
-            .with_state("state/digest/perri.pos", "0");
-        scan_and_dispatch(&mut env, "perri", "s", "/t.jsonl");
-        let lines = env.call_lines();
-        assert!(!lines.iter().any(|l| l == "send --from perri perri"), "no bare self peer-send: {lines:?}");
-        assert!(lines.iter().any(|l| l == "send --from perri perri --active-only --ephemeral"));
-    }
-
-    // [unit->REQ-COMMUNE-OUTPUT-SHORTCUT] `>>commune<<` writes the commune file (daemon ingests) and,
-    // when the body carries !!checkpoint!!, fires the same idle + checkpoint self-send as the Write path.
-    // The commune output is NOT tag-scanned (meta-recursion guard): no peer send.
-    #[test]
-    fn scan_commune_shortcut_writes_file_and_escalates_checkpoint() {
-        let transcript = asst_line(">>commune<<\nstatus done\n!!checkpoint!!");
-        let mut env = Recorder::new(|_| Some(String::new()))
-            .with_file("/t.jsonl", &transcript)
-            .with_state("state/digest/perri.pos", "0");
-        scan_and_dispatch(&mut env, "perri", "sid-9", "/t.jsonl");
-        assert!(
-            env.spills.iter().any(|(p, c)| p.ends_with("perri-commune.md") && c.contains("status done")),
-            "commune file written: {:?}",
-            env.spills
-        );
-        let lines = env.call_lines();
-        assert!(lines.iter().any(|l| l.starts_with("api --adapter claude-spt state idle perri")), "{lines:?}");
-        assert!(
-            lines.iter().any(|l| l.contains("\"checkpoint\":\"v1\"") && l.contains("--force-native")),
-            "checkpoint self-send: {lines:?}"
-        );
-        assert!(
-            !lines.iter().any(|l| l == "send --from perri perri --active-only --ephemeral"),
-            "a commune is not tag-scanned -> no peer confirm-back: {lines:?}"
-        );
-    }
-
-    // [unit->REQ-TAG-PEER-MESSAGING] a trailing PARTIAL final line (CC mid-write) is held: the complete
-    // line dispatches, the cursor stops before the partial so it is re-read whole next hook.
-    #[test]
-    fn scan_holds_a_trailing_partial_line() {
-        let complete = asst_line("@<bob one @>");
-        let partial = "{\"type\":\"assistant\",\"message\":{\"role\":\"assis"; // no newline
-        let transcript = format!("{complete}{partial}");
-        let consumed = complete.len().to_string();
-        let mut env = Recorder::new(move |args| match args {
-            ["send", "--from", "perri", "bob"] => Some("SENT:bob".into()),
-            _ => Some(String::new()),
-        })
-        .with_file("/t.jsonl", &transcript)
-        .with_state("state/digest/perri.pos", "0");
-        scan_and_dispatch(&mut env, "perri", "s", "/t.jsonl");
-        assert!(env.call_lines().iter().any(|l| l == "send --from perri bob"));
-        assert!(
-            env.state_writes.iter().any(|(k, v)| k == "state/digest/perri.pos" && *v == consumed),
-            "cursor stops before the partial: {:?}",
-            env.state_writes
-        );
-    }
-}
diff --git a/tools/claude-spt/src/interrupt_watch.rs b/tools/claude-spt/src/interrupt_watch.rs
deleted file mode 100644
index 18af93e..0000000
--- a/tools/claude-spt/src/interrupt_watch.rs
+++ /dev/null
@@ -1,244 +0,0 @@
-//! `interrupt_watch` — the receive-heal for an Esc-interrupted turn (NEXT-WORKLOAD-PLAN Item 1, fix 3).
-//!
-//! An operator Esc ends a turn with NO usable CC hook: `Stop` fires only on a clean finish,
-//! `StopFailure` only on an API error, and `PostToolUseFailure` only when a tool was mid-flight (and
-//! not reliably even then — field lia 2026-07-08). A PURE-THINKING Esc fires nothing. So a
-//! daemon-launched (spt-hosted) endpoint interrupted at its prompt stays ACTIVE and the daemon
-//! black-holes every inbound message until the operator's NEXT UserPromptSubmit happens to drain the
-//! spool (field: 20+ min of silence). The hook-driven fixes 1-2 cannot see a hookless interrupt.
-//!
-//! This is the self-driven backstop: a heartbeat thread hosted by the persistent per-endpoint
-//! translation binary (`translate.rs`, born/reaped with the spt-hosted session) PULLS the endpoint's
-//! own digest every [`POLL_SECS`] seconds. The interrupt is digest-visible as the latest turn whose
-//! `input` is the interrupt marker (`[Request interrupted by user]` / `[Request interrupted by user
-//! for tool use]` — both share the `[Request interrupted by user` prefix, field-verified on lia
-//! 2026-07-08). On seeing it, the thread marks the endpoint idle (`spt api ... state idle`), which
-//! drains the parked spool. The full chain — digest-detect → carrier-sid → `state idle` → delivery
-//! drains (SENT) — was proven manually against a stuck lia before this code was written.
-//!
-//! Heal-once semantics: the thread heals a given interrupt exactly once and re-arms only when the
-//! latest turn is no longer the marker (the agent moved on), so a persisting interrupt is not
-//! re-healed every tick. `state idle` is idempotent regardless, so a redundant call is harmless.
-//!
-//! Cost discipline (doyle rider): each poll spawns `spt endpoint digest --last 1` (DIGEST_FETCH_TIMEOUT
-//! bounded); [`POLL_SECS`] = 15 keeps the fetcher-spawn rate low across every idle session node-wide
-//! (NOT `--follow`, which is an activity reactor blind to an idle interrupt). Lifecycle-safe: the
-//! thread never panics the host (no unwrap; every spawn/parse failure degrades to a skipped tick), and
-//! it dies with the process when spt-core reaps the translation binary. [impl->REQ-HAZARD-INTERRUPT-STUCK-BUSY]
-
-use std::time::Duration;
-
-/// Heartbeat interval. 15s (operator-set): heals within ≤15s vs the 20-min status-quo black-hole,
-/// while keeping the per-idle-session digest-fetch spawn rate low node-wide (doyle anti-thrash rider).
-const POLL_SECS: u64 = 15;
-
-const ADAPTER: &str = "claude-spt";
-
-/// The interrupt-marker prefix shared by both CC variants: `[Request interrupted by user]` (a
-/// pure-thinking Esc) and `[Request interrupted by user for tool use]` (an Esc mid-tool-call).
-const INTERRUPT_PREFIX: &str = "[Request interrupted by user";
-
-/// True if a digest turn's `input` is a CC interrupt marker (either variant).
-pub fn is_interrupt_marker(input: &str) -> bool {
-    input.trim_start().starts_with(INTERRUPT_PREFIX)
-}
-
-/// The latest turn's `input` from a `spt endpoint digest <id> --json` document (`{"turns":[…]}`), or
-/// None if the JSON is unparseable / has no turns / the latest turn has no string `input`. Pure over
-/// the string so the parse is unit-testable without a live daemon.
-pub fn parse_latest_input(digest_json: &str) -> Option<String> {
-    let v: serde_json::Value = serde_json::from_str(digest_json.trim()).ok()?;
-    let turns = v.get("turns")?.as_array()?;
-    let last = turns.last()?;
-    last.get("input").and_then(serde_json::Value::as_str).map(str::to_string)
-}
-
-/// Decide the next action from the latest digest input and whether the CURRENT interrupt was already
-/// healed. Pure state machine (unit-tested), returns `(should_mark_idle, next_healed_flag)`:
-/// - `None` (a failed/empty pull): HOLD state — never heal on missing data, never re-arm (a transient
-///   digest miss must not cause a re-heal on the next successful tick).
-/// - an interrupt marker: heal iff not already healed; latch `healed = true`.
-/// - any other turn (the agent moved on): re-arm (`healed = false`), never heal.
-pub fn heal_decision(latest: Option<&str>, already_healed: bool) -> (bool, bool) {
-    match latest {
-        None => (false, already_healed),
-        Some(i) if is_interrupt_marker(i) => (!already_healed, true),
-        Some(_) => (false, false),
-    }
-}
-
-/// Sanitize an endpoint id to the filename-safe alphabet and build the bind-time sid carrier's
-/// adapter-relative path — MUST match `hook::sid_state_rel` (the hook writes it at bind; we read it).
-fn sid_state_rel(endpoint_id: &str) -> String {
-    let safe: String = endpoint_id
-        .chars()
-        .filter(|c| c.is_ascii_alphanumeric() || *c == '-' || *c == '_' || *c == '.')
-        .collect();
-    format!("state/session/{safe}.sid")
-}
-
-/// Read the current session id from the bind-time carrier beside the binary (adapter_dir). The
-/// `state idle` verb needs this sid to prove ownership; an empty/missing carrier ⇒ None (skip — never
-/// call `state idle` with an empty `--session-id`, which core AUTH-refuses).
-fn read_sid(endpoint_id: &str) -> Option<String> {
-    let dir = std::env::current_exe().ok()?.parent()?.to_path_buf();
-    let s = std::fs::read_to_string(dir.join(sid_state_rel(endpoint_id))).ok()?;
-    let t = s.trim().to_string();
-    if t.is_empty() { None } else { Some(t) }
-}
-
-/// Resolve the `spt` binary: PATH first (the daemon spawns us with spt on PATH), then known install
-/// locations. Mirrors `hook::SysEnv::spt_bin`; the caller tolerates a failed spawn.
-fn spt_bin() -> String {
-    if which_spt() {
-        return "spt".to_string();
-    }
-    let home = std::env::var("HOME").unwrap_or_default();
-    let local = std::env::var("LOCALAPPDATA").unwrap_or_default();
-    for p in [
-        format!("{home}/.local/bin/spt"),
-        format!("{local}/spt-core/bin/spt.exe"),
-        format!("{home}/AppData/Local/spt-core/bin/spt.exe"),
-    ] {
-        if std::path::Path::new(&p).is_file() {
-            return p;
-        }
-    }
-    "spt".to_string()
-}
-
-/// Minimal `command -v spt` (PATH + PATHEXT on Windows).
-fn which_spt() -> bool {
-    let path = std::env::var_os("PATH").unwrap_or_default();
-    let exts: Vec<String> = if cfg!(windows) {
-        std::env::var("PATHEXT")
-            .unwrap_or_else(|_| ".EXE;.CMD;.BAT;.COM".into())
-            .split(';')
-            .map(|e| e.trim().to_lowercase())
-            .filter(|e| !e.is_empty())
-            .collect()
-    } else {
-        vec![String::new()]
-    };
-    for dir in std::env::split_paths(&path) {
-        for ext in &exts {
-            let cand = dir.join(format!("spt{ext}"));
-            if cand.is_file() {
-                return true;
-            }
-        }
-    }
-    false
-}
-
-/// Run `spt <args>` and capture stdout (None on spawn/exec failure). stderr → the daemon log (which
-/// DOES capture the translation binary's stderr, unlike CC-hook stderr).
-fn spt_capture(args: &[&str]) -> Option<String> {
-    let out = std::process::Command::new(spt_bin()).args(args).output().ok()?;
-    Some(String::from_utf8_lossy(&out.stdout).into_owned())
-}
-
-/// One heartbeat tick: pull the latest digest input for `endpoint_id`. None on any failure.
-fn pull_latest_input(endpoint_id: &str) -> Option<String> {
-    let out = spt_capture(&["endpoint", "digest", endpoint_id, "--last", "1", "--json"])?;
-    parse_latest_input(&out)
-}
-
-/// The heartbeat loop (runs on the spawned thread until the process is reaped). Never panics.
-fn watch_loop(endpoint_id: String) {
-    let mut healed = false;
-    loop {
-        std::thread::sleep(Duration::from_secs(POLL_SECS));
-        let latest = pull_latest_input(&endpoint_id);
-        let (mark_idle, next) = heal_decision(latest.as_deref(), healed);
-        healed = next;
-        if !mark_idle {
-            continue;
-        }
-        let Some(sid) = read_sid(&endpoint_id) else {
-            eprintln!("claude-spt interrupt-watch: {endpoint_id} interrupt seen but no sid carrier — cannot mark idle");
-            continue;
-        };
-        eprintln!("claude-spt interrupt-watch: {endpoint_id} interrupt marker at prompt — marking idle (receive-heal)");
-        let _ = spt_capture(&["api", "--adapter", ADAPTER, "state", "idle", &endpoint_id, "--session-id", &sid]);
-    }
-}
-
-/// Spawn the detached interrupt-watch heartbeat for `endpoint_id`. Called once from the translation
-/// binary's `init` handshake (where the endpoint id first becomes known). A blank id is ignored. The
-/// thread is detached — it dies with the process when spt-core reaps the translation binary.
-pub fn spawn(endpoint_id: &str) {
-    let id = endpoint_id.trim().to_string();
-    if id.is_empty() {
-        return;
-    }
-    std::thread::spawn(move || watch_loop(id));
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn interrupt_marker_matches_both_variants_only() {
-        assert!(is_interrupt_marker("[Request interrupted by user]"));
-        assert!(is_interrupt_marker("[Request interrupted by user for tool use]"));
-        // Leading whitespace tolerated (defensive).
-        assert!(is_interrupt_marker("  [Request interrupted by user]"));
-        // A real prompt that merely mentions it is NOT the marker (must be the whole input's start).
-        assert!(!is_interrupt_marker("please explain [Request interrupted by user]"));
-        assert!(!is_interrupt_marker("do the thing"));
-        assert!(!is_interrupt_marker(""));
-    }
-
-    #[test]
-    fn parse_latest_input_takes_the_last_turn() {
-        // The field shape from `spt endpoint digest lia --last 1 --json` (2026-07-08).
-        let j = r#"{"turns":[{"input":"[Request interrupted by user for tool use]","entries":[],"partial":true}]}"#;
-        assert_eq!(parse_latest_input(j).as_deref(), Some("[Request interrupted by user for tool use]"));
-        // Multiple turns → the LAST is the latest.
-        let multi = r#"{"turns":[{"input":"old prompt","entries":[]},{"input":"[Request interrupted by user]","entries":[]}]}"#;
-        assert_eq!(parse_latest_input(multi).as_deref(), Some("[Request interrupted by user]"));
-    }
-
-    #[test]
-    fn parse_latest_input_is_none_on_bad_or_empty() {
-        assert_eq!(parse_latest_input("not json"), None);
-        assert_eq!(parse_latest_input(r#"{"turns":[]}"#), None);
-        assert_eq!(parse_latest_input(r#"{"other":1}"#), None);
-        // A turn with a non-string / missing input → None (never a false heal).
-        assert_eq!(parse_latest_input(r#"{"turns":[{"entries":[]}]}"#), None);
-    }
-
-    // [unit->REQ-HAZARD-INTERRUPT-STUCK-BUSY] the heal-once state machine — the core of the fix-3
-    // receive-heal: a hookless Esc-interrupt is detected in the digest and healed exactly once.
-    #[test]
-    fn heal_decision_heals_once_per_interrupt() {
-        // First sight of the interrupt → heal + latch.
-        assert_eq!(heal_decision(Some("[Request interrupted by user]"), false), (true, true));
-        // Still the interrupt, already healed → do NOT re-heal, stay latched.
-        assert_eq!(heal_decision(Some("[Request interrupted by user for tool use]"), true), (false, true));
-    }
-
-    #[test]
-    fn heal_decision_rearms_when_agent_moves_on() {
-        // A non-interrupt latest turn re-arms (so the NEXT interrupt heals again).
-        assert_eq!(heal_decision(Some("a new prompt"), true), (false, false));
-        assert_eq!(heal_decision(Some("a new prompt"), false), (false, false));
-    }
-
-    #[test]
-    fn heal_decision_holds_state_on_a_failed_pull() {
-        // None (digest pull failed): never heal, never re-arm — hold the latch so a transient miss
-        // does not trigger a re-heal on the next successful tick.
-        assert_eq!(heal_decision(None, true), (false, true));
-        assert_eq!(heal_decision(None, false), (false, false));
-    }
-
-    #[test]
-    fn sid_carrier_path_matches_the_hook_writer_shape() {
-        // MUST match hook::sid_state_rel so we read exactly what the bind hook wrote.
-        assert_eq!(sid_state_rel("lia"), "state/session/lia.sid");
-        assert_eq!(sid_state_rel("cc @ n (p/)"), "state/session/ccnp.sid");
-    }
-}
diff --git a/tools/claude-spt/src/launch.rs b/tools/claude-spt/src/launch.rs
deleted file mode 100644
index 444a98d..0000000
--- a/tools/claude-spt/src/launch.rs
+++ /dev/null
@@ -1,449 +0,0 @@
-//! `claude-spt launch` — the `[session.self]` / `[session.resume]` CC spawn shim (v0.10.3).
-//!
-//! WHY A SHIM: the operator wants spt-hosted endpoints named `<id> @ <node>` (display) so a fleet
-//! of live agents is cross-node-distinguishable in the prompt box / `/resume` picker / terminal
-//! title — the REQ-DIST-RC-STARTUP STRETCH (doyle ask #4). spt-core's published fill catalog
-//! (harness-contract/manifest, v0.19.1) has NO `{node}` key, so the node name is not templatable
-//! manifest-side; and tokenize-then-fill can never produce a space-carrying single argv element
-//! anyway (`-n {id} @ {node}` would be three argv tokens). Both problems dissolve by routing the
-//! spawn through this shim: it runs ON the node, computes the hostname itself, and passes each
-//! name as one clean argv element. Same resolve-through-own-binary move as `hook`/`psyche`
-//! (ADR-0006); the `{node}` fill-key gap stays a reported spt-core finding, not a blocker.
-//!
-//! Invoked by the spt-core daemon (broker PTY leader):
-//!   claude-spt launch --id <id> [--cli claude|ccs] [--resume <session_id>] [--node <node>]
-//! and it spawns the real harness CLI:
-//!   <cli> [-r <session_id>] -n "<id> @ <node> (<project>/)" --remote-control <id>--<node>--<project-token> --dangerously-skip-permissions
-//!
-//! NAME SHAPES: display = `<id> @ <node> (<project>/)` (spaces/parens/slash fine — one argv element;
-//! the `<project>` is the launch cwd basename, the endpoint's project folder). Remote Control =
-//! `<id>--<node>--<project-token>`: RC session names are tokeny (CC's own auto-generated names use the
-//! hostname as prefix, `--remote-control-session-name-prefix` default), and whether the RC backend
-//! accepts spaces/`@`/`/` is not verifiable from the public surface — so the deterministic separator
-//! form is used with a CHARACTER-SAFE project token (`rc_project_token`: alphanumeric + `-`/`_`, other
-//! runs → `_`) rather than risking a bringup-time reject. `spt rc <id>` is UNAFFECTED either way: it
-//! attaches the broker-held PTY by ENDPOINT id (broker-internal), not by CC's RC name. An UNKNOWN
-//! project drops only its suffix (display `<id> @ <node>`, RC `<id>--<node>`); an UNKNOWN node
-//! degrades BOTH names to the bare `<id>` (the pre-0.10.3 shape) — never a half-named endpoint, never
-//! a failed launch.
-//!
-//! PTY: on unix this process exec()s the CLI (process replacement — the harness IS the PTY leader,
-//! zero interference). Windows has no exec: spawn with inherited stdio + wait + propagate the exit
-//! code. CC runs its TUI in raw mode, so ConPTY passes ^C through as bytes (no CTRL_C_EVENT racing
-//! the waiting shim in steady state). `ccs` on Windows is an npm `.cmd` shim — CreateProcess does
-//! not resolve those from a bare name, so the CLI is PATH-resolved to an explicit
-//! `.exe`/`.cmd`/`.bat` candidate first (std spawns an explicit `.cmd` via cmd.exe with safe
-//! quoting). [impl->REQ-DIST-RC-STARTUP]
-
-use std::path::PathBuf;
-use std::process::{Command, ExitCode};
-
-/// Parsed launch args: the daemon-filled keys we template (`{id}`, `{session_id}` on the resume
-/// role, `{node}` — the daemon's ADVERTISED node label, spt-core v0.20.0) plus the profile-static
-/// `--cli` selector (base manifest omits it → `claude`; the ccs profile overlay passes `--cli ccs`).
-#[derive(Debug, PartialEq)]
-struct Args {
-    id: String,
-    cli: String,
-    resume: Option<String>,
-    node: Option<String>,
-}
-
-impl Args {
-    /// Parse `--id V [--cli V] [--resume V] [--node V]` (order-independent, all single-value —
-    /// nothing here is prompt-shaped, so no greedy tail like psyche's `--prompt`). Unknown args are
-    /// loud: a manifest template drift must fail the bringup visibly, not launch a half-configured
-    /// session. `--node` is NORMALIZED here: blank or a literal un-substituted `{node}` (a core
-    /// that doesn't fill the key — the F-013 substitution-gap class) collapses to None, so the
-    /// caller falls back to on-node hostname detection instead of naming the session `x @ {node}`.
-    fn parse<I: IntoIterator<Item = String>>(argv: I) -> Result<Args, String> {
-        let (mut id, mut cli, mut resume, mut node) = (None, None, None, None);
-        let mut it = argv.into_iter();
-        while let Some(flag) = it.next() {
-            let want = |it: &mut dyn Iterator<Item = String>| {
-                it.next().ok_or_else(|| format!("{flag} expects a value"))
-            };
-            match flag.as_str() {
-                "--id" => id = Some(want(&mut it)?),
-                "--cli" => cli = Some(want(&mut it)?),
-                "--resume" => resume = Some(want(&mut it)?),
-                "--node" => node = Some(want(&mut it)?),
-                other => return Err(format!("unknown arg: {other}")),
-            }
-        }
-        Ok(Args {
-            id: id.ok_or("missing --id")?,
-            cli: cli.unwrap_or_else(|| "claude".to_string()),
-            resume,
-            node: node
-                .map(|s| s.trim().to_string())
-                .filter(|s| !s.is_empty() && s != "{node}"),
-        })
-    }
-}
-
-/// The env var carrying the spawned session's computed display name into CC: the SessionStart hook
-/// reads it back on a `/clear` boundary to re-assert the name (the boundary rename — CC drops the
-/// `-n` display name when a clear rotates the session). Same string as the `-n` argv element, so
-/// the rename re-applies EXACTLY the spawn name, degrade rules included (parity by construction —
-/// one computation site). [impl->REQ-DIST-BOUNDARY-RENAME]
-pub(crate) const SESSION_NAME_ENV: &str = "SPT_SESSION_NAME";
-
-/// FALLBACK node name for session naming when the manifest's `--node {node}` fill is absent
-/// (spt-core < 0.20.0 never passes it; a non-filling core collapses to None in `Args::parse`):
-/// `COMPUTERNAME` (Windows) else `HOSTNAME` (often unset in non-interactive POSIX shells) else
-/// the `hostname` command. None when nothing yields a non-blank value — the caller degrades to
-/// bare-`{id}` names. The daemon-advertised label (`--node`) is PREFERRED over this detection so
-/// session names match what the rest of the spt surface calls the node. [impl->REQ-DIST-RC-STARTUP]
-fn node_name() -> Option<String> {
-    for var in ["COMPUTERNAME", "HOSTNAME"] {
-        if let Ok(v) = std::env::var(var) {
-            let v = v.trim();
-            if !v.is_empty() {
-                return Some(v.to_string());
-            }
-        }
-    }
-    let out = Command::new("hostname").output().ok()?;
-    let v = String::from_utf8_lossy(&out.stdout).trim().to_string();
-    (!v.is_empty()).then_some(v)
-}
-
-/// The PROJECT FOLDER name for session naming: the basename of the launch cwd. The broker spawns this
-/// shim in the endpoint's recorded project dir, so `current_dir` basename IS the project folder — the
-/// same self-compute move as `node_name` (no `{project}` fill exists on the published surface). None
-/// when it can't be determined or is empty; the caller then omits the project suffix.
-/// [impl->REQ-DIST-RC-STARTUP]
-fn project_name() -> Option<String> {
-    let cwd = std::env::current_dir().ok()?;
-    let base = cwd.file_name()?.to_string_lossy().trim().to_string();
-    (!base.is_empty()).then_some(base)
-}
-
-/// Sanitize a project folder name into a Remote-Control-safe token: keep ASCII alphanumerics plus
-/// `-`/`_`, collapse any other run (spaces, `.`, `/`, `@`, unicode, …) to a single `_`, and trim
-/// leading/trailing `_`. RC session names are tokeny (CC prefixes with the hostname), so a raw folder
-/// name with spaces or path separators risks a bringup-time reject — the RC form uses this safe token
-/// while the `-n` display keeps the raw name (spaces/parens/slash are fine there). Empty result (a
-/// name with no alphanumerics) → None, so the suffix is omitted rather than a bare `--`. Pure.
-fn rc_project_token(project: &str) -> Option<String> {
-    let mut out = String::new();
-    let mut prev_us = false;
-    for c in project.chars() {
-        if c.is_ascii_alphanumeric() || c == '-' || c == '_' {
-            out.push(c);
-            prev_us = false;
-        } else if !prev_us {
-            out.push('_');
-            prev_us = true;
-        }
-    }
-    let trimmed = out.trim_matches('_').to_string();
-    (!trimmed.is_empty()).then_some(trimmed)
-}
-
-/// Display name (`-n`): `<id> @ <node> (<project>/)`, dropping the `(<project>/)` suffix when the
-/// project is unknown and degrading to bare `<id>` when the node is unknown. The raw project name is
-/// used verbatim (spaces/parens/slash are fine for the CC display name — one argv element). Pure.
-fn display_name(id: &str, node: Option<&str>, project: Option<&str>) -> String {
-    match node {
-        Some(n) => match project {
-            Some(p) => format!("{id} @ {n} ({p}/)"),
-            None => format!("{id} @ {n}"),
-        },
-        None => id.to_string(),
-    }
-}
-
-/// Remote Control name (`--remote-control`): `<id>--<node>--<project-token>`, dropping the project
-/// segment when it is unknown or sanitizes to empty, and degrading to bare `<id>` when the node is
-/// unknown. Separator form with a CHARACTER-SAFE project token (`rc_project_token`) — see the module
-/// comment. Pure.
-fn rc_name(id: &str, node: Option<&str>, project: Option<&str>) -> String {
-    match node {
-        Some(n) => match project.and_then(rc_project_token) {
-            Some(p) => format!("{id}--{n}--{p}"),
-            None => format!("{id}--{n}"),
-        },
-        None => id.to_string(),
-    }
-}
-
-/// The harness CLI argv (everything after the program): `[-r <session_id>]` first (mirrors the
-/// pre-0.10.3 `[session.resume]` flag order), then the two names, then skip-permissions (REQUIRED
-/// for the non-interactive broker PTY — REQ-HAZARD-PSYCHE-PERMS-DEADLOCK; no operator exists at
-/// spawn time to approve a permission prompt). Pure so the full command shape is unit-testable.
-/// [impl->REQ-DIST-RC-STARTUP]
-fn cli_argv(args: &Args, node: Option<&str>, project: Option<&str>) -> Vec<String> {
-    let mut v = Vec::new();
-    if let Some(sid) = &args.resume {
-        v.push("-r".into());
-        v.push(sid.clone());
-    }
-    v.push("-n".into());
-    v.push(display_name(&args.id, node, project));
-    v.push("--remote-control".into());
-    v.push(rc_name(&args.id, node, project));
-    v.push("--dangerously-skip-permissions".into());
-    v
-}
-
-/// PATH-resolve `name` to a spawnable program. Windows probes `.exe`/`.cmd`/`.bat` per PATH dir
-/// (bare `Command::new("ccs")` cannot spawn the npm `ccs.cmd` shim; an explicit `.cmd` path std
-/// runs via cmd.exe with safe quoting); POSIX returns the bare name (execvp resolves it). Pure
-/// over the supplied PATH string so resolution is unit-testable. Shared with `post-update` (its
-/// `ccs plugin update` follow-up hits the same .cmd-shim wall).
-pub(crate) fn resolve_program_from(name: &str, path: Option<&std::ffi::OsStr>) -> Option<PathBuf> {
-    if !cfg!(windows) {
-        return Some(PathBuf::from(name));
-    }
-    let path = path?;
-    for dir in std::env::split_paths(path) {
-        for ext in [".exe", ".cmd", ".bat"] {
-            let cand = dir.join(format!("{name}{ext}"));
-            if cand.is_file() {
-                return Some(cand);
-            }
-        }
-    }
-    None
-}
-
-/// `claude-spt launch` entry. Reads its own argv (binary name + `launch` token already consumed).
-pub fn run() -> ExitCode {
-    let args = match Args::parse(std::env::args().skip(2)) {
-        Ok(a) => a,
-        Err(e) => {
-            eprintln!("claude-spt launch: {e}");
-            return ExitCode::from(2);
-        }
-    };
-    let node = args.node.clone().or_else(node_name);
-    let project = project_name();
-    let argv = cli_argv(&args, node.as_deref(), project.as_deref());
-    let path = std::env::var_os("PATH");
-    let program = match resolve_program_from(&args.cli, path.as_deref()) {
-        Some(p) => p,
-        None => {
-            eprintln!("claude-spt launch: `{}` not found on PATH", args.cli);
-            return ExitCode::from(2);
-        }
-    };
-
-    let mut cmd = Command::new(&program);
-    cmd.args(&argv);
-    // Inherited through exec (unix — the Command env map survives process replacement) and
-    // spawn+wait (windows) alike; the hook, a CC child process, reads it like $SPT_ENDPOINT_ID.
-    // [impl->REQ-DIST-BOUNDARY-RENAME]
-    cmd.env(SESSION_NAME_ENV, display_name(&args.id, node.as_deref(), project.as_deref()));
-
-    #[cfg(unix)]
-    {
-        // exec() replaces this process — the harness becomes the PTY leader directly. Returning
-        // at all means the exec failed.
-        use std::os::unix::process::CommandExt;
-        let err = cmd.exec();
-        eprintln!("claude-spt launch: failed to exec `{}`: {err}", program.display());
-        ExitCode::from(1)
-    }
-    #[cfg(not(unix))]
-    {
-        // No exec on Windows: run the harness as a child on the same console and propagate its
-        // exit code (stdio inherited by default — the broker PTY reaches the harness untouched).
-        match cmd.status() {
-            Ok(st) => ExitCode::from(st.code().unwrap_or(1).clamp(0, 255) as u8),
-            Err(e) => {
-                eprintln!("claude-spt launch: failed to spawn `{}`: {e}", program.display());
-                ExitCode::from(1)
-            }
-        }
-    }
-}
-
-// [unit->REQ-DIST-RC-STARTUP]
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn args(v: &[&str]) -> Result<Args, String> {
-        Args::parse(v.iter().map(|s| s.to_string()))
-    }
-
-    #[test]
-    fn parses_id_only_defaults_to_claude_fresh() {
-        assert_eq!(
-            args(&["--id", "perri"]).unwrap(),
-            Args { id: "perri".into(), cli: "claude".into(), resume: None, node: None }
-        );
-    }
-
-    #[test]
-    fn parses_ccs_resume_order_independent() {
-        assert_eq!(
-            args(&["--resume", "sid-1", "--cli", "ccs", "--id", "perri"]).unwrap(),
-            Args {
-                id: "perri".into(),
-                cli: "ccs".into(),
-                resume: Some("sid-1".into()),
-                node: None
-            }
-        );
-    }
-
-    // [unit->REQ-DIST-BOUNDARY-RENAME]
-    #[test]
-    fn session_name_env_value_matches_the_display_argv() {
-        // The boundary rename re-applies SPT_SESSION_NAME verbatim, so its value MUST equal the
-        // `-n` argv element for the same (id, node, project) — across the whole degrade matrix.
-        // Both sides call display_name; this locks the -n slot to that single computation site.
-        let a = args(&["--id", "perri"]).unwrap();
-        for (node, project) in [
-            (Some("NODE"), Some("proj")),
-            (Some("NODE"), None),
-            (None, Some("proj")),
-            (None, None),
-        ] {
-            let argv = cli_argv(&a, node, project);
-            let n = argv.iter().position(|s| s == "-n").expect("-n present");
-            assert_eq!(argv[n + 1], display_name("perri", node, project), "node={node:?} project={project:?}");
-        }
-        assert_eq!(SESSION_NAME_ENV, "SPT_SESSION_NAME");
-    }
-
-    #[test]
-    fn missing_id_and_unknown_args_are_loud() {
-        assert!(args(&["--cli", "ccs"]).unwrap_err().contains("missing --id"));
-        assert!(args(&["--id", "x", "--nope"]).unwrap_err().contains("unknown arg"));
-        assert!(args(&["--id"]).unwrap_err().contains("expects a value"));
-    }
-
-    // [unit->REQ-DIST-RC-STARTUP] the {node} fill adoption (spt-core v0.20.0): the daemon's
-    // advertised node label arrives via --node and is used verbatim for both names.
-    #[test]
-    fn parses_node_as_the_advertised_label() {
-        let a = args(&["--id", "perri", "--node", "hfend-lab"]).unwrap();
-        assert_eq!(a.node.as_deref(), Some("hfend-lab"));
-        assert_eq!(
-            cli_argv(&a, a.node.as_deref(), Some("spt-claude-code")),
-            vec![
-                "-n",
-                "perri @ hfend-lab (spt-claude-code/)",
-                "--remote-control",
-                "perri--hfend-lab--spt-claude-code",
-                "--dangerously-skip-permissions",
-            ]
-        );
-    }
-
-    // [unit->REQ-DIST-RC-STARTUP] a core that does NOT substitute {node} (the F-013 gap class)
-    // or fills it blank must collapse to None — the shim then falls back to hostname detection,
-    // never naming a session `x @ {node}`.
-    #[test]
-    fn unsubstituted_or_blank_node_collapses_to_fallback() {
-        assert_eq!(args(&["--id", "x", "--node", "{node}"]).unwrap().node, None);
-        assert_eq!(args(&["--id", "x", "--node", "  "]).unwrap().node, None);
-        assert_eq!(args(&["--id", "x", "--node", " n1 "]).unwrap().node.as_deref(), Some("n1"));
-    }
-
-    #[test]
-    fn names_carry_id_at_node_project_and_separator_rc() {
-        // Display = "<id> @ <node> (<project>/)" (spaced, one argv element); RC = separator token form.
-        assert_eq!(
-            display_name("perri", Some("HFENDULEAM"), Some("spt-claude-code")),
-            "perri @ HFENDULEAM (spt-claude-code/)"
-        );
-        assert_eq!(
-            rc_name("perri", Some("HFENDULEAM"), Some("spt-claude-code")),
-            "perri--HFENDULEAM--spt-claude-code"
-        );
-    }
-
-    #[test]
-    fn unknown_project_drops_only_its_suffix() {
-        // No project → the pre-project shapes (node still present).
-        assert_eq!(display_name("perri", Some("HFENDULEAM"), None), "perri @ HFENDULEAM");
-        assert_eq!(rc_name("perri", Some("HFENDULEAM"), None), "perri--HFENDULEAM");
-    }
-
-    #[test]
-    fn unknown_node_degrades_both_names_to_bare_id() {
-        // The pre-0.10.3 shape — never a half-named endpoint, never a failed launch. Project is
-        // dropped too (the enriched suffixes ride the node).
-        assert_eq!(display_name("perri", None, Some("proj")), "perri");
-        assert_eq!(rc_name("perri", None, Some("proj")), "perri");
-    }
-
-    #[test]
-    fn rc_project_token_sanitizes_incompatible_chars() {
-        // Spaces, dots, slashes, @, unicode collapse to single underscores; alnum/-/_ survive.
-        assert_eq!(rc_project_token("spt-claude-code").as_deref(), Some("spt-claude-code"));
-        assert_eq!(rc_project_token("My Project").as_deref(), Some("My_Project"));
-        assert_eq!(rc_project_token("a.b/c@d").as_deref(), Some("a_b_c_d"));
-        assert_eq!(rc_project_token("  padded  ").as_deref(), Some("padded"));
-        assert_eq!(rc_project_token("under_score-ok").as_deref(), Some("under_score-ok"));
-        // A name with no alphanumerics sanitizes to empty → None (suffix omitted, no bare `--`).
-        assert_eq!(rc_project_token("!!! ..."), None);
-        // The display name keeps the raw project verbatim; only RC sanitizes.
-        assert_eq!(
-            display_name("id", Some("N"), Some("My Project")),
-            "id @ N (My Project/)"
-        );
-        assert_eq!(rc_name("id", Some("N"), Some("My Project")), "id--N--My_Project");
-    }
-
-    #[test]
-    fn fresh_argv_has_names_then_skip_perms() {
-        let a = args(&["--id", "perri"]).unwrap();
-        assert_eq!(
-            cli_argv(&a, Some("HFENDULEAM"), Some("spt-claude-code")),
-            vec![
-                "-n",
-                "perri @ HFENDULEAM (spt-claude-code/)",
-                "--remote-control",
-                "perri--HFENDULEAM--spt-claude-code",
-                "--dangerously-skip-permissions",
-            ]
-        );
-    }
-
-    #[test]
-    fn resume_argv_leads_with_native_resume_verb() {
-        // -r {session_id} FIRST (pre-0.10.3 [session.resume] flag order), then the U6 name flags.
-        let a = args(&["--id", "perri", "--resume", "sid-1"]).unwrap();
-        assert_eq!(
-            cli_argv(&a, Some("N1"), Some("proj")),
-            vec![
-                "-r",
-                "sid-1",
-                "-n",
-                "perri @ N1 (proj/)",
-                "--remote-control",
-                "perri--N1--proj",
-                "--dangerously-skip-permissions",
-            ]
-        );
-    }
-
-    #[cfg(windows)]
-    #[test]
-    fn windows_resolution_finds_cmd_shims_and_misses_are_none() {
-        // An npm `ccs.cmd` shim must resolve to its explicit path (bare names can't spawn .cmd).
-        let dir = std::env::temp_dir().join("claude-spt-launch-test-path");
-        std::fs::create_dir_all(&dir).unwrap();
-        std::fs::write(dir.join("fakecli.cmd"), "@echo off\r\n").unwrap();
-        let path = std::env::join_paths([&dir]).unwrap();
-        assert_eq!(
-            resolve_program_from("fakecli", Some(path.as_os_str())),
-            Some(dir.join("fakecli.cmd"))
-        );
-        assert_eq!(resolve_program_from("no-such-cli-xyz", Some(path.as_os_str())), None);
-        let _ = std::fs::remove_dir_all(&dir);
-    }
-
-    #[cfg(unix)]
-    #[test]
-    fn unix_resolution_is_the_bare_name() {
-        // execvp does PATH resolution itself; the shim passes the bare name through.
-        assert_eq!(resolve_program_from("ccs", None), Some(PathBuf::from("ccs")));
-    }
-}
diff --git a/tools/claude-spt/src/main.rs b/tools/claude-spt/src/main.rs
deleted file mode 100644
index c8ac711..0000000
--- a/tools/claude-spt/src/main.rs
+++ /dev/null
@@ -1,194 +0,0 @@
-//! claude-spt — consolidated tool binary for the claude-spt adapter (ADR-0006, U2).
-//!
-//! ONE binary, one set of subcommands (was three crates → fewer artifacts per triple in adapter.spt):
-//!   claude-spt digest      — the [digest] extractor (was claude-spt-digest)
-//!   claude-spt psyche      — the [session.psyche_init] Psyche runner (was claude-spt-psyche)
-//!   claude-spt post-update — reconcile the cplugs plugin after `spt adapter update` (ADR-0006)
-//!   claude-spt translate   — the [message-idle-translation-binary] idle filter (was cc-spt-idle-translate)
-//!   claude-spt hook <ev>   — the CC hook handler (D1: hook logic moved off the plugin shell so it
-//!                            rides `spt adapter update`; was the eight plugin hook .sh wrappers)
-//!   claude-spt launch      — the [session.self]/[session.resume] CC spawn shim (node-named
-//!                            sessions: -n "<id> @ <node>" + --remote-control <id>--<node>)
-//!
-//! Dispatch is a bare `argv[1]` match (no clap — keep the dependency-light ethos the predecessor
-//! crates were built on). Each subcommand owns its remaining argv via `std::env::args().skip(2)`
-//! (skip the binary name + the subcommand token) and its own hand-written flag parser. `translate`
-//! reads no argv (pure stdin/stdout protocol).
-//!
-//! `translate` folded in at the v0.8.0 cut once spt-core v0.16.0 gave `[message-idle-translation-
-//! binary]` a `command` field (D3) — so claude-spt is now the SINGLE tool binary (one artifact per
-//! triple in adapter.spt). [impl->REQ-DIST-BINARY-CONSOLIDATE] [impl->REQ-DIST-IDLE-TRANSLATE]
-
-mod bridge;
-mod digest;
-mod digest_omp;
-mod echo_commune;
-mod echo_commune_omp;
-mod history;
-mod history_omp;
-mod hook;
-mod interrupt_watch;
-mod launch;
-mod post_update;
-mod psyche;
-mod psyche_omp;
-mod tag_scan;
-mod translate;
-
-use std::process::ExitCode;
-
-/// The resolved subcommand. Pure classification of `argv[1]` so dispatch routing is unit-testable
-/// without spawning the binary. [impl->REQ-DIST-BINARY-CONSOLIDATE]
-#[derive(Debug, PartialEq)]
-enum Sub {
-    Bridge,
-    Digest,
-    DigestOmp,
-    EchoCommune,
-    EchoCommuneOmp,
-    History,
-    HistoryOmp,
-    Psyche,
-    PsycheOmp,
-    PostUpdate,
-    Translate,
-    Hook,
-    Launch,
-    Help,
-    Unknown(String),
-}
-
-fn classify(sub: Option<&str>) -> Sub {
-    match sub {
-        Some("bridge") => Sub::Bridge,
-        Some("digest") => Sub::Digest,
-        Some("digest-omp") => Sub::DigestOmp,
-        Some("echo-commune") => Sub::EchoCommune,
-        Some("echo-commune-omp") => Sub::EchoCommuneOmp,
-        Some("history") => Sub::History,
-        Some("history-omp") => Sub::HistoryOmp,
-        Some("psyche") => Sub::Psyche,
-        Some("psyche-omp") => Sub::PsycheOmp,
-        Some("post-update") => Sub::PostUpdate,
-        Some("translate") => Sub::Translate,
-        Some("hook") => Sub::Hook,
-        Some("launch") => Sub::Launch,
-        None | Some("-h") | Some("--help") => Sub::Help,
-        Some(other) => Sub::Unknown(other.to_string()),
-    }
-}
-
-fn usage() {
-    eprintln!(
-        "claude-spt <subcommand> [args]\n\
-         \n\
-         subcommands:\n\
-         \x20 bridge       drive omp via `omp --mode rpc`, relaying spt api seed/poll/state (ready-agent)\n\
-         \x20 digest       map a Claude Code JSONL transcript to digest NDJSON ([digest] extractor)\n\
-         \x20 digest-omp   map an oh-my-pi (omp) session JSONL to digest NDJSON (omp [digest] extractor)\n\
-         \x20 history-omp  stream an omp session JSONL verbatim (omp [history] fetcher)\n\
-         \x20 psyche-omp   run one ephemeral omp Psyche turn ([session.psyche_resume], omp-flavored)\n\
-         \x20 echo-commune-omp  bounded end-of-session summarizer over an omp transcript\n\
-         \x20 echo-commune bounded end-of-session summarizer ([session.echo_commune] role)\n\
-         \x20 history      stream a session's CC JSONL transcript verbatim ([history] fetcher)\n\
-         \x20 psyche       run the LiveAgent Psyche companion ([session.psyche_init] runner)\n\
-         \x20 post-update  reconcile the cplugs plugin after `spt adapter update`\n\
-         \x20 translate    idle-message translation filter (stdin->stdout JSON lines)\n\
-         \x20 hook <event> handle a Claude Code hook event (stdin = the CC hook payload)\n\
-         \x20 launch       spawn the CC session with node-named display/RC ([session.self]/[session.resume])"
-    );
-}
-
-fn main() -> ExitCode {
-    let sub = std::env::args().nth(1);
-    match classify(sub.as_deref()) {
-        Sub::Bridge => bridge::run(),
-        Sub::Digest => digest::run(),
-        Sub::DigestOmp => digest_omp::run(),
-        Sub::EchoCommune => echo_commune::run(),
-        Sub::EchoCommuneOmp => echo_commune_omp::run(),
-        Sub::History => history::run(),
-        Sub::HistoryOmp => history_omp::run(),
-        Sub::Psyche => psyche::run(),
-        Sub::PsycheOmp => psyche_omp::run(),
-        Sub::PostUpdate => post_update::run(),
-        Sub::Translate => translate::run(),
-        Sub::Hook => hook::run(),
-        Sub::Launch => launch::run(),
-        Sub::Help => {
-            usage();
-            ExitCode::SUCCESS
-        }
-        Sub::Unknown(other) => {
-            // DEGRADE, NEVER BRICK (REQ-HAZARD-HOOKCMD-DISPATCH-LOCKSTEP). A stale plugin
-            // dispatch.sh (old 0.1.8 shape) execs `claude-spt <CCEvent>` WITHOUT the `hook` token —
-            // e.g. `claude-spt UserPromptSubmit`. Exiting nonzero here made CC treat every hook as a
-            // blocking failure (all tools blocked + a looping Stop hook) with zero self-repair. So
-            // when the unknown subcommand is actually a CC hook event, route it through as a hook
-            // (the perch keeps working) and emit a NON-blocking stderr note about the skew. A genuine
-            // typo (not a hook event) still exits loud so real misinvocations are not masked.
-            if hook::is_cc_hook_event(&other) {
-                eprintln!(
-                    "claude-spt: received CC hook event '{other}' as a bare subcommand — the sptc \
-                     plugin dispatch is stale (dropped the `hook` token). Handling it anyway; run \
-                     /reload-plugins to refresh the plugin. [REQ-HAZARD-HOOKCMD-DISPATCH-LOCKSTEP]"
-                );
-                hook::run_event(&other)
-            } else {
-                eprintln!("claude-spt: unknown subcommand: {other}");
-                usage();
-                ExitCode::from(2)
-            }
-        }
-    }
-}
-
-// [unit->REQ-DIST-BINARY-CONSOLIDATE]
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn classifies_each_real_subcommand() {
-        assert_eq!(classify(Some("bridge")), Sub::Bridge);
-        assert_eq!(classify(Some("digest")), Sub::Digest);
-        assert_eq!(classify(Some("digest-omp")), Sub::DigestOmp);
-        assert_eq!(classify(Some("history-omp")), Sub::HistoryOmp);
-        assert_eq!(classify(Some("psyche-omp")), Sub::PsycheOmp);
-        assert_eq!(classify(Some("echo-commune-omp")), Sub::EchoCommuneOmp);
-        assert_eq!(classify(Some("echo-commune")), Sub::EchoCommune);
-        assert_eq!(classify(Some("history")), Sub::History);
-        assert_eq!(classify(Some("psyche")), Sub::Psyche);
-        assert_eq!(classify(Some("post-update")), Sub::PostUpdate);
-        assert_eq!(classify(Some("translate")), Sub::Translate);
-        assert_eq!(classify(Some("hook")), Sub::Hook);
-        assert_eq!(classify(Some("launch")), Sub::Launch);
-    }
-
-    #[test]
-    fn no_subcommand_and_help_flags_are_help() {
-        assert_eq!(classify(None), Sub::Help);
-        assert_eq!(classify(Some("-h")), Sub::Help);
-        assert_eq!(classify(Some("--help")), Sub::Help);
-    }
-
-    #[test]
-    fn unrecognized_subcommand_is_unknown_not_misrouted() {
-        // A typo must NOT silently fall through to a real subcommand (it exits 2 in main).
-        assert_eq!(classify(Some("digset")), Sub::Unknown("digset".into()));
-    }
-
-    // [unit->REQ-HAZARD-HOOKCMD-DISPATCH-LOCKSTEP]
-    #[test]
-    fn stale_dispatch_cc_event_degrades_typo_stays_loud() {
-        // The stale-dispatch signature: `claude-spt <CCEvent>` (the `hook` token dropped) classifies
-        // as Unknown, but main routes it through hook::run_event (exit 0, pass-through) BECAUSE the
-        // token is a CC hook event. A genuine typo is NOT a hook event → stays the loud exit-2 path.
-        for ev in hook::CC_HOOK_EVENTS {
-            assert_eq!(classify(Some(ev)), Sub::Unknown((*ev).to_string()));
-            assert!(hook::is_cc_hook_event(ev), "{ev} must be recognised as a CC hook event");
-        }
-        assert!(!hook::is_cc_hook_event("digset")); // typo → loud exit-2 branch, not degrade
-        assert!(!hook::is_cc_hook_event("digest")); // a real subcommand is never a hook event
-    }
-}
diff --git a/tools/claude-spt/src/post_update.rs b/tools/claude-spt/src/post_update.rs
deleted file mode 100644
index 35e2d19..0000000
--- a/tools/claude-spt/src/post_update.rs
+++ /dev/null
@@ -1,529 +0,0 @@
-//! `claude-spt post-update` — reconcile the cplugs plugin after `spt adapter update` (NEW, ADR-0006).
-//!
-//! `spt adapter update` pulls the adapter `.spt` (manifest + binaries + strings — the high-churn
-//! surface) but it CANNOT touch the cplugs plugin (the thin skeleton: hooks.json + skill stubs +
-//! plugin.json), which lives in Claude Code's marketplace registry. This subcommand closes that gap:
-//! detect the host CLI (`claude`, or `ccs` — a drop-in), ensure the `cplugs` marketplace is
-//! registered, then install/update the plugin. When ccs is installed ALONGSIDE claude, it ALSO runs
-//! `ccs plugin update sptc@cplugs` (best-effort) — ccs sessions read their own per-account plugin
-//! tree, which the claude-side reconcile never touches (v0.10.3, REQ-DIST-CCS-PLUGIN-FOLLOWUP).
-//! It then PRINTS a notice — it CANNOT run
-//! `/reload-plugins` (a TUI-only action), so the manual residual is the user's `/reload-plugins`.
-//!
-//! WIRED (spt-core v0.16.0, D2): the manifest `[update.post] = {command = "{adapter_dir}/claude-spt
-//! post-update", self_verifies = false}` runs this AFTER the `gh_release` pull, UNCONDITIONALLY.
-//! spt-core pipes ONE JSON line on stdin — `{adapter_applied, adapter_name, profile_name, version,
-//! previous_version, adapter_dir}` (additive; we ignore unknown keys) — and reads our STDOUT to
-//! arbitrate the update notice: custom text SUPERSEDES `[update].message`; the reserved sentinel
-//! `!!update-message!!` (alone) FIRES the static `[update].message`; empty = nothing. Exit code is
-//! orthogonal (the pull is never rolled back on our failure — fail-isolated). `self_verifies` is
-//! attestation-only (gates nothing yet).
-//!
-//! We use the SENTINEL strategy: on a successful real reconcile we print `!!update-message!!` so the
-//! single user-facing copy lives once in `[update].message` (the /reload-plugins + go-live notice,
-//! REQ-DIST-UPDATE-MESSAGE). Diagnostics go to STDERR (never stdout — stdout is the arbiter channel).
-//!
-//! THREE invocation modes:
-//!   * `[update.post]` (stdin is a piped JSON line) — reconcile, then stdout = sentinel on success / empty.
-//!   * standalone by hand / `/sptc:setup` (stdin is a TTY) — reconcile, then print the human notice to stdout.
-//!   * `--dry-run` / `-n` — print the intended actions (no spawn); the deterministic surface the int asserts.
-//! [impl->REQ-DIST-BINARY-CONSOLIDATE] [impl->REQ-DIST-UPDATE-MESSAGE]
-
-use std::io::{IsTerminal, Read};
-use std::path::PathBuf;
-use std::process::{Command, ExitCode, Stdio};
-
-/// Reserved stdout sentinel: printing it (alone) tells spt-core to fire the static `[update].message`.
-const UPDATE_MESSAGE_SENTINEL: &str = "!!update-message!!";
-
-const MARKETPLACE: &str = "cplugs";
-const MARKETPLACE_REPO: &str = "SaberMage/cplugs";
-/// Plugin reference Claude Code keys by: `<plugin.json name>@<marketplace>`. This milestone the
-/// plugin stays `sptc` (the `sptc`→`spt` succession is D4, owl-gated) so the ref is `sptc@cplugs`.
-const PLUGIN_REF: &str = "sptc@cplugs";
-
-/// Pick the CLI to drive. Prefer real `claude`; fall back to `ccs` (a documented drop-in for the
-/// `claude` binary, same argv). Pure so the PATH probe stays at the edge and routing is testable.
-fn choose_cli(has_claude: bool, has_ccs: bool) -> Option<&'static str> {
-    if has_claude {
-        Some("claude")
-    } else if has_ccs {
-        Some("ccs")
-    } else {
-        None
-    }
-}
-
-/// `<cli> plugin marketplace add SaberMage/cplugs` — register the marketplace (run only when absent).
-fn marketplace_add_cmd() -> Vec<String> {
-    ["plugin", "marketplace", "add", MARKETPLACE_REPO]
-        .iter()
-        .map(|s| (*s).to_string())
-        .collect()
-}
-
-/// `<cli> plugin marketplace update cplugs` — REFRESH the local marketplace cache before install.
-/// Without this, an ALREADY-registered-but-stale `cplugs` cache makes `plugin install sptc@cplugs`
-/// fail with "Plugin sptc not found in marketplace cplugs ... try claude plugin marketplace update
-/// cplugs" (the v0.9.0 bug). Run when the marketplace is already registered (a fresh `add` already
-/// fetches). [impl->REQ-DIST-UPDATE-MESSAGE]
-fn marketplace_update_cmd() -> Vec<String> {
-    ["plugin", "marketplace", "update", MARKETPLACE]
-        .iter()
-        .map(|s| (*s).to_string())
-        .collect()
-}
-
-/// `<cli> plugin (install|update) sptc@cplugs` — `update` when already installed, else `install`.
-fn plugin_sync_cmd(installed: bool) -> Vec<String> {
-    let verb = if installed { "update" } else { "install" };
-    ["plugin", verb, PLUGIN_REF]
-        .iter()
-        .map(|s| (*s).to_string())
-        .collect()
-}
-
-/// Does the ccs FOLLOW-UP apply? (operator ask, v0.10.3): when BOTH CLIs are on PATH the primary
-/// reconcile drives `claude` — but ccs-launched sessions read their own per-account plugin tree
-/// (the CLAUDE_CONFIG_DIR relocation, ~/.ccs/instances/<account>/.claude), which the claude-side
-/// reconcile never touches. So the update ALSO runs `ccs plugin update sptc@cplugs` (ccs applies
-/// it in its own account context). Not needed when ccs is absent, nor when ccs IS the primary
-/// (already reconciled). Pure. [impl->REQ-DIST-CCS-PLUGIN-FOLLOWUP]
-fn ccs_followup_needed(primary: &str, has_ccs: bool) -> bool {
-    has_ccs && primary != "ccs"
-}
-
-/// The follow-up argv: `plugin update sptc@cplugs` — always `update` (never `install`): if a ccs
-/// account never installed the plugin, force-installing it is not this reconcile's call; the
-/// follow-up refreshes what exists and its failure is best-effort noise, never a post-update fail.
-/// [impl->REQ-DIST-CCS-PLUGIN-FOLLOWUP]
-fn ccs_followup_cmd() -> Vec<String> {
-    ["plugin", "update", PLUGIN_REF]
-        .iter()
-        .map(|s| (*s).to_string())
-        .collect()
-}
-
-/// Parse a `from <old> to <new>` version transition out of Claude Code's `plugin update` stdout
-/// (e.g. `Plugin "sptc" updated from 0.1.3 to 0.1.8 for scope user.`). None when CC's wording does
-/// not carry one (a fresh install, or a future CC reformat). Pure. [impl->REQ-DIST-UPDATE-MESSAGE]
-fn parse_version_transition(cc_output: &str) -> Option<(String, String)> {
-    // Scan for the literal " from <tok> to <tok>" without a regex dep.
-    let i = cc_output.find(" from ")?;
-    let rest = &cc_output[i + " from ".len()..];
-    let to = rest.find(" to ")?;
-    let old = rest[..to].trim();
-    let after = &rest[to + " to ".len()..];
-    // <new> is the next whitespace-delimited token (version dots are part of it), minus any trailing
-    // sentence punctuation (e.g. `0.1.8 for scope user.` or `0.1.8.`).
-    let new: &str = after
-        .split_whitespace()
-        .next()
-        .unwrap_or("")
-        .trim_end_matches(['.', ',']);
-    if old.is_empty() || new.is_empty() {
-        return None;
-    }
-    Some((old.to_string(), new.to_string()))
-}
-
-/// The reworded plugin-sync notice (REQ-DIST-UPDATE-MESSAGE). Names Claude Code explicitly and the
-/// exact manual residual (`/reload-plugins`) — avoiding CC's "Restart to apply changes" wording.
-/// Carries the version transition when CC reported one. Pure. [impl->REQ-DIST-UPDATE-MESSAGE]
-fn reworded_notice(transition: Option<(&str, &str)>) -> String {
-    match transition {
-        Some((old, new)) => format!(
-            "✔ Claude Code plugin \"sptc\" updated from {old} to {new}. Active sessions need to run the /reload-plugins command."
-        ),
-        None => "✔ Claude Code plugin \"sptc\" reconciled. Active sessions need to run the /reload-plugins command.".to_string(),
-    }
-}
-
-/// Is `MARKETPLACE` registered? Parses `known_marketplaces.json` — a top-level object keyed by
-/// marketplace name, each with `source.repo`. True if the `cplugs` key exists OR any entry's repo is
-/// `SaberMage/cplugs` (robust to a differently-named registration of the same repo). Pure over the
-/// file contents (read at the edge). Malformed/empty -> false (caller registers it).
-fn marketplace_registered_in(json: &str) -> bool {
-    let v: serde_json::Value = match serde_json::from_str(json) {
-        Ok(v) => v,
-        Err(_) => return false,
-    };
-    let obj = match v.as_object() {
-        Some(o) => o,
-        None => return false,
-    };
-    if obj.contains_key(MARKETPLACE) {
-        return true;
-    }
-    obj.values().any(|entry| {
-        entry
-            .get("source")
-            .and_then(|s| s.get("repo"))
-            .and_then(|r| r.as_str())
-            == Some(MARKETPLACE_REPO)
-    })
-}
-
-/// Is the plugin already installed? Parses `installed_plugins.json` — `{ plugins: { "<ref>": [...] } }`
-/// — and checks for the `sptc@cplugs` key. Pure over the file contents. Malformed/empty/absent ->
-/// false (caller installs rather than updates).
-fn plugin_installed_in(json: &str) -> bool {
-    serde_json::from_str::<serde_json::Value>(json)
-        .ok()
-        .and_then(|v| {
-            v.get("plugins")
-                .and_then(|p| p.as_object())
-                .map(|p| p.contains_key(PLUGIN_REF))
-        })
-        .unwrap_or(false)
-}
-
-/// Executable names to probe on PATH for `name`. Windows resolves `claude`/`ccs` via PATHEXT
-/// (`.exe`/`.cmd`/`.bat`); POSIX uses the bare name. Pure so PATH resolution is testable.
-fn program_candidates(name: &str) -> Vec<String> {
-    if cfg!(windows) {
-        ["", ".exe", ".cmd", ".bat"]
-            .iter()
-            .map(|ext| format!("{name}{ext}"))
-            .collect()
-    } else {
-        vec![name.to_string()]
-    }
-}
-
-/// Claude Code's config root: `$CLAUDE_CONFIG_DIR` (set by `ccs` per-account) else `~/.claude`.
-fn claude_config_dir() -> Option<PathBuf> {
-    if let Some(cfg) = std::env::var_os("CLAUDE_CONFIG_DIR") {
-        if !cfg.is_empty() {
-            return Some(PathBuf::from(cfg));
-        }
-    }
-    std::env::var_os("HOME")
-        .or_else(|| std::env::var_os("USERPROFILE"))
-        .map(|home| PathBuf::from(home).join(".claude"))
-}
-
-/// True if `name` (or a PATHEXT variant) resolves to a file on any PATH dir.
-fn which(name: &str) -> bool {
-    let path = match std::env::var_os("PATH") {
-        Some(p) => p,
-        None => return false,
-    };
-    let cands = program_candidates(name);
-    std::env::split_paths(&path).any(|dir| cands.iter().any(|c| dir.join(c).is_file()))
-}
-
-/// Parse the [update.post] stdin JSON line (ADDITIVE — ignore unknown keys, per doyle). Returns the
-/// `adapter_applied` flag (whether the adapter version was applied this run); false on absent/bad
-/// JSON. Pure so the stdin read stays at the edge. [impl->REQ-DIST-UPDATE-MESSAGE]
-fn update_applied_in(json: &str) -> bool {
-    serde_json::from_str::<serde_json::Value>(json)
-        .ok()
-        .and_then(|v| v.get("adapter_applied").and_then(|b| b.as_bool()))
-        .unwrap_or(false)
-}
-
-/// The stdout ARBITER line for the [update.post] channel: the reserved sentinel (→ spt-core fires the
-/// static `[update].message`) when the reconcile ran OR the adapter was applied, else empty (nothing).
-/// We fire on any successful real reconcile so the one-lever `spt adapter update` always surfaces the
-/// /reload-plugins reminder (the user-facing copy lives once in `[update].message`). Pure.
-/// [impl->REQ-DIST-UPDATE-MESSAGE]
-fn arbiter_line(reconciled: bool, adapter_applied: bool) -> &'static str {
-    if reconciled || adapter_applied {
-        UPDATE_MESSAGE_SENTINEL
-    } else {
-        ""
-    }
-}
-
-/// `claude-spt post-update` entry. Reads its own argv (binary name + `post-update` token consumed).
-pub fn run() -> ExitCode {
-    let dry_run = std::env::args()
-        .skip(2)
-        .any(|a| a == "--dry-run" || a == "-n");
-
-    // [update.post] mode iff stdin is a piped JSON line (spt-core pipes one line then closes); a TTY
-    // stdin = standalone-by-hand. --dry-run forces the standalone-diagnostic path regardless.
-    let post_mode = !dry_run && !std::io::stdin().is_terminal();
-    let mut adapter_applied = false;
-    if post_mode {
-        let mut buf = String::new();
-        let _ = std::io::stdin().read_to_string(&mut buf);
-        adapter_applied = update_applied_in(buf.trim());
-    }
-
-    let (has_claude, has_ccs) = (which("claude"), which("ccs"));
-    let cli = match choose_cli(has_claude, has_ccs) {
-        Some(c) => c,
-        None => {
-            // fail-isolated: spt-core never rolls back the pull on our exit code. stderr, not stdout.
-            eprintln!("claude-spt post-update: no `claude` or `ccs` CLI on PATH — cannot reconcile the plugin");
-            return ExitCode::from(3);
-        }
-    };
-    // Spawn via the PATH-resolved program: `ccs` is an npm `.cmd` shim on Windows, which a bare
-    // Command::new cannot start (same wall the launch shim hits — resolver shared from launch.rs).
-    let path_env = std::env::var_os("PATH");
-    let resolve = |name: &str| {
-        crate::launch::resolve_program_from(name, path_env.as_deref())
-            .unwrap_or_else(|| PathBuf::from(name))
-    };
-    let cli_program = resolve(cli);
-
-    let plugins_dir = claude_config_dir().map(|d| d.join("plugins"));
-    let read = |name: &str| -> String {
-        plugins_dir
-            .as_ref()
-            .and_then(|d| std::fs::read_to_string(d.join(name)).ok())
-            .unwrap_or_default()
-    };
-    let registered = marketplace_registered_in(&read("known_marketplaces.json"));
-    let installed = plugin_installed_in(&read("installed_plugins.json"));
-
-    let mut steps: Vec<Vec<String>> = Vec::new();
-    if !registered {
-        steps.push(marketplace_add_cmd());
-    } else {
-        // Registered-but-possibly-STALE cache: refresh it so `plugin install` sees the latest sptc.
-        // (The v0.9.0 bug: install failed "Plugin sptc not found in marketplace cplugs" on a stale
-        // cache because this step was missing.) A fresh `add` above already fetches, so this only
-        // runs on the already-registered path.
-        steps.push(marketplace_update_cmd());
-    }
-    steps.push(plugin_sync_cmd(installed));
-    let sync_idx = steps.len() - 1; // the last step is always the plugin install/update.
-
-    for (i, argv) in steps.iter().enumerate() {
-        let shown = format!("{cli} {}", argv.join(" "));
-        if dry_run {
-            println!("would run: {shown}"); // diagnostic preview to stdout (no spt-core arbiter present)
-            continue;
-        }
-        // Diagnostics → STDERR: stdout is the [update.post] arbiter channel (sentinel/custom/empty).
-        eprintln!("claude-spt post-update: {shown}");
-        // CAPTURE the subprocess output — it must NOT inherit our stdout. In [update.post] mode our
-        // stdout is the arbiter channel; CC's verbose `plugin update` line leaking there would be read
-        // by spt-core as a CUSTOM update message (superseding [update].message) — the v0.9.0 wording bug.
-        let output = match Command::new(&cli_program).args(argv).stdin(Stdio::null()).output() {
-            Ok(o) => o,
-            Err(e) => {
-                eprintln!("claude-spt post-update: failed to spawn `{shown}`: {e}");
-                return ExitCode::from(1);
-            }
-        };
-        let so = String::from_utf8_lossy(&output.stdout);
-        let se = String::from_utf8_lossy(&output.stderr);
-        if !output.status.success() {
-            // Surface CC's own diagnostics on STDERR (spt-core displays post-step stderr), fail-isolated.
-            if !so.trim().is_empty() {
-                eprintln!("{}", so.trim_end());
-            }
-            if !se.trim().is_empty() {
-                eprintln!("{}", se.trim_end());
-            }
-            eprintln!("claude-spt post-update: `{shown}` exited {}", output.status);
-            return ExitCode::from(1); // stdout stays empty so no notice fires
-        }
-        if i == sync_idx {
-            // Reword CC's "Plugin sptc updated from X to Y for scope user. Restart to apply changes."
-            // → name Claude Code + the exact /reload-plugins residual, carrying the version transition.
-            let transition = parse_version_transition(&so);
-            let line = reworded_notice(transition.as_ref().map(|(o, n)| (o.as_str(), n.as_str())));
-            if post_mode {
-                eprintln!("{line}"); // stderr (shown by spt-core); stdout stays clean for the arbiter
-            } else {
-                println!("{line}"); // standalone-by-hand: no arbiter, show it directly
-            }
-        } else if !so.trim().is_empty() {
-            eprintln!("{}", so.trim_end()); // marketplace step output → stderr, never the arbiter
-        }
-    }
-
-    // ccs FOLLOW-UP (operator ask, v0.10.3): the primary reconcile above only touched the primary
-    // CLI's plugin tree; when ccs is ALSO installed, refresh its per-account plugin tree too.
-    // BEST-EFFORT by design: a ccs account without the plugin makes `plugin update` fail — that is
-    // noise (stderr), never a post-update failure and never the arbiter channel.
-    // [impl->REQ-DIST-CCS-PLUGIN-FOLLOWUP]
-    if ccs_followup_needed(cli, has_ccs) {
-        let argv = ccs_followup_cmd();
-        let shown = format!("ccs {}", argv.join(" "));
-        if dry_run {
-            println!("would run: {shown}");
-        } else {
-            eprintln!("claude-spt post-update: {shown} (ccs follow-up)");
-            match Command::new(resolve("ccs")).args(&argv).stdin(Stdio::null()).output() {
-                Ok(out) => {
-                    let se = String::from_utf8_lossy(&out.stderr);
-                    let so = String::from_utf8_lossy(&out.stdout);
-                    if out.status.success() {
-                        if !so.trim().is_empty() {
-                            eprintln!("{}", so.trim_end());
-                        }
-                    } else {
-                        eprintln!(
-                            "claude-spt post-update: `{shown}` exited {} (best-effort follow-up — continuing)",
-                            out.status
-                        );
-                        if !se.trim().is_empty() {
-                            eprintln!("{}", se.trim_end());
-                        }
-                    }
-                }
-                Err(e) => eprintln!("claude-spt post-update: failed to spawn `{shown}`: {e} (best-effort follow-up — continuing)"),
-            }
-        }
-    }
-
-    if dry_run {
-        return ExitCode::SUCCESS; // diagnostics already printed; no arbiter output
-    }
-    if post_mode {
-        // spt-core reads stdout to arbitrate: the sentinel (ALONE) fires the static [update].message.
-        print!("{}", arbiter_line(true, adapter_applied));
-    }
-    // (standalone-by-hand already printed the reworded sync notice above.)
-    ExitCode::SUCCESS
-}
-
-// [unit->REQ-DIST-BINARY-CONSOLIDATE]
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    // [unit->REQ-DIST-CCS-PLUGIN-FOLLOWUP]
-    #[test]
-    fn ccs_followup_only_when_ccs_present_and_not_primary() {
-        assert!(ccs_followup_needed("claude", true)); // both installed → claude primary + ccs follow-up
-        assert!(!ccs_followup_needed("claude", false)); // no ccs → nothing to follow up
-        assert!(!ccs_followup_needed("ccs", true)); // ccs IS the primary → already reconciled
-        assert_eq!(ccs_followup_cmd(), vec!["plugin", "update", "sptc@cplugs"]); // update, never install
-    }
-
-    #[test]
-    fn cli_prefers_claude_then_ccs_then_none() {
-        assert_eq!(choose_cli(true, true), Some("claude"));
-        assert_eq!(choose_cli(true, false), Some("claude"));
-        assert_eq!(choose_cli(false, true), Some("ccs")); // ccs is a documented claude drop-in
-        assert_eq!(choose_cli(false, false), None);
-    }
-
-    #[test]
-    fn marketplace_add_targets_the_cplugs_repo() {
-        assert_eq!(
-            marketplace_add_cmd(),
-            vec!["plugin", "marketplace", "add", "SaberMage/cplugs"]
-        );
-    }
-
-    #[test]
-    fn plugin_sync_picks_update_when_installed_else_install() {
-        assert_eq!(plugin_sync_cmd(false), vec!["plugin", "install", "sptc@cplugs"]);
-        assert_eq!(plugin_sync_cmd(true), vec!["plugin", "update", "sptc@cplugs"]);
-    }
-
-    // [unit->REQ-DIST-UPDATE-MESSAGE] the v0.9.1 stale-marketplace fix.
-    #[test]
-    fn marketplace_update_refreshes_the_cplugs_cache() {
-        assert_eq!(
-            marketplace_update_cmd(),
-            vec!["plugin", "marketplace", "update", "cplugs"]
-        );
-    }
-
-    // [unit->REQ-DIST-UPDATE-MESSAGE] reworded notice + version parse.
-    #[test]
-    fn parse_version_transition_pulls_from_cc_update_line() {
-        let line = "Plugin \"sptc\" updated from 0.1.3 to 0.1.8 for scope user. Restart to apply changes.";
-        assert_eq!(
-            parse_version_transition(line),
-            Some(("0.1.3".to_string(), "0.1.8".to_string()))
-        );
-        // A fresh install (no "from X to Y") yields None.
-        assert_eq!(parse_version_transition("Plugin \"sptc\" installed for scope user."), None);
-        assert_eq!(parse_version_transition(""), None);
-    }
-
-    #[test]
-    fn reworded_notice_names_claude_code_and_reload_plugins() {
-        let n = reworded_notice(Some(("0.1.3", "0.1.8")));
-        assert_eq!(
-            n,
-            "✔ Claude Code plugin \"sptc\" updated from 0.1.3 to 0.1.8. Active sessions need to run the /reload-plugins command."
-        );
-        // Drops CC's "Restart to apply changes" wording; never present.
-        assert!(!n.contains("Restart to apply"));
-        // Fallback (no transition) still names /reload-plugins.
-        assert!(reworded_notice(None).contains("/reload-plugins"));
-    }
-
-    #[test]
-    fn marketplace_registered_detects_by_key() {
-        let json = r#"{"cplugs":{"source":{"source":"github","repo":"SaberMage/cplugs"}}}"#;
-        assert!(marketplace_registered_in(json));
-    }
-
-    #[test]
-    fn marketplace_registered_detects_by_repo_under_other_name() {
-        // Same repo registered under a different marketplace name must still count.
-        let json = r#"{"my-fork":{"source":{"source":"github","repo":"SaberMage/cplugs"}}}"#;
-        assert!(marketplace_registered_in(json));
-    }
-
-    #[test]
-    fn marketplace_registered_false_when_absent_or_malformed() {
-        assert!(!marketplace_registered_in(
-            r#"{"other":{"source":{"source":"github","repo":"a/b"}}}"#
-        ));
-        assert!(!marketplace_registered_in("not json"));
-        assert!(!marketplace_registered_in(""));
-    }
-
-    #[test]
-    fn plugin_installed_detects_the_ref_key() {
-        let json = r#"{"version":2,"plugins":{"sptc@cplugs":[{"scope":"user"}]}}"#;
-        assert!(plugin_installed_in(json));
-    }
-
-    #[test]
-    fn plugin_installed_false_for_legacy_or_absent() {
-        // The legacy owl plugin is `spt@cplugs`, NOT `sptc@cplugs` — must not be mistaken for ours.
-        assert!(!plugin_installed_in(
-            r#"{"version":2,"plugins":{"spt@cplugs":[{"scope":"user"}]}}"#
-        ));
-        assert!(!plugin_installed_in(r#"{"version":2,"plugins":{}}"#));
-        assert!(!plugin_installed_in("not json"));
-    }
-
-    #[test]
-    fn program_candidates_cover_windows_pathext() {
-        let c = program_candidates("claude");
-        assert!(c.contains(&"claude".to_string()));
-        if cfg!(windows) {
-            assert!(c.contains(&"claude.exe".to_string()));
-            assert!(c.contains(&"claude.cmd".to_string()));
-        } else {
-            assert_eq!(c, vec!["claude".to_string()]);
-        }
-    }
-
-    // [unit->REQ-DIST-UPDATE-MESSAGE] the [update.post] stdin/stdout contract (D2).
-    #[test]
-    fn update_context_reads_adapter_applied_additively() {
-        // Additive: unknown future keys ignored; only adapter_applied read.
-        assert!(update_applied_in(
-            r#"{"adapter_applied":true,"adapter_name":"claude-spt","version":"0.8.0","unknown_future_key":42}"#
-        ));
-        assert!(!update_applied_in(r#"{"adapter_applied":false,"adapter_dir":"/x"}"#));
-        assert!(!update_applied_in(r#"{"adapter_name":"claude-spt"}"#)); // key absent -> false
-        assert!(!update_applied_in("not json"));
-        assert!(!update_applied_in(""));
-    }
-
-    #[test]
-    fn arbiter_fires_sentinel_on_reconcile_or_applied_else_empty() {
-        assert_eq!(arbiter_line(true, false), "!!update-message!!"); // reconcile ran
-        assert_eq!(arbiter_line(false, true), "!!update-message!!"); // adapter applied
-        assert_eq!(arbiter_line(true, true), "!!update-message!!");
-        assert_eq!(arbiter_line(false, false), ""); // true no-op -> nothing
-    }
-}
diff --git a/tools/claude-spt/src/psyche.rs b/tools/claude-spt/src/psyche.rs
deleted file mode 100644
index e386b71..0000000
--- a/tools/claude-spt/src/psyche.rs
+++ /dev/null
@@ -1,545 +0,0 @@
-//! `claude-spt psyche` — the `[session.psyche_resume]` EPHEMERAL shim (PSYCHE-EPHEMERAL-PLAN.md,
-//! doyle-gated PASS; adapter half of the joint F-030 wave; replaces the resident wrapper this file
-//! used to be). Frozen against doyle's W1/W2 psyche-turn contract (2026-07-04, id 944a74b0) + the
-//! evidence-classified answers that collapsed the parked two-path design into ONE spawned role, and
-//! the W4 amendment (id 9e6863d0) that moved the composed mind from an argv value to a FILE path.
-//!
-//! WHAT A PSYCHE IS (doyle 2026-06-15, traced spt-core): a LiveAgent's companion. The spt-core
-//! daemon's livehost hosts it — only when the resolved manifest declares `[session.psyche_init]`
-//! (the live-capability GATE only, lifecycle.rs:365; it is NEVER spawned in the ephemeral model)
-//! AND the perch came up as state=live_agent. The Psyche's continuity is the CC TRANSCRIPT +
-//! session id, not a process: between events NOTHING runs. The daemon drives every turn — ONE
-//! invocation of THIS shim per turn: one headless `claude` turn, run to completion, exit. The
-//! daemon owns the psyche perch (`<id>-psyche`, bound by core `spawn_and_bind`); this shim must
-//! NOT mint it, never polls it, holds no state across invocations, and writes NOTHING to the
-//! core-owned psyche-custody.json — nor to the mind file (core owns its whole lifecycle).
-//! [impl->REQ-PSYCHE-EPHEMERAL-SHIM]
-//!
-//! ONE ROLE, TWO KEY SHAPES (contract Q2, W4 file form). Every drive is `[session.psyche_resume]`:
-//!   * FreshWithPreload (FIRST turn): the mind FILE is NON-EMPTY (core writes the composed mind
-//!     before spawn — a zero-context fresh agent is seeded a minimal marker, so non-empty ⟺ fresh
-//!     by construction), and `{session_id}` is the core-MINTED psyche-own sid. We ADOPT it:
-//!     `claude -p --session-id <sid>` and seed the turn with the composed mind + the event.
-//!   * ContinueExisting (LATER turn): the mind FILE is EMPTY (core writes it empty — no sentinel),
-//!     same stored `{session_id}`. We RESUME: `claude -p --resume <sid>`, turn = the event only
-//!     (the mind already lives in the transcript).
-//! The shim discriminates on the FILE CONTENT's emptiness — no `--resume` mode flag.
-//!
-//! I/O (contract, W4). `{psyche_context_file}` (ALWAYS filled — a path to the mind file in the
-//! psyche's nested perch dir) rides this shim's argv; the shim READS that file to get the composed
-//! mind (W4 kills the win32 ~32k cmdline cap: real minds are ~20KB and used to ride argv directly).
-//! The per-turn EVENT/COMMUNE rides the shim's STDIN (a bare pulse feeds `<pulse/>`). We compose
-//! them (FIRST = mind + blank line + event; LATER = event) and hand the result to claude via
-//! CLAUDE'S OWN STDIN — never claude argv. claude's STDOUT is the psyche's SOLE outbound channel:
-//! we CAPTURE it and pass it through to our stdout (the daemon runs parse_psyche_intents on it),
-//! guaranteeing a NON-EMPTY ack on a no-relay turn (core also backstops via TurnError::EmptyOutput).
-//! The daemon spawns us NON-detached, stdin-fed, stdout-captured, bounded.
-//!
-//! FAILURE CONTRACT (contract FORK-3 + exit-code amendment): the SOLE machine reseed discriminator
-//! is EXIT CODE 95 — emitted ONLY when a ContinueExisting turn's `--resume` fails because the
-//! session is gone (claude: "No conversation found with session ID: …"). Core's
-//! is_psyche_session_not_found matches TurnError::Failed{status_code: Some(95)} → clears custody +
-//! fires PSYCHE_RESEED. EVERY OTHER nonzero exit keeps custody (generic fail) — INCLUDING a failure
-//! to read the mind file (a fault before any claude spawn, so it is never mistaken for a reseed).
-//! No internal retry, no silent reseed (the daemon owns reseed via the next fresh turn; core C3(b)
-//! owns crashloop pacing). Human stderr breadcrumbs ride alongside for logs but are NOT
-//! decision-bearing. [impl->REQ-SKILL-LIVE]
-
-use std::io::{Read, Write};
-use std::process::{Command, ExitCode, Stdio};
-
-/// Exit code 95 = the SOLE machine reseed discriminator (contract amendment, doyle-pinned
-/// 2026-07-04; matches core is_psyche_session_not_found → TurnError::Failed{status_code:Some(95)}).
-/// Emitted ONLY on a ContinueExisting `--resume` whose session is gone. [impl->REQ-PSYCHE-EPHEMERAL-SHIM]
-const EXIT_SESSION_GONE: u8 = 95;
-
-/// The non-empty stdout ack for a no-relay turn (contract: stdout MUST be non-empty; core backstops
-/// with TurnError::EmptyOutput). Carries no `<EVENT>` intent, so parse_psyche_intents routes
-/// nothing — it only satisfies the non-empty guarantee. [impl->REQ-PSYCHE-EPHEMERAL-SHIM]
-const ACK: &str = "<psyche-ack/>";
-
-/// Parsed launch args — the daemon-filled keys we template. `{node}`/`{parent_session_id}`/
-/// `{subnet}` are ignored on argv (contract Q3b + W4 — not surfaced into the prompt).
-/// `{psyche_context_file}` (W4) is ALWAYS filled — a path to the mind file the shim reads; its
-/// CONTENT emptiness discriminates fresh vs continue, and its PARENT DIR is the psyche's nested
-/// perch dir, which the shim adopts as claude's cwd (v0.14.2 — the manifest's former
-/// `cwd = "{psyche_dir}"` referenced a retired resident-era key the F-030 fill catalog never
-/// carried, faulting EVERY per-event turn at substitution; doyle P-1 verdict 2026-07-06).
-#[derive(Debug, PartialEq)]
-struct Args {
-    id: String,
-    session_id: String,
-    psyche_context_file: String,
-}
-
-impl Args {
-    /// Parse `--id V --session-id V --psyche-context-file V`. All three are required, single-value,
-    /// order-independent (the W4 mind-file path is ALWAYS filled by core — unlike the pre-W4 soft
-    /// `{psyche_context}` value, its presence is unconditional). spt-core 0.8.2+ fills each `{key}`
-    /// as exactly ONE argv element (tokenize-then-fill). Unknown args are loud (a real misfire must
-    /// fail).
-    fn parse<I: IntoIterator<Item = String>>(argv: I) -> Result<Args, String> {
-        let (mut id, mut session_id, mut psyche_context_file) = (None, None, None);
-        let mut it = argv.into_iter();
-        while let Some(flag) = it.next() {
-            match flag.as_str() {
-                "--id" => id = Some(it.next().ok_or("--id expects a value")?),
-                "--session-id" => session_id = Some(it.next().ok_or("--session-id expects a value")?),
-                "--psyche-context-file" => {
-                    psyche_context_file = Some(it.next().ok_or("--psyche-context-file expects a value")?)
-                }
-                other => return Err(format!("unknown arg: {other}")),
-            }
-        }
-        Ok(Args {
-            id: id.ok_or("missing --id")?,
-            session_id: session_id.ok_or("missing --session-id")?,
-            psyche_context_file: psyche_context_file.ok_or("missing --psyche-context-file")?,
-        })
-    }
-}
-
-/// Read the composed mind from the core-written file (W4). Core writes-before-spawn every turn and
-/// owns the file's whole lifecycle — the shim only reads. A read failure is a FAULT (returned Err →
-/// generic keep-custody exit), never a reseed. [impl->REQ-PSYCHE-CONTEXT-FILE-INDIRECTION]
-fn read_context(path: &str) -> std::io::Result<String> {
-    std::fs::read_to_string(path)
-}
-
-/// FreshWithPreload ⟺ a non-empty composed mind (contract: core writes the mind non-empty on a
-/// first turn, seeding a minimal marker for zero-context agents; treat ANY non-empty content as
-/// fresh — do NOT special-case the marker). Trim-based, so a 0-byte OR whitespace/newline-only file
-/// both read as ContinueExisting. [impl->REQ-PSYCHE-EPHEMERAL-SHIM]
-fn is_first_turn(psyche_context: &str) -> bool {
-    !psyche_context.trim().is_empty()
-}
-
-/// Compose the single prompt fed to claude via its stdin. FIRST = mind + blank line + this turn's
-/// event (channels are disjoint by source — contract Q1(B), no de-dup); LATER = the event alone
-/// (the mind already lives in the resumed transcript). [impl->REQ-PSYCHE-EPHEMERAL-SHIM]
-fn compose_prompt(psyche_context: &str, event: &str) -> String {
-    if is_first_turn(psyche_context) {
-        format!("{}\n\n{}", psyche_context.trim_end(), event)
-    } else {
-        event.to_string()
-    }
-}
-
-/// Tool/permission SANDBOX flags applied to EVERY psyche claude turn — legacy owl parity
-/// (claude_skill_owl `src/live/wrapper/claude.rs`, init/resume/final all carry this exact set).
-/// A CONSTRAINED companion, not a general agent:
-///   * `--tools Read,Edit,Write` — commune authoring needs file IO only; NO Bash/network.
-///   * `--disable-slash-commands` — the Psyche drives itself from the prompt.
-///   * `--dangerously-skip-permissions` — REQUIRED (REQ-HAZARD-PSYCHE-PERMS-DEADLOCK): a
-///     non-interactive turn with an interactive permission prompt would hang; auto-approve within
-///     the Read/Edit/Write box is the safe combination (bounded surface + no deadlock).
-///   * model pin (`sonnet` primary, `opus` fallback, `medium` effort) — the cheap companion never
-///     silently rides the parent's heavier model.
-/// [impl->REQ-HAZARD-PSYCHE-PERMS-DEADLOCK]
-fn sandbox_flags() -> Vec<String> {
-    [
-        "--model", "sonnet",
-        "--fallback-model", "opus",
-        "--effort", "medium",
-        "--dangerously-skip-permissions",
-        "--disable-slash-commands",
-        "--tools", "Read,Edit,Write",
-    ]
-    .iter()
-    .map(|s| (*s).to_string())
-    .collect()
-}
-
-/// argv for THE one headless claude turn — print mode reading the prompt from STDIN (no positional
-/// prompt; the composed mind/event never touches argv). FIRST ADOPTS the core-minted sid
-/// (`--session-id`, uuid_inject — CC accepts an explicit UUID headlessly); LATER resumes it
-/// (`--resume`). Sandbox flags ride BOTH modes so the ADR-0003 box holds for the session's life.
-/// [impl->REQ-PSYCHE-EPHEMERAL-SHIM]
-fn turn_cmd(session_id: &str, is_first: bool) -> Vec<String> {
-    let mut v: Vec<String> = vec!["-p".into()];
-    v.push(if is_first { "--session-id".into() } else { "--resume".into() });
-    v.push(session_id.to_string());
-    v.extend(sandbox_flags());
-    v
-}
-
-/// This invocation's plan (pure/stateless — one invocation plans AT MOST one turn; no loop, no
-/// residency, no state to carry another). `Ack` = a no-relay turn (blank composed prompt): emit the
-/// non-empty ack, no billed claude turn. `Turn` = spawn claude once with this argv, feeding `prompt`
-/// on claude's stdin. Operates on the already-read mind CONTENT (the file read happens in run()).
-/// [impl->REQ-PSYCHE-EPHEMERAL-SHIM]
-#[derive(Debug, PartialEq)]
-enum Plan {
-    Ack,
-    Turn { cmd: Vec<String>, prompt: String, is_first: bool },
-}
-
-/// Plan the turn from the mind content + the stdin event. A blank composed prompt (only possible on
-/// a ContinueExisting turn with a blank event — a FIRST turn's mind is non-empty by construction) is
-/// the billing guard: no claude spawn, just the ack. [impl->REQ-PSYCHE-EPHEMERAL-SHIM]
-fn plan(session_id: &str, psyche_context: &str, event: &str) -> Plan {
-    let is_first = is_first_turn(psyche_context);
-    let prompt = compose_prompt(psyche_context, event);
-    if prompt.trim().is_empty() {
-        return Plan::Ack;
-    }
-    Plan::Turn { cmd: turn_cmd(session_id, is_first), prompt, is_first }
-}
-
-/// How a nonzero claude exit maps to OUR exit (contract FORK-3). SessionGone is the ONLY reseed
-/// path and only reachable on a ContinueExisting `--resume` — a FIRST turn ADOPTS a fresh sid and
-/// cannot be "session not found". [impl->REQ-PSYCHE-EPHEMERAL-SHIM]
-#[derive(Debug, PartialEq)]
-enum FailKind {
-    SessionGone,
-    Generic,
-}
-
-/// Discriminate a claude failure. The session-gone signature is claude's own resume error
-/// ("No conversation found with session ID: …", empirically confirmed on this box 2026-07-04),
-/// matched case-insensitively and ONLY on a resume (later) turn. [impl->REQ-PSYCHE-EPHEMERAL-SHIM]
-fn classify_failure(is_first: bool, claude_stderr: &str) -> FailKind {
-    if !is_first && claude_stderr.to_ascii_lowercase().contains("no conversation found") {
-        FailKind::SessionGone
-    } else {
-        FailKind::Generic
-    }
-}
-
-/// Human stderr breadcrumb for a generic (keep-custody) failure — a process-death marker for the
-/// daemon's psyche_host_error surface + any log reader. NOT decision-bearing (exit code is).
-fn fail_line(id: &str, cause: &str) -> String {
-    format!("PSYCHE_TURN_FAIL:{id}: {cause} — exiting nonzero (keep custody); the daemon owns retry/reseed (no internal retry)")
-}
-
-/// Human stderr breadcrumb accompanying the exit-95 reseed signal. NOT decision-bearing — core
-/// keys reseed off exit 95, not this line. [impl->REQ-PSYCHE-EPHEMERAL-SHIM]
-fn session_gone_line(id: &str) -> String {
-    format!("PSYCHE_SESSION_NOT_FOUND:{id}: resume session is gone/expired — exit {EXIT_SESSION_GONE} (reseed)")
-}
-
-/// The psyche's working dir: the mind file's PARENT dir — the core-written context file lives in
-/// the psyche's nested perch dir (observed: `owlery/<id>/nested/<id>-psyche/psyche-context.txt`),
-/// the same location the retired `{psyche_dir}` fill pointed at. Adopting it keeps claude's
-/// sid+cwd transcript-resolution pair STABLE across turns (a drifting cwd would strand the psyche's
-/// own transcript and reseed-loop). None when the path has no parent — the spawn then inherits the
-/// shim's cwd rather than failing the turn. Pure (existence is checked at the call site).
-/// [impl->REQ-PSYCHE-EPHEMERAL-SHIM]
-fn psyche_cwd(context_file: &str) -> Option<std::path::PathBuf> {
-    let p = std::path::Path::new(context_file).parent()?;
-    (!p.as_os_str().is_empty()).then(|| p.to_path_buf())
-}
-
-/// Run claude once for this turn: feed `prompt` on its stdin, CAPTURE stdout (the psyche's outbound
-/// channel) + stderr (for the fail discriminator + log forwarding). `cwd` (when present + existing)
-/// anchors the turn in the psyche's nested perch dir — see `psyche_cwd`. Returned on spawn failure
-/// as Err. [impl->REQ-PSYCHE-EPHEMERAL-SHIM]
-fn run_claude(cmd: &[String], prompt: &str, cwd: Option<&std::path::Path>) -> std::io::Result<std::process::Output> {
-    let mut c = Command::new("claude");
-    c.args(cmd).stdin(Stdio::piped()).stdout(Stdio::piped()).stderr(Stdio::piped());
-    if let Some(d) = cwd.filter(|d| d.is_dir()) {
-        c.current_dir(d);
-    }
-    let mut child = c.spawn()?;
-    // Write the composed prompt to claude's stdin, then close it so claude's print mode proceeds.
-    child
-        .stdin
-        .take()
-        .expect("piped stdin")
-        .write_all(prompt.as_bytes())?;
-    child.wait_with_output()
-}
-
-/// `claude-spt psyche` entry — run-to-completion: parse argv, read the mind file + the stdin event,
-/// plan (at most one turn), spawn claude once, map its outcome to our exit + forward its stdout as
-/// the psyche's outbound (non-empty ack if it produced nothing). [impl->REQ-PSYCHE-EPHEMERAL-SHIM]
-pub fn run() -> ExitCode {
-    let args = match Args::parse(std::env::args().skip(2)) {
-        Ok(a) => a,
-        Err(e) => {
-            eprintln!("claude-spt psyche: {e}");
-            return ExitCode::from(2);
-        }
-    };
-
-    // The composed mind rides a core-written FILE (W4); read it. A read failure is a keep-custody
-    // FAULT, before any claude spawn — never a reseed. [impl->REQ-PSYCHE-CONTEXT-FILE-INDIRECTION]
-    let psyche_context = match read_context(&args.psyche_context_file) {
-        Ok(c) => c,
-        Err(e) => {
-            eprintln!("{}", fail_line(&args.id, &format!("mind file unreadable ({}): {e}", args.psyche_context_file)));
-            return ExitCode::FAILURE;
-        }
-    };
-
-    // The per-turn EVENT/COMMUNE rides our stdin (a bare pulse feeds `<pulse/>`).
-    let mut event = String::new();
-    if let Err(e) = std::io::stdin().read_to_string(&mut event) {
-        eprintln!("{}", fail_line(&args.id, &format!("stdin read failed: {e}")));
-        return ExitCode::FAILURE;
-    }
-
-    let (cmd, prompt, is_first) = match plan(&args.session_id, &psyche_context, &event) {
-        Plan::Ack => {
-            // No-relay turn: emit the non-empty ack (satisfies the stdout non-empty guarantee), no
-            // billed claude turn. [impl->REQ-PSYCHE-EPHEMERAL-SHIM]
-            println!("{ACK}");
-            return ExitCode::SUCCESS;
-        }
-        Plan::Turn { cmd, prompt, is_first } => (cmd, prompt, is_first),
-    };
-
-    let output = match run_claude(&cmd, &prompt, psyche_cwd(&args.psyche_context_file).as_deref()) {
-        Ok(o) => o,
-        Err(e) => {
-            eprintln!("{}", fail_line(&args.id, &format!("claude spawn failed: {e}")));
-            return ExitCode::FAILURE;
-        }
-    };
-
-    // Forward claude's stderr for logs (never swallowed), regardless of outcome.
-    if !output.stderr.is_empty() {
-        let _ = std::io::stderr().write_all(&output.stderr);
-    }
-
-    if output.status.success() {
-        // Pass the psyche's stdout through as-is; guarantee non-empty with the ack if claude emitted
-        // nothing (a no-relay turn). [impl->REQ-PSYCHE-EPHEMERAL-SHIM]
-        if output.stdout.iter().all(|b| b.is_ascii_whitespace()) {
-            println!("{ACK}");
-        } else {
-            let _ = std::io::stdout().write_all(&output.stdout);
-        }
-        return ExitCode::SUCCESS;
-    }
-
-    // Nonzero: the SOLE reseed discriminator is exit 95 on a resume-turn session-gone; all else
-    // keeps custody. [impl->REQ-PSYCHE-EPHEMERAL-SHIM]
-    let claude_stderr = String::from_utf8_lossy(&output.stderr);
-    match classify_failure(is_first, &claude_stderr) {
-        FailKind::SessionGone => {
-            eprintln!("{}", session_gone_line(&args.id));
-            ExitCode::from(EXIT_SESSION_GONE)
-        }
-        FailKind::Generic => {
-            eprintln!("{}", fail_line(&args.id, &format!("claude exited {}", output.status)));
-            ExitCode::FAILURE
-        }
-    }
-}
-
-// [unit->REQ-SKILL-LIVE]
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn argv(parts: &[&str]) -> Vec<String> {
-        parts.iter().map(|s| (*s).to_string()).collect()
-    }
-
-    const SID: &str = "e00167d2-1084-4236-80e1-b33f3ee97ae8";
-    const FRESH_MIND: &str = "# durable mind\nrole: perri";
-
-    // ---- arg parsing ----
-
-    #[test]
-    fn all_three_keys_required_order_independent() {
-        let a = Args::parse(argv(&["--session-id", "S", "--id", "I", "--psyche-context-file", "/p/mind"])).unwrap();
-        assert_eq!(a, Args { id: "I".into(), session_id: "S".into(), psyche_context_file: "/p/mind".into() });
-    }
-
-    // [unit->REQ-PSYCHE-EPHEMERAL-SHIM]
-    #[test]
-    fn psyche_cwd_is_the_mind_files_parent_dir() {
-        // The context file lives in the psyche's nested perch dir — its parent IS the retired
-        // {psyche_dir} location, adopted as claude's cwd so the sid+cwd transcript pair stays
-        // stable across turns (v0.14.2 fix: the manifest cwd template faulted every turn).
-        assert_eq!(
-            psyche_cwd("C:\\spt\\owlery\\flynn\\nested\\flynn-psyche\\psyche-context.txt"),
-            Some(std::path::PathBuf::from("C:\\spt\\owlery\\flynn\\nested\\flynn-psyche"))
-        );
-        assert_eq!(psyche_cwd("/o/perri/nested/perri-psyche/psyche-context.txt"), Some(std::path::PathBuf::from("/o/perri/nested/perri-psyche")));
-        // A bare filename has no usable parent — spawn inherits the shim's cwd, never a fault.
-        assert_eq!(psyche_cwd("psyche-context.txt"), None);
-    }
-
-    #[test]
-    fn missing_any_required_flag_is_an_error() {
-        // W4: the mind-file path is ALWAYS filled by core, so its absence is a real misfire (loud).
-        assert!(Args::parse(argv(&["--session-id", "S", "--psyche-context-file", "/p"])).is_err());
-        assert!(Args::parse(argv(&["--id", "I", "--psyche-context-file", "/p"])).is_err());
-        assert!(Args::parse(argv(&["--id", "I", "--session-id", "S"])).is_err());
-    }
-
-    #[test]
-    fn unknown_arg_is_rejected() {
-        assert!(Args::parse(argv(&["--id", "I", "--session-id", "S", "--psyche-context-file", "/p", "--bogus", "x"])).is_err());
-    }
-
-    // ---- W4 file read + discriminator ----
-
-    // [unit->REQ-PSYCHE-CONTEXT-FILE-INDIRECTION]
-    #[test]
-    fn reads_the_mind_file_and_content_drives_the_discriminator() {
-        // Fresh (non-empty) file → fresh turn; empty file → continue. Uses a real temp file (core
-        // owns the file in production; here we prove the read + content-emptiness wiring).
-        let dir = std::env::temp_dir();
-        let fresh = dir.join(format!("sptc-mind-fresh-{}", std::process::id()));
-        let empty = dir.join(format!("sptc-mind-empty-{}", std::process::id()));
-        std::fs::write(&fresh, FRESH_MIND).unwrap();
-        std::fs::write(&empty, "   \n").unwrap(); // whitespace-only = empty (trim-based)
-        assert!(is_first_turn(&read_context(fresh.to_str().unwrap()).unwrap()), "non-empty file = fresh");
-        assert!(!is_first_turn(&read_context(empty.to_str().unwrap()).unwrap()), "whitespace-only file = continue");
-        let _ = std::fs::remove_file(&fresh);
-        let _ = std::fs::remove_file(&empty);
-    }
-
-    // [unit->REQ-PSYCHE-CONTEXT-FILE-INDIRECTION]
-    #[test]
-    fn an_unreadable_mind_file_is_an_error_not_a_panic() {
-        assert!(read_context("/no/such/sptc-mind-file-xyz").is_err(), "a missing file surfaces as Err (→ keep-custody fault)");
-    }
-
-    // ---- turn-shape discrimination ----
-
-    // [unit->REQ-PSYCHE-EPHEMERAL-SHIM]
-    #[test]
-    fn nonempty_context_is_a_fresh_turn_empty_is_continue() {
-        assert!(is_first_turn("# a mind"));
-        assert!(is_first_turn("<fresh-psyche/>"), "any non-empty marker counts as fresh (no special-case)");
-        assert!(!is_first_turn(""));
-        assert!(!is_first_turn("   \n\t "));
-    }
-
-    // [unit->REQ-PSYCHE-EPHEMERAL-SHIM]
-    #[test]
-    fn first_turn_adopts_the_minted_sid() {
-        let cmd = turn_cmd(SID, true);
-        let at = cmd.iter().position(|t| t == "--session-id").expect("--session-id present");
-        assert_eq!(cmd[at + 1], SID);
-        assert!(!cmd.contains(&"--resume".to_string()), "fresh must not resume");
-        assert_eq!(cmd[0], "-p", "print mode");
-        assert!(!cmd.iter().any(|t| t.contains("durable") || t.contains("MIND")), "prompt never rides argv");
-    }
-
-    // [unit->REQ-PSYCHE-EPHEMERAL-SHIM]
-    #[test]
-    fn continue_turn_resumes_by_sid() {
-        let cmd = turn_cmd(SID, false);
-        let at = cmd.iter().position(|t| t == "--resume").expect("--resume present");
-        assert_eq!(cmd[at + 1], SID);
-        assert!(!cmd.contains(&"--session-id".to_string()), "resume must not re-adopt");
-        assert_eq!(cmd[0], "-p", "print mode");
-    }
-
-    // ---- prompt composition (contract Q1(B)) ----
-
-    // [unit->REQ-PSYCHE-EPHEMERAL-SHIM]
-    #[test]
-    fn first_prompt_is_mind_blankline_event() {
-        let p = compose_prompt("# mind", "<pulse/>");
-        assert_eq!(p, "# mind\n\n<pulse/>", "mind + blank line + event, disjoint channels, no de-dup");
-    }
-
-    // [unit->REQ-PSYCHE-EPHEMERAL-SHIM]
-    #[test]
-    fn continue_prompt_is_event_only() {
-        assert_eq!(compose_prompt("", "<EVENT type=\"msg\">hi</EVENT>"), "<EVENT type=\"msg\">hi</EVENT>");
-    }
-
-    // ---- planning: at-most-one-turn + billing/ack guard ----
-
-    // [unit->REQ-HAZARD-PSYCHE-HOST-THRASH]
-    #[test]
-    fn plan_is_stateless_one_turn_no_residency() {
-        // KH §2.6 resolved-by-design: the resident loop is GONE — plan() is pure, so re-planning the
-        // same inputs yields the same single turn. Crashloop pacing belongs to core C3(b), which
-        // consumes our ephemeral deaths. Successor assertion replacing the retired thrash_guard.
-        let one = plan(SID, FRESH_MIND, "<pulse/>");
-        let two = plan(SID, FRESH_MIND, "<pulse/>");
-        assert_eq!(one, two, "stateless: no streaks, no backoff, no residency");
-        assert!(matches!(one, Plan::Turn { .. }), "an actionable event plans exactly one turn");
-    }
-
-    // [unit->REQ-PSYCHE-EPHEMERAL-SHIM]
-    #[test]
-    fn blank_continue_event_plans_the_ack_no_spawn() {
-        // The billing guard on the ContinueExisting path: a blank event with an empty mind plans the
-        // non-empty ack, NOT a billed claude turn.
-        for blank in ["", "   ", "\n\t "] {
-            assert_eq!(plan(SID, "", blank), Plan::Ack, "blank continue event must plan the ack: {blank:?}");
-        }
-    }
-
-    // [unit->REQ-PSYCHE-EPHEMERAL-SHIM]
-    #[test]
-    fn first_turn_never_planned_as_ack_mind_is_nonempty() {
-        // A FIRST turn's mind is non-empty by construction, so even a blank event still composes a
-        // non-blank prompt → a real turn, never the ack shortcut.
-        assert!(matches!(plan(SID, FRESH_MIND, ""), Plan::Turn { is_first: true, .. }));
-    }
-
-    // ---- failure discrimination (exit 95) ----
-
-    // [unit->REQ-PSYCHE-EPHEMERAL-SHIM]
-    #[test]
-    fn resume_session_gone_is_the_sole_reseed_signal() {
-        assert_eq!(
-            classify_failure(false, "No conversation found with session ID: 00000000-0000-4000-8000-000000000000"),
-            FailKind::SessionGone
-        );
-        assert_eq!(EXIT_SESSION_GONE, 95, "the pinned reseed discriminator");
-    }
-
-    // [unit->REQ-PSYCHE-EPHEMERAL-SHIM]
-    #[test]
-    fn a_fresh_turn_is_never_session_gone() {
-        // A FIRST turn ADOPTS a fresh sid; the same stderr must NOT be read as reseed (guards against
-        // a spurious reseed churn on a first-turn failure).
-        assert_eq!(
-            classify_failure(true, "No conversation found with session ID: x"),
-            FailKind::Generic
-        );
-    }
-
-    // [unit->REQ-PSYCHE-EPHEMERAL-SHIM]
-    #[test]
-    fn other_resume_failures_keep_custody() {
-        assert_eq!(classify_failure(false, "some other claude error"), FailKind::Generic);
-        assert_eq!(classify_failure(false, ""), FailKind::Generic);
-    }
-
-    // ---- sandbox parity + non-minting invariants ----
-
-    // [unit->REQ-HAZARD-PSYCHE-PERMS-DEADLOCK]
-    #[test]
-    fn every_turn_is_sandboxed_both_modes() {
-        for is_first in [true, false] {
-            let cmd = turn_cmd(SID, is_first);
-            for flag in ["--tools", "--disable-slash-commands", "--dangerously-skip-permissions", "--model", "--fallback-model"] {
-                assert!(cmd.contains(&flag.to_string()), "{flag} missing (is_first={is_first})");
-            }
-            let at = cmd.iter().position(|t| t == "--tools").unwrap();
-            assert_eq!(cmd[at + 1], "Read,Edit,Write");
-        }
-    }
-
-    // [unit->REQ-PSYCHE-EPHEMERAL-SHIM]
-    #[test]
-    fn the_shim_never_mints_no_spt_verb_in_the_turn() {
-        // Plan/gate Q2: core spawn_and_bind owns the psyche perch — the shim must not mint it. The
-        // planned command is a bare `claude` argv; no spt/ready verb appears.
-        for (ctx, ev) in [("# mind", "<pulse/>"), ("", "<EVENT/>")] {
-            if let Plan::Turn { cmd, .. } = plan(SID, ctx, ev) {
-                assert!(!cmd.iter().any(|t| t.contains("spt") || t.contains("ready")), "{cmd:?}");
-            }
-        }
-    }
-
-    // [unit->REQ-PSYCHE-EPHEMERAL-SHIM]
-    #[test]
-    fn ack_is_non_empty() {
-        // The stdout non-empty guarantee rests on this.
-        assert!(!ACK.trim().is_empty());
-    }
-}
diff --git a/tools/claude-spt/src/psyche_omp.rs b/tools/claude-spt/src/psyche_omp.rs
deleted file mode 100644
index 833644d..0000000
--- a/tools/claude-spt/src/psyche_omp.rs
+++ /dev/null
@@ -1,339 +0,0 @@
-//! `claude-spt psyche-omp` — the omp-spt `[session.psyche_resume]` EPHEMERAL shim (S4).
-//!
-//! The omp counterpart of psyche.rs, holding the SAME frozen psyche-turn contract (one spawned
-//! role, two key shapes, event on stdin, stdout captured, exit 95 = the sole reseed discriminator)
-//! while adapting the three seams where oh-my-pi differs from Claude Code — each verified against
-//! the live omp v16.3.11 binary, not assumed:
-//!
-//!  1. SESSION ADOPTION: omp has no `--session-id` inject — it always mints its own id. So the
-//!     psyche's continuity is keyed on a PRIVATE SESSION DIR instead: `<mind-file-parent>/omp-
-//!     sessions` (`--session-dir`). FIRST turn starts fresh there; LATER turns `-c` (continue the
-//!     most recent session in that dir). The core-minted `{session_id}` still rides argv for
-//!     custody bookkeeping/labels, but is not (cannot be) the omp session id.
-//!  2. SESSION-GONE: `omp -c` on an empty session dir does NOT error — it silently starts a fresh,
-//!     mindless session (verified), which would strand the psyche context-less with no reseed. So
-//!     the shim ITSELF discriminates: a ContinueExisting turn with NO `*.jsonl` in the session dir
-//!     exits 95 (PSYCHE_SESSION_NOT_FOUND) WITHOUT spawning omp — cheaper than CC's model-reported
-//!     failure, same core-side reseed semantics.
-//!  3. PROMPT DELIVERY: `omp -p` ignores a stdin-only prompt (verified: exits silently), so the
-//!     composed mind+event cannot ride stdin as it does for claude. It rides omp's `@file` message
-//!     include instead: the shim writes the composed prompt to `<session-dir>/turn-prompt.md`
-//!     (shim-OWNED scratch, overwritten per turn — never the core-owned mind file / custody json)
-//!     and passes `@<path>` as the one argv message. This also keeps the W4 property (a ~20KB mind
-//!     never touches the win32 ~32k cmdline cap).
-//!
-//! Sandbox (ADR-0003 parity, omp flags): `--tools read,write,edit` (commune authoring is file IO
-//! only — no bash/eval/browser/web), `--auto-approve` (non-interactive; REQ-HAZARD-PSYCHE-PERMS-
-//! DEADLOCK class), `--thinking off` + `--no-title` (a cheap companion — no reasoning tokens, no
-//! title-generation model call), `--no-extensions --no-skills --no-rules` (the psyche drives itself
-//! from the prompt; discovery surfaces stay out). Tool names verified against the live binary's
-//! tool list. Model is NOT pinned: omp's model selection is profile/models.yml-driven (S5), and a
-//! hardcoded model name may not resolve against a user's provider set.
-//! [impl->REQ-PSYCHE-EPHEMERAL-SHIM]
-
-use std::io::Read;
-use std::path::{Path, PathBuf};
-use std::process::{Command, ExitCode, Stdio};
-
-/// Exit code 95 = the SOLE machine reseed discriminator (same contract as psyche.rs).
-const EXIT_SESSION_GONE: u8 = 95;
-
-/// The non-empty stdout ack for a no-relay turn (contract: stdout MUST be non-empty).
-const ACK: &str = "<psyche-ack/>";
-
-/// The shim-owned per-turn prompt file inside the psyche session dir (@file delivery, seam 3).
-const TURN_PROMPT_FILE: &str = "turn-prompt.md";
-
-/// Parsed launch args — identical fill shape to psyche.rs ([session.psyche_resume] keys).
-#[derive(Debug, PartialEq)]
-struct Args {
-    id: String,
-    session_id: String,
-    psyche_context_file: String,
-}
-
-impl Args {
-    fn parse<I: IntoIterator<Item = String>>(argv: I) -> Result<Args, String> {
-        let (mut id, mut session_id, mut psyche_context_file) = (None, None, None);
-        let mut it = argv.into_iter();
-        while let Some(flag) = it.next() {
-            match flag.as_str() {
-                "--id" => id = Some(it.next().ok_or("--id expects a value")?),
-                "--session-id" => session_id = Some(it.next().ok_or("--session-id expects a value")?),
-                "--psyche-context-file" => {
-                    psyche_context_file = Some(it.next().ok_or("--psyche-context-file expects a value")?)
-                }
-                other => return Err(format!("unknown arg: {other}")),
-            }
-        }
-        Ok(Args {
-            id: id.ok_or("missing --id")?,
-            session_id: session_id.ok_or("missing --session-id")?,
-            psyche_context_file: psyche_context_file.ok_or("missing --psyche-context-file")?,
-        })
-    }
-}
-
-/// FreshWithPreload ⟺ a non-empty composed mind (same discriminator as psyche.rs — the file
-/// CONTENT, not a mode flag).
-fn is_first_turn(psyche_context: &str) -> bool {
-    !psyche_context.trim().is_empty()
-}
-
-/// Compose the single turn prompt. FIRST = mind + blank line + event; LATER = the event alone.
-fn compose_prompt(psyche_context: &str, event: &str) -> String {
-    if is_first_turn(psyche_context) {
-        format!("{}\n\n{}", psyche_context.trim_end(), event)
-    } else {
-        event.to_string()
-    }
-}
-
-/// The psyche's omp session dir: `<mind-file-parent>/omp-sessions` — a shim-owned subdir of the
-/// psyche's nested perch dir (the CC shim adopts the same parent as claude's cwd; here it anchors
-/// omp's session store, which is what actually carries the psyche's continuity — seam 1).
-fn psyche_session_dir(context_file: &str) -> Option<PathBuf> {
-    let p = Path::new(context_file).parent()?;
-    (!p.as_os_str().is_empty()).then(|| p.join("omp-sessions"))
-}
-
-/// Does the session dir hold any prior omp session (`*.jsonl`)? The shim-side session-gone
-/// discriminator (seam 2): a ContinueExisting turn over an empty dir = the session is gone.
-fn has_prior_session(dir: &Path) -> bool {
-    std::fs::read_dir(dir)
-        .map(|rd| {
-            rd.flatten().any(|e| {
-                e.path()
-                    .extension()
-                    .map(|x| x.eq_ignore_ascii_case("jsonl"))
-                    .unwrap_or(false)
-            })
-        })
-        .unwrap_or(false)
-}
-
-/// omp argv for THE one headless turn (sans the trailing `@<turn-prompt>` message, appended at the
-/// call site). Fresh omits `-c`; continue rides it. See the module header for each flag's why.
-fn turn_cmd(session_dir: &str, is_first: bool) -> Vec<String> {
-    let mut v: Vec<String> = vec!["-p".into()];
-    if !is_first {
-        v.push("-c".into());
-    }
-    v.extend(
-        [
-            "--session-dir", session_dir,
-            "--tools", "read,write,edit",
-            "--auto-approve",
-            "--thinking", "off",
-            "--no-title",
-            "--no-extensions",
-            "--no-skills",
-            "--no-rules",
-        ]
-        .iter()
-        .map(|s| (*s).to_string()),
-    );
-    v
-}
-
-/// This invocation's plan (pure; mirrors psyche.rs::Plan).
-#[derive(Debug, PartialEq)]
-enum Plan {
-    Ack,
-    /// The dir-presence check happens at run() time (filesystem); the plan carries intent only.
-    Turn { is_first: bool, prompt: String },
-}
-
-fn plan(psyche_context: &str, event: &str) -> Plan {
-    let is_first = is_first_turn(psyche_context);
-    let prompt = compose_prompt(psyche_context, event);
-    if prompt.trim().is_empty() {
-        return Plan::Ack;
-    }
-    Plan::Turn { is_first, prompt }
-}
-
-fn fail_line(id: &str, cause: &str) -> String {
-    format!("PSYCHE_TURN_FAIL:{id}: {cause} — exiting nonzero (keep custody); the daemon owns retry/reseed (no internal retry)")
-}
-
-fn session_gone_line(id: &str) -> String {
-    format!("PSYCHE_SESSION_NOT_FOUND:{id}: psyche omp session dir holds no prior session — exit {EXIT_SESSION_GONE} (reseed)")
-}
-
-pub fn run() -> ExitCode {
-    let args = match Args::parse(std::env::args().skip(2)) {
-        Ok(a) => a,
-        Err(e) => {
-            eprintln!("claude-spt psyche-omp: {e}");
-            return ExitCode::from(2);
-        }
-    };
-
-    // The composed mind rides the core-written FILE (W4); a read failure is a keep-custody FAULT.
-    let psyche_context = match std::fs::read_to_string(&args.psyche_context_file) {
-        Ok(c) => c,
-        Err(e) => {
-            eprintln!("{}", fail_line(&args.id, &format!("mind file unreadable ({}): {e}", args.psyche_context_file)));
-            return ExitCode::FAILURE;
-        }
-    };
-
-    // The per-turn EVENT/COMMUNE rides our stdin.
-    let mut event = String::new();
-    if let Err(e) = std::io::stdin().read_to_string(&mut event) {
-        eprintln!("{}", fail_line(&args.id, &format!("stdin read failed: {e}")));
-        return ExitCode::FAILURE;
-    }
-
-    let (is_first, prompt) = match plan(&psyche_context, &event) {
-        Plan::Ack => {
-            println!("{ACK}");
-            return ExitCode::SUCCESS;
-        }
-        Plan::Turn { is_first, prompt } => (is_first, prompt),
-    };
-
-    let sdir = match psyche_session_dir(&args.psyche_context_file) {
-        Some(d) => d,
-        None => {
-            eprintln!("{}", fail_line(&args.id, "mind file path has no parent dir (no session-dir anchor)"));
-            return ExitCode::FAILURE;
-        }
-    };
-
-    // Seam 2: the shim-side session-gone discriminator, BEFORE any spawn (a fresh turn creates the
-    // dir instead; `-c` over an empty dir would silently mint a mindless session — never allow it).
-    if !is_first && !has_prior_session(&sdir) {
-        eprintln!("{}", session_gone_line(&args.id));
-        return ExitCode::from(EXIT_SESSION_GONE);
-    }
-    if let Err(e) = std::fs::create_dir_all(&sdir) {
-        eprintln!("{}", fail_line(&args.id, &format!("cannot create session dir {}: {e}", sdir.display())));
-        return ExitCode::FAILURE;
-    }
-
-    // Seam 3: the composed prompt rides a shim-owned @file, never argv content and never stdin.
-    let prompt_file = sdir.join(TURN_PROMPT_FILE);
-    if let Err(e) = std::fs::write(&prompt_file, &prompt) {
-        eprintln!("{}", fail_line(&args.id, &format!("cannot write turn prompt {}: {e}", prompt_file.display())));
-        return ExitCode::FAILURE;
-    }
-
-    let mut cmd = Command::new(crate::bridge::omp_bin());
-    cmd.args(turn_cmd(&sdir.to_string_lossy(), is_first));
-    cmd.arg(format!("@{}", prompt_file.display()));
-    // cwd = the psyche's nested perch dir (mind-file parent) — commune file-drops land beside it.
-    if let Some(parent) = Path::new(&args.psyche_context_file).parent().filter(|p| p.is_dir()) {
-        cmd.current_dir(parent);
-    }
-    cmd.stdin(Stdio::null()).stdout(Stdio::piped()).stderr(Stdio::piped());
-
-    let out = match cmd.output() {
-        Ok(o) => o,
-        Err(e) => {
-            eprintln!("{}", fail_line(&args.id, &format!("omp spawn failed: {e}")));
-            return ExitCode::FAILURE;
-        }
-    };
-    // Forward omp's stderr as log breadcrumbs (never decision-bearing).
-    let err_text = String::from_utf8_lossy(&out.stderr);
-    if !err_text.trim().is_empty() {
-        eprint!("{err_text}");
-    }
-    if !out.status.success() {
-        eprintln!("{}", fail_line(&args.id, &format!("omp exited {}", out.status)));
-        return ExitCode::FAILURE;
-    }
-    // omp stdout = the psyche's outbound channel (the daemon parses intents); non-empty guarantee.
-    let text = String::from_utf8_lossy(&out.stdout);
-    if text.trim().is_empty() {
-        println!("{ACK}");
-    } else {
-        print!("{text}");
-    }
-    ExitCode::SUCCESS
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn args(v: &[&str]) -> Result<Args, String> {
-        Args::parse(v.iter().map(|s| s.to_string()))
-    }
-
-    #[test]
-    fn parses_all_three_required_flags_any_order() {
-        let a = args(&["--session-id", "s1", "--psyche-context-file", "/x/mind.txt", "--id", "lib"]).unwrap();
-        assert_eq!(a, Args { id: "lib".into(), session_id: "s1".into(), psyche_context_file: "/x/mind.txt".into() });
-    }
-
-    #[test]
-    fn missing_or_unknown_flags_are_loud() {
-        assert!(args(&["--id", "x"]).is_err());
-        assert!(args(&["--id", "x", "--session-id", "s", "--psyche-context-file", "f", "--bogus", "v"]).is_err());
-    }
-
-    #[test]
-    fn first_turn_is_mind_nonempty() {
-        assert!(is_first_turn("composed mind"));
-        assert!(!is_first_turn(""));
-        assert!(!is_first_turn("  \n\t"));
-    }
-
-    #[test]
-    fn compose_first_is_mind_plus_event_later_is_event_alone() {
-        assert_eq!(compose_prompt("MIND\n", "EVENT"), "MIND\n\nEVENT");
-        assert_eq!(compose_prompt("", "EVENT"), "EVENT");
-    }
-
-    #[test]
-    fn blank_prompt_plans_ack_no_spawn() {
-        assert_eq!(plan("", "  \n"), Plan::Ack);
-        // A first turn's mind is non-empty by construction — always a Turn.
-        assert!(matches!(plan("mind", ""), Plan::Turn { is_first: true, .. }));
-    }
-
-    #[test]
-    fn turn_cmd_fresh_omits_continue_later_rides_it() {
-        let fresh = turn_cmd("/p/omp-sessions", true);
-        assert!(!fresh.contains(&"-c".to_string()));
-        assert_eq!(fresh[0], "-p");
-        let cont = turn_cmd("/p/omp-sessions", false);
-        assert!(cont.contains(&"-c".to_string()));
-        // Sandbox: file-IO tools only, auto-approved, no thinking/title/discovery surfaces.
-        for flag in ["--tools", "--auto-approve", "--thinking", "--no-title", "--no-extensions", "--no-skills", "--no-rules"] {
-            assert!(fresh.contains(&flag.to_string()), "fresh missing {flag}");
-            assert!(cont.contains(&flag.to_string()), "cont missing {flag}");
-        }
-        let ti = fresh.iter().position(|s| s == "--tools").unwrap();
-        assert_eq!(fresh[ti + 1], "read,write,edit");
-    }
-
-    #[test]
-    fn session_dir_is_mind_parent_slash_omp_sessions() {
-        let d = psyche_session_dir("/perch/nested/lib-psyche/psyche-context.txt").unwrap();
-        assert!(d.ends_with("omp-sessions"));
-        assert!(d.parent().unwrap().ends_with("lib-psyche"));
-        assert_eq!(psyche_session_dir("mind.txt"), None); // no parent → fault at run()
-    }
-
-    #[test]
-    fn prior_session_detection_keys_on_jsonl_presence() {
-        let work = std::env::temp_dir().join(format!("psyche-omp-test-{}", std::process::id()));
-        let _ = std::fs::remove_dir_all(&work);
-        std::fs::create_dir_all(&work).unwrap();
-        assert!(!has_prior_session(&work)); // empty dir → gone
-        std::fs::write(work.join("turn-prompt.md"), "x").unwrap();
-        assert!(!has_prior_session(&work)); // non-jsonl files don't count
-        std::fs::write(work.join("2026-07-09T00_abc.jsonl"), "{}").unwrap();
-        assert!(has_prior_session(&work));
-        let _ = std::fs::remove_dir_all(&work);
-    }
-
-    #[test]
-    fn missing_dir_reads_as_no_prior_session() {
-        assert!(!has_prior_session(Path::new("/definitely/not/a/real/dir/xyz")));
-    }
-}
diff --git a/tools/claude-spt/src/tag_scan.rs b/tools/claude-spt/src/tag_scan.rs
deleted file mode 100644
index e688136..0000000
--- a/tools/claude-spt/src/tag_scan.rs
+++ /dev/null
@@ -1,365 +0,0 @@
-//! `tag_scan` — the pure parse+plan half of tag-driven peer messaging + the commune-output shortcut
-//! (NEXT-WORKLOAD-PLAN Item 2). No I/O: the hook layer owns the digest pull, the `spt send` fan-out,
-//! the confirm-back, the commune-file write, and the cursor read/advance. This module is the grammar
-//! and the double-send guard, so both are unit-testable without a live daemon.
-//!
-//! Two output-embedded markers an agent can emit in its own turn output:
-//!
-//!   - **peer message** `@<t1,t2,t3 body @>` — send `body` to each comma-separated id. `@<` opens;
-//!     the target list runs until the FIRST whitespace (no internal spaces); `body` runs until the
-//!     FIRST `@>` (non-greedy, no escaping v1). A bare `@@id` is deliberately NOT a trigger (prose
-//!     discussing the syntax would false-fire); only the explicit `@<…@>` block dispatches.
-//!   - **commune** `>>commune<<` at output start — the rest of that output is the commune body,
-//!     written to `.claude/<id>-commune.md`. **Collision rule:** once an output is a commune, it is
-//!     NOT scanned for `@<…@>` (the meta-recursion guard — a commune may quote the messaging syntax).
-//!
-//! Double-send guard: dispatch is driven off the digest's `seq` cursor. Only Agent entries that carry
-//! a `seq` (finalized turn output) strictly greater than the stored cursor are dispatched, and the
-//! cursor advances to the max seq seen. `seq` is monotonic and `endpoint digest --after <seq>` excludes
-//! everything at-or-below it, so a section is dispatched exactly once across the PreToolUse (mid-turn)
-//! and Stop (backstop) hooks that both drive this. A partial (seq-less) Agent entry is skipped until it
-//! finalizes — a not-yet-closed `@<…` never fires. [impl->REQ-TAG-PEER-MESSAGING]
-
-use serde_json::Value;
-
-const OPEN: &str = "@<";
-const CLOSE: &str = "@>";
-const COMMUNE: &str = ">>commune<<";
-
-/// One parsed peer-message section: the raw target ids (in author order) and the message body. Target
-/// classification (unknown / self / offline) is the hook layer's job — it needs `self_id` and the live
-/// `spt send` result, neither of which belongs in a pure parser.
-#[derive(Debug, PartialEq, Eq)]
-pub struct TagSection {
-    pub targets: Vec<String>,
-    pub body: String,
-}
-
-/// The prose spans of `text` — everything OUTSIDE a fenced code block (```` ``` ````) and OUTSIDE an
-/// inline-code span (`` ` ``). Markdown code delimiters split the text on even/odd parity: for
-/// ```` ``` ````-split blocks the even indices are prose, and within each the `` ` ``-split even
-/// indices are prose. A tag is only dispatched from a prose span, so documentation/discussion that
-/// QUOTES the syntax in code formatting never false-fires (field-proven 2026-07-08, v0.17.0: the
-/// release notes' own `@<alice …@>` examples fired). A genuine send is written bare, in prose.
-fn prose_segments(text: &str) -> Vec<&str> {
-    let mut segs = Vec::new();
-    for (bi, block) in text.split("```").enumerate() {
-        if bi % 2 == 1 {
-            continue; // inside a fenced code block
-        }
-        for (si, span) in block.split('`').enumerate() {
-            if si % 2 == 1 {
-                continue; // inside an inline-code span
-            }
-            segs.push(span);
-        }
-    }
-    segs
-}
-
-/// Parse every `@<targets body @>` section from one output string, in author order — scanning only the
-/// PROSE spans (see [`prose_segments`]: a tag inside backticks or a code fence is a quotation, not a
-/// send). Malformed openers (no `@>` close — an in-progress partial) and empty-target sections are
-/// dropped. Non-greedy: each section closes at the first `@>` after its `@<`.
-pub fn parse_tag_sections(text: &str) -> Vec<TagSection> {
-    let mut out = Vec::new();
-    for seg in prose_segments(text) {
-        scan_prose_segment(seg, &mut out);
-    }
-    out
-}
-
-/// Scan ONE prose segment (no code delimiters within) for `@<…@>` sections, appending to `out`.
-fn scan_prose_segment(text: &str, out: &mut Vec<TagSection>) {
-    let mut i = 0;
-    while let Some(rel) = text[i..].find(OPEN) {
-        let start = i + rel + OPEN.len(); // first byte after "@<"
-        let Some(crel) = text[start..].find(CLOSE) else {
-            break; // no close for this opener → not a section (and none can follow it either)
-        };
-        let close = start + crel;
-        let inner = &text[start..close];
-        // Target list runs to the first whitespace; the body is the remainder (trimmed). No whitespace
-        // at all ⇒ the whole inner is the target list and the body is empty.
-        let (targ_str, body) = match inner.find(char::is_whitespace) {
-            Some(w) => (&inner[..w], inner[w..].trim()),
-            None => (inner.trim(), ""),
-        };
-        let targets: Vec<String> = targ_str
-            .split(',')
-            .map(str::trim)
-            .filter(|t| !t.is_empty())
-            .map(str::to_string)
-            .collect();
-        if !targets.is_empty() {
-            out.push(TagSection { targets, body: body.to_string() });
-        }
-        i = close + CLOSE.len();
-    }
-}
-
-/// If `text` (ignoring leading whitespace) begins with `>>commune<<`, return the commune body (the rest
-/// of the output, leading whitespace after the marker trimmed). The `!!checkpoint!!` escalation is an
-/// in-body marker the downstream ingest interprets — this returns the body verbatim so it survives.
-/// [impl->REQ-COMMUNE-OUTPUT-SHORTCUT]
-pub fn commune_body(text: &str) -> Option<String> {
-    text.trim_start()
-        .strip_prefix(COMMUNE)
-        .map(|rest| rest.trim_start().to_string())
-}
-
-/// Every assistant-output text block across raw CC transcript JSONL — the `type=assistant`
-/// `message.content[].type=text` entries, an agent's OWN output (the only place a tag or commune
-/// marker can originate). Mirrors the assistant mapping in `digest::extract`, read straight from the
-/// transcript so there is no async digest-projection lag: CC writes the turn's final assistant message
-/// to the transcript BEFORE it fires the Stop hook, so a tag that is the turn's last output is visible
-/// the moment Stop runs (the digest's `seq` is assigned later — the v0.17.0/1 end-of-turn miss).
-/// Malformed / non-assistant / thinking / tool_use lines are skipped. [impl->REQ-TAG-PEER-MESSAGING]
-pub fn assistant_texts_from_jsonl(jsonl: &str) -> Vec<String> {
-    let mut out = Vec::new();
-    for line in jsonl.lines() {
-        let line = line.trim();
-        if line.is_empty() {
-            continue;
-        }
-        let Ok(o) = serde_json::from_str::<Value>(line) else {
-            continue;
-        };
-        if o.get("type").and_then(Value::as_str) != Some("assistant") {
-            continue;
-        }
-        let Some(msg) = o.get("message") else { continue };
-        if msg.get("role").and_then(Value::as_str) != Some("assistant") {
-            continue;
-        }
-        if let Some(Value::Array(items)) = msg.get("content") {
-            for it in items {
-                if it.get("type").and_then(Value::as_str) == Some("text") {
-                    if let Some(t) = it.get("text").and_then(Value::as_str) {
-                        if !t.is_empty() {
-                            out.push(t.to_string());
-                        }
-                    }
-                }
-            }
-        }
-    }
-    out
-}
-
-/// The prefix of a transcript-tail `chunk` consisting only of COMPLETE (newline-terminated) lines,
-/// plus its byte length. The hook advances its byte cursor by exactly this many bytes, so a trailing
-/// partial line (CC mid-write) is re-read whole on the next hook — never parsed half-formed, never
-/// double-consumed. An empty return (no newline yet) means "nothing complete to process; hold cursor".
-pub fn complete_line_prefix(chunk: &str) -> (&str, usize) {
-    match chunk.rfind('\n') {
-        Some(i) => (&chunk[..=i], i + 1),
-        None => ("", 0),
-    }
-}
-
-/// The dispatch plan from a batch of new assistant-output texts: peer sends + commune bodies.
-#[derive(Debug, PartialEq, Eq)]
-pub struct Dispatch {
-    pub sends: Vec<TagSection>,
-    pub communes: Vec<String>,
-}
-
-/// Plan the dispatch from the new assistant-output texts (already sliced to what is new since the byte
-/// cursor). Per text: a commune marker routes to `communes` and suppresses tag scanning (collision
-/// rule / meta-recursion guard); otherwise the text is scanned for `@<…@>` peer-message sections.
-/// [impl->REQ-TAG-PEER-MESSAGING] [impl->REQ-COMMUNE-OUTPUT-SHORTCUT]
-pub fn plan_dispatch(texts: &[String]) -> Dispatch {
-    let mut sends = Vec::new();
-    let mut communes = Vec::new();
-    for t in texts {
-        if let Some(body) = commune_body(t) {
-            communes.push(body); // collision rule: a commune is NOT tag-scanned
-        } else {
-            sends.extend(parse_tag_sections(t));
-        }
-    }
-    Dispatch { sends, communes }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn sec(targets: &[&str], body: &str) -> TagSection {
-        TagSection { targets: targets.iter().map(|s| s.to_string()).collect(), body: body.to_string() }
-    }
-
-    // ---- grammar: parse_tag_sections ------------------------------------------------------------
-
-    #[test]
-    fn single_target_single_body() {
-        assert_eq!(parse_tag_sections("@<bob hello there @>"), vec![sec(&["bob"], "hello there")]);
-    }
-
-    #[test]
-    fn multi_target_comma_no_spaces() {
-        assert_eq!(
-            parse_tag_sections("@<bob,carol,dave ship it @>"),
-            vec![sec(&["bob", "carol", "dave"], "ship it")]
-        );
-    }
-
-    #[test]
-    fn body_runs_to_first_close_non_greedy() {
-        // A stray `@>` inside would-be body ends the section there; the tail is not a new section.
-        assert_eq!(parse_tag_sections("@<bob a @> b @>"), vec![sec(&["bob"], "a")]);
-    }
-
-    #[test]
-    fn multiple_sections_in_one_output() {
-        assert_eq!(
-            parse_tag_sections("intro @<bob hi @> mid @<carol yo @> end"),
-            vec![sec(&["bob"], "hi"), sec(&["carol"], "yo")]
-        );
-    }
-
-    #[test]
-    fn first_whitespace_ends_target_list_including_newline() {
-        // A newline is the first whitespace → target list is just `bob`, body is the next line.
-        assert_eq!(parse_tag_sections("@<bob\nmulti\nline @>"), vec![sec(&["bob"], "multi\nline")]);
-    }
-
-    #[test]
-    fn no_whitespace_all_targets_empty_body() {
-        assert_eq!(parse_tag_sections("@<bob,carol@>"), vec![sec(&["bob", "carol"], "")]);
-    }
-
-    #[test]
-    fn unclosed_opener_is_not_a_section() {
-        // A partial (still typing) never fires until `@>` closes it.
-        assert!(parse_tag_sections("@<bob half a message").is_empty());
-        // And an unclosed opener blocks nothing before it, but there IS nothing after to find.
-        assert_eq!(parse_tag_sections("@<bob done @> then @<carol unclosed"),
-                   vec![sec(&["bob"], "done")]);
-    }
-
-    #[test]
-    fn empty_target_list_dropped() {
-        assert!(parse_tag_sections("@< no targets @>").is_empty());
-        assert!(parse_tag_sections("@<,, @>").is_empty());
-    }
-
-    #[test]
-    fn bare_at_at_id_is_not_a_trigger() {
-        // The rejected shorthand: prose mentioning @@bob must not dispatch.
-        assert!(parse_tag_sections("cc @@bob and @@carol about the plan").is_empty());
-    }
-
-    #[test]
-    fn prose_without_the_block_is_inert() {
-        assert!(parse_tag_sections("I will message bob and carol shortly.").is_empty());
-    }
-
-    // [unit->REQ-TAG-PEER-MESSAGING] the false-fire guard (field-proven v0.17.0: the release notes'
-    // own examples fired). A tag QUOTED in inline-code or a fenced block is documentation, not a send.
-    #[test]
-    fn inline_code_quote_does_not_fire() {
-        // The exact shape that tripped in the wild: an example wrapped in backticks while explaining it.
-        assert!(parse_tag_sections("Write `@<alice hey there @>` anywhere in a reply.").is_empty());
-        assert!(parse_tag_sections("send to several with `@<alice,bob,carol …@>`").is_empty());
-    }
-
-    #[test]
-    fn fenced_code_block_quote_does_not_fire() {
-        let doc = "Example:\n```\n@<doyle status @>\n```\nthat is the syntax.";
-        assert!(parse_tag_sections(doc).is_empty());
-    }
-
-    #[test]
-    fn bare_tag_still_fires_alongside_a_quoted_one() {
-        // A real (bare) send in the same output as a quoted example: only the bare one dispatches.
-        let mixed = "The form is `@<alice example @>`. Actually sending now: @<doyle real message @>";
-        assert_eq!(parse_tag_sections(mixed), vec![sec(&["doyle"], "real message")]);
-    }
-
-    #[test]
-    fn tag_straddling_a_code_boundary_does_not_fire() {
-        // An opener in prose whose close is only reached inside code (or vice-versa) is not a section.
-        assert!(parse_tag_sections("@<alice body `@>` ").is_empty());
-    }
-
-    // ---- commune marker --------------------------------------------------------------------------
-
-    #[test]
-    fn commune_at_start_captures_body() {
-        assert_eq!(commune_body(">>commune<<\nctx delta here").as_deref(), Some("ctx delta here"));
-    }
-
-    #[test]
-    fn commune_tolerates_leading_whitespace() {
-        assert_eq!(commune_body("  \n>>commune<< body").as_deref(), Some("body"));
-    }
-
-    #[test]
-    fn commune_only_at_start() {
-        assert_eq!(commune_body("some text >>commune<< not a commune"), None);
-    }
-
-    #[test]
-    fn commune_body_preserves_checkpoint_marker() {
-        // The !!checkpoint!! escalation must survive verbatim for the downstream ingest.
-        let b = commune_body(">>commune<<\n!!checkpoint!!\nfinal state").unwrap();
-        assert!(b.starts_with("!!checkpoint!!"), "got {b:?}");
-    }
-
-    // ---- transcript parse + text-based planner ---------------------------------------------------
-
-    #[test]
-    fn assistant_texts_extracts_only_assistant_text_blocks() {
-        // A real CC transcript slice: a user turn, an assistant turn with thinking+text+tool_use, and
-        // a tool_result user line. Only the assistant `text` block is an agent's own output.
-        let jsonl = concat!(
-            r#"{"type":"user","message":{"role":"user","content":"do it"}}"#,
-            "\n",
-            r#"{"type":"assistant","message":{"role":"assistant","content":[{"type":"thinking","thinking":"x"},{"type":"text","text":"@<bob hi @>"},{"type":"tool_use","name":"Bash","input":{"command":"ls"}}]}}"#,
-            "\n",
-            r#"{"type":"user","message":{"role":"user","content":[{"type":"tool_result","content":"ok"}]}}"#,
-        );
-        assert_eq!(assistant_texts_from_jsonl(jsonl), vec!["@<bob hi @>".to_string()]);
-    }
-
-    #[test]
-    fn assistant_texts_skips_bad_and_nonassistant_lines() {
-        assert!(assistant_texts_from_jsonl("not json\n{\"type\":\"user\"}\n").is_empty());
-        assert!(assistant_texts_from_jsonl("").is_empty());
-    }
-
-    #[test]
-    fn complete_line_prefix_holds_a_trailing_partial() {
-        // Two whole lines + a partial third → only the two whole lines are consumed.
-        let chunk = "line one\nline two\npartial-being-written";
-        let (prefix, n) = complete_line_prefix(chunk);
-        assert_eq!(prefix, "line one\nline two\n");
-        assert_eq!(n, "line one\nline two\n".len());
-        // No newline yet → nothing complete, hold the cursor.
-        assert_eq!(complete_line_prefix("no newline yet"), ("", 0));
-    }
-
-    #[test]
-    fn plan_dispatch_scans_new_texts_for_tags() {
-        let texts = vec!["@<carol new @>".to_string(), "just working".to_string()];
-        let d = plan_dispatch(&texts);
-        assert_eq!(d.sends, vec![sec(&["carol"], "new")]);
-        assert!(d.communes.is_empty());
-    }
-
-    #[test]
-    fn plan_dispatch_commune_suppresses_tags() {
-        let texts = vec![">>commune<<\nstatus @<bob leak @>".to_string()];
-        let d = plan_dispatch(&texts);
-        assert_eq!(d.communes, vec!["status @<bob leak @>".to_string()]);
-        assert!(d.sends.is_empty(), "a commune output is never tag-scanned (meta-recursion guard)");
-    }
-
-    #[test]
-    fn plan_dispatch_empty_when_no_markers() {
-        let d = plan_dispatch(&["nothing here".to_string()]);
-        assert!(d.sends.is_empty() && d.communes.is_empty());
-    }
-}
diff --git a/tools/claude-spt/src/translate.rs b/tools/claude-spt/src/translate.rs
deleted file mode 100644
index 5f43d8f..0000000
--- a/tools/claude-spt/src/translate.rs
+++ /dev/null
@@ -1,913 +0,0 @@
-//! `claude-spt translate` — the `[message-idle-translation-binary]` for the claude-spt adapter
-//! (spt-core harness-contract v0.13.0+; folded from the standalone cc-spt-idle-translate crate into
-//! this subcommand via the v0.16.0 `[message-idle-translation-binary].command` seam — ADR-0006/D3).
-//!
-//! A lifecycle-managed `stdin -> stdout` JSON-lines filter. spt-core spawns it when the spt-hosted
-//! endpoint comes online and reaps it on shutdown; it turns each inbound `<EVENT>` envelope into a
-//! sequence of keystroke-commands that spt-core applies ATOMICALLY to the broker-held PTY (live
-//! operator input is buffered during emission, so it coexists with an attached `spt rc` controller).
-//! Scope is IDLE delivery only — busy/mid-turn injection stays the adapter's `[inject]` hook path.
-//!
-//! CHECKPOINT BRANCH (agent-driven context reset) — SPLIT across CC's clear-done signal so the wake
-//! can never race ahead of the `/clear`:
-//!   * ARM: an envelope carrying `json="{"checkpoint":"v1",…}"` (self-sent by the PostToolUse commune
-//!     hook via `spt send --json-payload --force-native`) stashes the wake in the in-memory
-//!     `pending_wake` and emits CLEAR-ONLY (ctrl+s · 50ms · /clear · 50ms · enter · commit).
-//!   * FIRE: an envelope carrying `json="{"checkpoint_fire":"v1"}"` (self-sent by the SessionStart
-//!     hook on a `clear` boundary, `--force-native`) emits WAKE-ONLY (ctrl+s · 50ms · wake · 50ms · enter ·
-//!     commit) iff a wake is armed, else no-ops.
-//! A single inject sequence cannot straddle a `/clear` (the async clear re-runs SessionStart with
-//! network I/O, and every sequence must {commit} within the 5s INJECT_COMMIT_DEADLINE), so the split
-//! is mandatory — the wake emits only after SessionStart, which only fires after clear completes. The
-//! structured markers live inside the opaque json attr spt-core carries verbatim, so a normal message
-//! can never forge them. State lives ONLY here (no marker file; the hook is stateless). See
-//! `dispatch_event` / `commands_for_clear` / `commands_for_boundary` / `is_checkpoint_fire`.
-//! [impl->REQ-HAZARD-CHECKPOINT-CLEAR-RACE]
-//!
-//! Input protocol (stdin, one JSON object per line):
-//!   {"type":"init","endpoint_id":…,"node":…}   — first message (handshake; no output)
-//!   {"type":"event","envelope":"<EVENT…>"}      — one inbound message; the full EVENT envelope
-//!   {"type":"input"}                            — content-free ping when the operator types (no output)
-//!
-//! Output protocol (stdout, one JSON object per line):
-//!   {"key":"ctrl+s"}     — keystroke command (Claude Code: STASH the current draft input)
-//!   {"key":"enter"}      — keystroke command (submit the PTY line; see SUBMIT note below)
-//!   {"delay_ms":50}      — inter-command pause
-//!   {"text":"<payload>"} — text injection (the envelope; NO trailing \r — it does not submit CC)
-//!   {"commit":true}      — MANDATORY sequence terminator (release the InjectFloor; see below)
-//!
-//! The per-event choreography delivers the message WITHOUT clobbering a half-typed draft the operator
-//! may have in the input box, then terminates the inject sequence:
-//!   1. ctrl+s              stash any existing draft
-//!   2. delay 50ms          let the stash settle
-//!   3. <envelope>          type the envelope (multi-line: a raw \n after the opening tag and before
-//!                          the closing </EVENT> — CC soft-newlines a bare \n, so it frames across
-//!                          lines without submitting; no trailing CR)
-//!   4. delay 50ms          let the text land in CC's input box before the submit key
-//!   5. {"key":"enter"}     submit the line
-//!   6. {"commit":true}     terminate the inject sequence
-//! No trailing restore keystroke: Claude Code AUTO-RESTORES the stashed draft after the submit, so a
-//! second ctrl+s would be redundant (it would re-stash, not restore).
-//!
-//! SUBMIT IS A REAL ENTER KEY, NOT A TRAILING `\r` (corrected 2026-06-23): we previously rode the
-//! submit IN the text as a trailing `\r`, on the assumption that spt-core applies `{"text"}` VERBATIM
-//! to the PTY (broker.rs:1066, :1016-1017) and a `\r` byte == `{"key":"enter"}`
-//! (`key_to_bytes("enter")->b"\r"`). Empirically that is NOT enough: a `\r` byte in injected text does
-//! NOT trigger Claude Code's message submission — CC needs the discrete Enter KEY event. So step 5 is
-//! now a separate `{"key":"enter"}` after the text lands. The verbatim-text application still REQUIRES
-//! `commands_for_event` to neutralize the envelope's INTERNAL CR/LF (an un-neutralized `\n`/`\r` would
-//! reach the PTY and could split or corrupt the injection) — only the discrete Enter submits.
-//!
-//! TWO DISTINCT SIGNALS — do not conflate them:
-//!  - The `{"key":"enter"}` in step 5 is the HARNESS-level submit (the discrete keypress CC needs).
-//!  - The `{"commit":true}` in step 6 is the PROTOCOL-level terminator: `run_inject_worker`
-//!    (broker.rs:1075-1090) ends an inject sequence ONLY on an explicit `{commit}`. Text/Key/Delay
-//!    just enqueue; a sequence that emits no `{commit}` hits `INJECT_COMMIT_DEADLINE` (5s,
-//!    broker.rs:151-169) and FAULTS on every delivery (reverts to raw inject — input isn't lost but
-//!    each delivery stalls to the deadline). `{commit}` flushes the live controller's buffered input
-//!    and releases the InjectFloor race-free. Enter submits the line; `{commit}` ends the sequence.
-//!
-//! Degenerate fallback (per the published contract): `{"text":payload}{"key":"enter"}{"commit":true}`
-//! with no choreography — even the bare form MUST commit. (The published manifest doc ORIGINALLY
-//! omitted `{commit}` from the vocabulary and its degenerate example — a public-surface defect this
-//! adapter's blind-build caught, logged F-016. The contract is now CORRECTED + live:
-//! harness-contract/manifest.html documents `{commit}` as the mandatory terminator + the 5s
-//! commit-deadline + inject-floor release + raw-inject fallback, since v0.13.0.)
-//! We choreograph because Claude Code's input box supports the ctrl+s draft stash/restore, so an
-//! inbound message never eats an in-progress draft.
-//!
-//! Robustness: this is lifecycle-critical — a panic would drop the idle-delivery pipe for the whole
-//! session. Malformed lines and unknown `type`s degrade gracefully (skipped, never fatal); unknown
-//! JSON fields are ignored (forward-compat with newer spt-core). [impl->REQ-DIST-IDLE-TRANSLATE]
-
-use serde_json::{json, Value};
-use std::io::{self, BufRead, Write};
-use std::process::ExitCode;
-
-/// Inter-command pause spt-core honors between emitted keystroke/text commands (operator spec).
-const DELAY_MS: u64 = 50;
-
-/// Wake directive used when a checkpoint carries no explicit `wake` (operator-specified default).
-const DEFAULT_WAKE: &str = "Proceed with next steps";
-
-/// Extract the raw (still XML-attr-escaped) value of the `json="…"` attribute from an EVENT
-/// envelope's opening tag, if present. Returns None when there is no such attribute. The attr value
-/// is the structured checkpoint payload spt-core carried verbatim from `spt send --json-payload`
-/// (doyle 2026-06-24): spt-core never parses it — it rides as an opaque envelope attribute. We only
-/// look inside the opening tag (before the first `>`), and an attr value is XML-escaped so it cannot
-/// contain a raw `"`, so the first `"` after `json="` terminates it. [impl->REQ-DIST-CHECKPOINT-COMMUNE]
-fn extract_json_attr(envelope: &str) -> Option<String> {
-    let gt = envelope.find('>')?; // opening tag ends at the first '>'
-    let opening = &envelope[..gt];
-    // Leading space ensures we match a real attribute, not a substring of some other name.
-    let key = " json=\"";
-    let ki = opening.find(key)?;
-    let rest = &opening[ki + key.len()..];
-    let end = rest.find('"')?;
-    Some(rest[..end].to_string())
-}
-
-/// Reverse XML attribute escaping. spt-core attr-escapes the `json` value; we must unescape it BEFORE
-/// JSON-parsing. `&amp;` is decoded LAST so an embedded `&amp;quot;` does not double-decode (doyle's
-/// caveat). This is a SEPARATE escape layer from the message body's `<br>`/HTML-unescape handling.
-/// [impl->REQ-DIST-CHECKPOINT-COMMUNE]
-fn xml_attr_unescape(s: &str) -> String {
-    s.replace("&quot;", "\"")
-        .replace("&lt;", "<")
-        .replace("&gt;", ">")
-        .replace("&amp;", "&") // LAST
-}
-
-/// If this envelope carries a `{"checkpoint":"v1", ...}` json attr, return the wake directive (the
-/// `wake` field, or DEFAULT_WAKE when absent/blank). Any other shape — no json attr, malformed JSON,
-/// a different/absent `checkpoint` marker — returns None so delivery falls through to the normal
-/// multi-line path. Collision-proof: the marker lives INSIDE the structured attr value, so a normal
-/// message body can never forge it. [impl->REQ-DIST-CHECKPOINT-COMMUNE]
-fn checkpoint_wake(envelope: &str) -> Option<String> {
-    let raw = extract_json_attr(envelope)?;
-    let v: Value = serde_json::from_str(&xml_attr_unescape(&raw)).ok()?;
-    if v.get("checkpoint").and_then(Value::as_str) != Some("v1") {
-        return None;
-    }
-    let wake = v
-        .get("wake")
-        .and_then(Value::as_str)
-        .map(str::trim)
-        .filter(|s| !s.is_empty())
-        .unwrap_or(DEFAULT_WAKE);
-    Some(wake.to_string())
-}
-
-/// The CLEAR half of the checkpoint (ARM path): stash any lingering draft, submit `/clear`, terminate.
-/// The wake is deliberately NOT emitted here — it is stashed in the loop's `pending_wake` and fired
-/// only after CC finishes the clear and re-runs SessionStart (which self-sends the `checkpoint_fire`
-/// signal). This split is the ordering fix: a single inject sequence CANNOT straddle a `/clear` (the
-/// async clear re-runs SessionStart with network I/O, and the whole sequence must `{commit}` within
-/// the 5s INJECT_COMMIT_DEADLINE — a fixed post-clear delay races and the wake lands in the OLD
-/// session). Terminated by the mandatory `{commit}`. [impl->REQ-HAZARD-CHECKPOINT-CLEAR-RACE]
-fn commands_for_clear() -> Vec<Value> {
-    vec![
-        json!({ "key": "ctrl+s" }),      // 1. stash any lingering input
-        json!({ "delay_ms": DELAY_MS }), // 2. let the stash settle (mandatory after ctrl+s)
-        json!({ "text": "/clear" }),     // 3. type the clear command
-        json!({ "delay_ms": DELAY_MS }), // 4. let the text land before the submit key (see wake note)
-        json!({ "key": "enter" }),       // 5. submit /clear (resets the session)
-        json!({ "commit": true }),       // 6. terminate the inject sequence
-    ]
-}
-
-// (The former standalone WAKE emit lives in `commands_for_boundary` below — the wake half of the
-// combined post-clear sequence. Its text→enter settle note, field-derived 2026-07-04, carries over:
-// without the delay the discrete enter's \r coalesces into the still-landing text as a SOFT
-// NEWLINE; a short text usually wins the race, a paragraph-length wake reliably loses it.)
-
-/// If this envelope carries a `{"rename":"v1",…}` json attr — the boundary-rename signal the
-/// SessionStart hook self-sends on a `clear` boundary (BEFORE the fire) — return the display name
-/// to re-assert (trimmed; empty when the `name` field is absent/blank, so the caller can answer a
-/// bare {commit} instead of submitting a stray `/rename `). Any other shape returns None and
-/// delivery falls through unchanged. Same opaque-json-attr collision-proofing as the checkpoint
-/// markers. [impl->REQ-DIST-BOUNDARY-RENAME]
-fn rename_directive(envelope: &str) -> Option<String> {
-    let raw = extract_json_attr(envelope)?;
-    let v: Value = serde_json::from_str(&xml_attr_unescape(&raw)).ok()?;
-    if v.get("rename").and_then(Value::as_str) != Some("v1") {
-        return None;
-    }
-    Some(v.get("name").and_then(Value::as_str).unwrap_or("").trim().to_string())
-}
-
-/// Collapse stray CR/LF to spaces so a typed line can never split the injection (the shared guard
-/// for the rename name and the wake directive).
-fn sanitize_line(s: &str) -> String {
-    s.chars().map(|c| if c == '\r' || c == '\n' { ' ' } else { c }).collect()
-}
-
-/// Settle between the rename's submit and the wake's stash within the ONE combined post-clear
-/// sequence: the enter→next-keystroke bridge the two-sequence design could not govern. Field-paid
-/// 2026-07-06 (flynn): rename and wake rode two back-to-back inject sequences, and with CC's input
-/// processing lagging the PTY stream at the just-rebuilt boundary, the rename's enter registered
-/// as a soft newline, the next sequence's ctrl+s failed to stash the residue, and the wake text
-/// submitted INSIDE the /rename argument — session titled with the wake, no wake turn, agent
-/// dormant ~9.5h (~33% observed rate, 1 of 3 checkpoints). [impl->REQ-DIST-BOUNDARY-RENAME]
-const BOUNDARY_BRIDGE_MS: u64 = 150;
-
-/// The COMBINED post-clear boundary emit — rename and/or wake in ONE inject sequence, one commit.
-/// Emitted only on the fire signal (strictly after SessionStart, i.e. after /clear completed).
-/// `/rename` is a local no-turn CC command (inline rest-of-line arg, renames the CURRENT session —
-/// empirically confirmed 2026-07-05), so the wake still lands on an idle session. The single
-/// sequence exists precisely so no inter-sequence keystroke race can interleave the two halves
-/// (see BOUNDARY_BRIDGE_MS); neither half present answers the mandatory bare {commit}
-/// (REQ-HAZARD-EMPTY-RESPONSE-COMMIT). [impl->REQ-DIST-BOUNDARY-RENAME]
-/// [impl->REQ-HAZARD-CHECKPOINT-CLEAR-RACE]
-fn commands_for_boundary(rename: Option<String>, wake: Option<String>) -> Vec<Value> {
-    let mut v = Vec::new();
-    if let Some(name) = rename {
-        v.push(json!({ "key": "ctrl+s" }));      // stash any lingering input
-        v.push(json!({ "delay_ms": DELAY_MS })); // let the stash settle
-        v.push(json!({ "text": format!("/rename {}", sanitize_line(&name)) }));
-        v.push(json!({ "delay_ms": DELAY_MS })); // text→enter settle
-        v.push(json!({ "key": "enter" }));       // submit — local command, no agent turn
-    }
-    if let Some(w) = wake {
-        if !v.is_empty() {
-            // enter→ctrl+s bridge: let the rename's submit fully register before the wake half
-            // stashes + types (the 2026-07-06 blend guard).
-            v.push(json!({ "delay_ms": BOUNDARY_BRIDGE_MS }));
-        }
-        v.push(json!({ "key": "ctrl+s" }));      // stash any residue (incl. a coalesced rename)
-        v.push(json!({ "delay_ms": DELAY_MS })); // let the stash settle
-        v.push(json!({ "text": sanitize_line(&w) }));
-        v.push(json!({ "delay_ms": DELAY_MS })); // text→enter settle (field-required, 2026-07-04)
-        v.push(json!({ "key": "enter" }));       // submit the wake — the first post-checkpoint turn
-    }
-    v.push(json!({ "commit": true }));           // the mandatory sequence terminator
-    v
-}
-
-/// Does this envelope carry the `{"checkpoint_fire":"v1"}` signal — the post-clear FIRE trigger the
-/// SessionStart hook self-sends on a `clear` boundary? The marker lives inside the opaque json attr
-/// spt-core carries verbatim, so a normal message can never forge it. Distinct from `checkpoint_wake`
-/// (the ARM signal). [impl->REQ-HAZARD-CHECKPOINT-CLEAR-RACE]
-fn is_checkpoint_fire(envelope: &str) -> bool {
-    let Some(raw) = extract_json_attr(envelope) else {
-        return false;
-    };
-    let Ok(v) = serde_json::from_str::<Value>(&xml_attr_unescape(&raw)) else {
-        return false;
-    };
-    v.get("checkpoint_fire").and_then(Value::as_str) == Some("v1")
-}
-
-/// Frame a (CR/LF-sanitized) EVENT envelope across MULTIPLE LINES for visual distinction in CC's
-/// input box: a raw `\n` after the opening `<EVENT …>` tag and a raw `\n` before the closing
-/// `</EVENT>`, so an inbound idle message renders as
-///
-/// ```text
-/// <EVENT type="msg" from="doyle">
-/// body
-/// </EVENT>
-/// ```
-///
-/// instead of one dense line. This is safe because spt-core writes `{"text"}` byte-verbatim
-/// INCLUDING `\n` (broker.rs:1016-1017, doyle 2026-06-20) and Claude Code SOFT-NEWLINES on a bare
-/// `\n` in the input box rather than submitting — empirically gated 2026-06-24 (a two-line `{text}`
-/// landed as ONE user turn with the `\n` preserved, no early submit). Cyan/SGR distinction is
-/// impossible (CC's input handling eats SGR bytes; user-turns are theme-fixed), so a multi-line
-/// plain-text frame is the only viable visual distinction.
-///
-/// `s` must already have its stray CR/LF neutralized (see `commands_for_event`) — the only newlines
-/// in the result are the two we deliberately insert at the structural seams. Degenerate inputs that
-/// don't match `<…>…</EVENT>` (e.g. an `<EVENT-PART …>` chunk, or a non-envelope payload) fall back
-/// to the single-line form unchanged — never panic, never corrupt. [impl->REQ-DIST-IDLE-MULTILINE]
-fn frame_envelope(s: &str) -> String {
-    // Opening tag ends at the first '>' (EVENT bodies HTML-escape '>' as &gt;, and attribute values
-    // carry no raw '>', so the first '>' is the opening tag's close).
-    let Some(gt) = s.find('>') else { return s.to_string() };
-    // Closing tag is the last literal "</EVENT>" ("</EVENT-PART>" does not contain it, so EVENT-PART
-    // chunks correctly fall through to the single-line form).
-    let Some(close) = s.rfind("</EVENT>") else { return s.to_string() };
-    // The body sits strictly between the opening '>' and the closing tag.
-    if close < gt + 1 {
-        return s.to_string();
-    }
-    let opening = &s[..=gt];
-    let body = &s[gt + 1..close];
-    let closing = &s[close..];
-    format!("{opening}\n{body}\n{closing}")
-}
-
-/// Build the keystroke-command sequence for one inbound EVENT envelope.
-///
-/// `envelope` is the full `<EVENT…>…</EVENT>` string. The envelope is single-line by contract (it
-/// encodes newlines as the literal `<br>` token), but we defensively strip any raw CR/LF so a stray
-/// newline can never split or corrupt the injection. (Necessary because spt-core applies `{"text"}`
-/// verbatim — broker.rs:1066/:1016-1017, doyle 2026-06-20 — so any internal CR/LF would otherwise
-/// reach the PTY.) After sanitizing, `frame_envelope` re-inserts exactly two deliberate `\n`s at the
-/// opening-tag / body / closing-tag seams to render the message across multiple lines (CC soft-newlines
-/// a bare `\n`; empirically gated 2026-06-24). The submit is a DISCRETE `{"key":"enter"}` AFTER the
-/// text — a trailing `\r` byte in the text does NOT submit a Claude Code message (corrected
-/// 2026-06-23), and the deliberate `\n`s soft-newline rather than submit. The closing `{"commit"}`
-/// is the MANDATORY inject-sequence terminator (broker.rs:1075-1090; no-commit FAULTs at the 5s
-/// INJECT_COMMIT_DEADLINE). [impl->REQ-DIST-IDLE-TRANSLATE] [impl->REQ-DIST-IDLE-MULTILINE]
-///
-/// PURE normal delivery only — the checkpoint ARM/FIRE branches live in the stateful `dispatch_event`
-/// (they own `pending_wake`); this function never sees them.
-fn commands_for_event(envelope: &str) -> Vec<Value> {
-    let sanitized: String = envelope
-        .chars()
-        .map(|c| if c == '\r' || c == '\n' { ' ' } else { c })
-        .collect();
-    let framed = frame_envelope(&sanitized); // re-insert the two deliberate structural newlines
-    vec![
-        json!({ "key": "ctrl+s" }),      // 1. stash any existing draft
-        json!({ "delay_ms": DELAY_MS }), // 2. let the stash settle
-        json!({ "text": framed }),       // 3. type the multi-line envelope — only the framing \n's; NO trailing CR
-        json!({ "delay_ms": DELAY_MS }), // 4. let the text land in CC's input box before the submit key
-        json!({ "key": "enter" }),       // 5. submit — a real Enter keypress (CC needs the key event, not a \r byte)
-        json!({ "commit": true }),       // 6. terminate the inject sequence (release the InjectFloor)
-    ]
-}
-
-/// Process-lifetime post-clear state: the checkpoint wake armed by an ARM envelope and the display
-/// name stashed by a rename envelope, both drained by the fire. One persistent process per
-/// endpoint, so this survives across deliveries (reaped on shutdown, NOT on /clear).
-#[derive(Default)]
-struct Pending {
-    wake: Option<String>,
-    rename: Option<String>,
-}
-
-/// Stateful event dispatch — the ARM / STASH / FIRE / normal decision that owns [`Pending`].
-///
-/// * A `{"checkpoint":"v1",…}` envelope ARMS: stash the (default-resolved) wake in `pending.wake`
-///   and emit CLEAR-only (the wake is withheld until the post-clear fire). A fresh checkpoint
-///   SUPERSEDES any previously-armed wake (at most one pending).
-/// * A `{"rename":"v1",…}` envelope (the boundary rename, self-sent by SessionStart BEFORE the
-///   fire on every clear) STASHES the name and answers a bare `{commit}` — it emits NOTHING of its
-///   own. The rename keystrokes ride the fire's single combined sequence: two back-to-back inject
-///   sequences raced at the post-clear boundary and the wake text submitted INSIDE the /rename
-///   argument (flynn 2026-07-06, ~33%; see BOUNDARY_BRIDGE_MS). `pending.wake` untouched.
-/// * A `{"checkpoint_fire":"v1"}` envelope FIRES: emit the ONE combined boundary sequence from
-///   whatever is pending — rename half, wake half, both, or (nothing pending — the hook fires on
-///   EVERY clear, stateless) the mandatory bare `{commit}` (REQ-HAZARD-EMPTY-RESPONSE-COMMIT;
-///   zero-record answers TERMINATE the binary, pinned 2026-07-04).
-/// * Anything else delivers normally (unchanged).
-///
-/// A fire envelope carries no `checkpoint` key so `checkpoint_wake` returns None first — the branch
-/// order is unambiguous. [impl->REQ-HAZARD-CHECKPOINT-CLEAR-RACE] [impl->REQ-DIST-BOUNDARY-RENAME]
-fn dispatch_event(pending: &mut Pending, envelope: &str) -> Vec<Value> {
-    if let Some(wake) = checkpoint_wake(envelope) {
-        pending.wake = Some(wake); // ARM — supersede any stale pending wake
-        return commands_for_clear();
-    }
-    if let Some(name) = rename_directive(envelope) {
-        // STASH — a blank/absent name stashes nothing (never a stray `/rename ` submit); either
-        // way the delivery opened an inject sequence broker-side, so answer the bare {commit}.
-        pending.rename = (!name.is_empty()).then_some(name);
-        return vec![json!({ "commit": true })];
-    }
-    if is_checkpoint_fire(envelope) {
-        return commands_for_boundary(pending.rename.take(), pending.wake.take());
-    }
-    commands_for_event(envelope)
-}
-
-/// Dispatch one parsed input line to its output commands. `init`/`input` (and any unknown `type`)
-/// produce nothing — they are stdin protocol lines, not inject deliveries, and an unsolicited
-/// `{commit}` outside a sequence is protocol noise. Only `event` emits the choreography, and an
-/// `event` ALWAYS answers at least a bare `{commit}` (REQ-HAZARD-EMPTY-RESPONSE-COMMIT).
-/// `pending` is the process-lifetime post-clear state threaded from `run`.
-fn dispatch_line(pending: &mut Pending, v: &Value) -> Vec<Value> {
-    match v.get("type").and_then(Value::as_str) {
-        Some("event") => match v.get("envelope").and_then(Value::as_str) {
-            Some(env) => dispatch_event(pending, env),
-            // Event without an envelope: nothing to deliver, but an event-typed input opened an
-            // inject sequence broker-side — answer a bare {commit} so it terminates instead of
-            // faulting at the 5s deadline. [impl->REQ-HAZARD-EMPTY-RESPONSE-COMMIT]
-            None => vec![json!({ "commit": true })],
-        },
-        // "init" handshake, "input" operator-typing ping, or any unknown type: no output.
-        _ => Vec::new(),
-    }
-}
-
-/// `claude-spt translate` entry — the [message-idle-translation-binary] stdin->stdout JSON-lines
-/// filter (was the cc-spt-idle-translate crate; folded in via the v0.16.0 `command` seam, ADR-0006/D3).
-/// Reads no argv: the protocol is entirely stdin/stdout, unchanged from the standalone binary.
-pub fn run() -> ExitCode {
-    let stdin = io::stdin();
-    let stdout = io::stdout();
-    let mut out = stdout.lock();
-
-    // Process-lifetime post-clear state (armed wake + stashed rename), drained by the fire.
-    let mut pending = Pending::default();
-    // The interrupt-watch heartbeat is spawned once, from the `init` handshake (where the endpoint id
-    // first becomes known) — the receive-heal for a hookless Esc-interrupt (fix 3). [impl->REQ-HAZARD-INTERRUPT-STUCK-BUSY]
-    let mut watch_started = false;
-
-    for line in stdin.lock().lines() {
-        let line = match line {
-            Ok(l) => l,
-            Err(_) => break, // stdin closed/errored: spt-core is tearing us down.
-        };
-        let trimmed = line.trim();
-        if trimmed.is_empty() {
-            continue;
-        }
-        let v: Value = match serde_json::from_str(trimmed) {
-            Ok(v) => v,
-            Err(e) => {
-                // Skip malformed lines — never fatal. stderr lands in spt-core's log, not the PTY.
-                eprintln!("claude-spt translate: skipping unparseable line: {e}");
-                continue;
-            }
-        };
-        // First `init` handshake: learn our endpoint id and start the interrupt-watch heartbeat.
-        if !watch_started && v.get("type").and_then(Value::as_str) == Some("init") {
-            if let Some(eid) = v.get("endpoint_id").and_then(Value::as_str) {
-                crate::interrupt_watch::spawn(eid);
-                watch_started = true;
-            }
-        }
-        for cmd in dispatch_line(&mut pending, &v) {
-            // One compact JSON object per line; flush per command so spt-core applies promptly.
-            if writeln!(out, "{cmd}").is_err() || out.flush().is_err() {
-                return ExitCode::SUCCESS; // stdout closed: endpoint gone.
-            }
-        }
-    }
-    ExitCode::SUCCESS
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn keys(cmds: &[Value]) -> Vec<String> {
-        cmds.iter()
-            .map(|c| {
-                if let Some(k) = c.get("key").and_then(Value::as_str) {
-                    format!("key:{k}")
-                } else if let Some(d) = c.get("delay_ms").and_then(Value::as_u64) {
-                    format!("delay:{d}")
-                } else if let Some(t) = c.get("text").and_then(Value::as_str) {
-                    format!("text:{t}")
-                } else if c.get("commit").and_then(Value::as_bool) == Some(true) {
-                    "commit".into()
-                } else {
-                    "?".into()
-                }
-            })
-            .collect()
-    }
-
-    #[test]
-    fn event_emits_the_stash_submit_commit_choreography() {
-        let cmds = commands_for_event("<EVENT type=\"msg\" from=\"doyle\">hi</EVENT>");
-        assert_eq!(
-            keys(&cmds),
-            vec![
-                "key:ctrl+s".to_string(),
-                "delay:50".to_string(),
-                // The envelope is framed across lines: \n after the opening tag, \n before </EVENT>.
-                "text:<EVENT type=\"msg\" from=\"doyle\">\nhi\n</EVENT>".to_string(),
-                "delay:50".to_string(),
-                "key:enter".to_string(),
-                "commit".to_string(),
-            ]
-        );
-    }
-
-    // [unit->REQ-DIST-IDLE-MULTILINE]
-    #[test]
-    fn envelope_is_framed_across_three_lines() {
-        // The deliberate visual-distinction frame: opening tag · \n · body · \n · closing tag.
-        // CC soft-newlines a bare \n (empirically gated 2026-06-24), so this renders as one user
-        // turn spanning three lines, not an early submit.
-        let cmds = commands_for_event("<EVENT type=\"msg\" from=\"doyle\">hello there</EVENT>");
-        let text = cmds[2].get("text").and_then(Value::as_str).unwrap();
-        assert_eq!(
-            text,
-            "<EVENT type=\"msg\" from=\"doyle\">\nhello there\n</EVENT>"
-        );
-        // Exactly two deliberate newlines (the structural seams) and zero CR.
-        assert_eq!(text.matches('\n').count(), 2, "exactly two framing newlines");
-        assert_eq!(text.matches('\r').count(), 0, "no CR");
-        // The three lines are: opening tag, body, closing tag.
-        let lines: Vec<&str> = text.split('\n').collect();
-        assert_eq!(lines[0], "<EVENT type=\"msg\" from=\"doyle\">");
-        assert_eq!(lines[1], "hello there");
-        assert_eq!(lines[2], "</EVENT>");
-    }
-
-    #[test]
-    fn frame_envelope_falls_back_on_non_envelope_payloads() {
-        // No opening '>' or no closing </EVENT>: leave the text single-line (never panic/corrupt).
-        assert_eq!(frame_envelope("plain payload, no tags"), "plain payload, no tags");
-        assert_eq!(frame_envelope("<EVENT no close"), "<EVENT no close");
-        // An EVENT-PART chunk has no literal "</EVENT>" (it ends "</EVENT-PART>"), so it falls back.
-        let part = "<EVENT-PART seq=\"1/2\" id=\"abcd1234\">chunk</EVENT-PART>";
-        assert_eq!(frame_envelope(part), part);
-        assert!(!frame_envelope(part).contains('\n'), "EVENT-PART stays single-line");
-    }
-
-    #[test]
-    fn frame_envelope_handles_attrless_and_empty_body() {
-        // Attribute-less opening tag still frames on the first '>'.
-        assert_eq!(frame_envelope("<EVENT>body</EVENT>"), "<EVENT>\nbody\n</EVENT>");
-        // Empty body yields an empty middle line — harmless.
-        assert_eq!(frame_envelope("<EVENT></EVENT>"), "<EVENT>\n\n</EVENT>");
-    }
-
-    #[test]
-    fn sequence_terminates_with_a_mandatory_commit() {
-        // broker.rs run_inject_worker ends a sequence ONLY on {commit:true}; without it the broker
-        // FAULTs at the 5s INJECT_COMMIT_DEADLINE on every delivery. The terminator MUST be last.
-        let cmds = commands_for_event("m");
-        assert_eq!(cmds.last().unwrap().get("commit").and_then(Value::as_bool), Some(true));
-        // Exactly one commit, and it is the final command (nothing emits after the terminator).
-        let commits = cmds.iter().filter(|c| c.get("commit").is_some()).count();
-        assert_eq!(commits, 1, "exactly one terminating commit");
-    }
-
-    #[test]
-    fn no_trailing_restore_keystroke() {
-        // CC auto-restores the stashed draft after the submit, so there is EXACTLY ONE ctrl+s (the
-        // stash) — never a trailing restore. (The sequence ends with the {commit} terminator.)
-        let cmds = commands_for_event("m");
-        let ctrl_s = cmds.iter().filter(|c| c.get("key").and_then(Value::as_str) == Some("ctrl+s")).count();
-        assert_eq!(ctrl_s, 1, "exactly one ctrl+s (stash only); CC auto-restores");
-    }
-
-    #[test]
-    fn submit_is_a_discrete_enter_key_not_a_trailing_cr() {
-        let cmds = commands_for_event("payload");
-        // The text carries NO trailing \r — a \r byte does not submit a Claude Code message.
-        let text = cmds[2].get("text").and_then(Value::as_str).unwrap();
-        assert_eq!(text, "payload");
-        assert!(!text.contains('\r'), "text must NOT carry a submit \\r");
-        // The submit is a discrete enter keypress, after the text.
-        let enters = cmds.iter().filter(|c| c.get("key").and_then(Value::as_str) == Some("enter")).count();
-        assert_eq!(enters, 1, "exactly one enter key (the submit)");
-        // ...and it comes AFTER the text command.
-        let text_idx = cmds.iter().position(|c| c.get("text").is_some()).unwrap();
-        let enter_idx = cmds.iter().position(|c| c.get("key").and_then(Value::as_str) == Some("enter")).unwrap();
-        assert!(enter_idx > text_idx, "the enter submit must follow the text");
-    }
-
-    #[test]
-    fn stash_precedes_the_submit() {
-        let cmds = commands_for_event("x");
-        // ctrl+s (stash) is FIRST; the text is cmds[2]; enter submits; the {commit} terminator is last.
-        assert_eq!(cmds.first().unwrap().get("key").and_then(Value::as_str), Some("ctrl+s"));
-        assert!(cmds[2].get("text").is_some());
-        assert_eq!(cmds.len(), 6);
-    }
-
-    #[test]
-    fn raw_newlines_in_envelope_are_neutralized() {
-        // A stray CR/LF must not split or corrupt the injection — only the discrete enter submits.
-        // A non-envelope payload collapses embedded newlines to spaces and stays single-line.
-        let cmds = commands_for_event("a\nb\r\nc");
-        let text = cmds[2].get("text").and_then(Value::as_str).unwrap();
-        assert_eq!(text, "a b  c");
-        assert_eq!(text.matches('\r').count(), 0, "no raw CR survives");
-        assert_eq!(text.matches('\n').count(), 0, "no raw LF survives");
-    }
-
-    #[test]
-    fn stray_newlines_neutralized_then_only_framing_newlines_remain() {
-        // STRAY CR/LF inside a real envelope collapse to spaces FIRST; then framing re-inserts
-        // EXACTLY the two deliberate structural newlines. No stray newline can split the injection.
-        let cmds = commands_for_event("<EVENT type=\"msg\">a\nb\r\nc</EVENT>");
-        let text = cmds[2].get("text").and_then(Value::as_str).unwrap();
-        assert_eq!(text, "<EVENT type=\"msg\">\na b  c\n</EVENT>");
-        assert_eq!(text.matches('\r').count(), 0, "no raw CR survives");
-        assert_eq!(text.matches('\n').count(), 2, "only the two framing newlines survive");
-    }
-
-    /// Build an EVENT envelope carrying a `json` attr whose value is the XML-attr-escaped form of
-    /// `obj` — mirrors what spt-core composes from `spt send --json-payload`.
-    fn envelope_with_json(obj: &str) -> String {
-        let escaped = obj
-            .replace('&', "&amp;")
-            .replace('<', "&lt;")
-            .replace('>', "&gt;")
-            .replace('"', "&quot;");
-        format!("<EVENT type=\"msg\" from=\"self\" json=\"{escaped}\">checkpoint</EVENT>")
-    }
-
-    // [unit->REQ-HAZARD-CHECKPOINT-CLEAR-RACE]
-    #[test]
-    fn checkpoint_arms_wake_and_emits_clear_only() {
-        // A {"checkpoint":"v1",…} envelope ARMS the wake in pending_wake and emits CLEAR-ONLY — the
-        // wake is NOT in this sequence (it fires later, after /clear completes).
-        let env = envelope_with_json(r#"{"checkpoint":"v1","wake":"Resume T2c now"}"#);
-        let mut pending = Pending::default();
-        let cmds = dispatch_event(&mut pending, &env);
-        assert_eq!(
-            keys(&cmds),
-            vec![
-                "key:ctrl+s".to_string(),
-                "delay:50".to_string(),
-                "text:/clear".to_string(),
-                "delay:50".to_string(), // text→enter settle: the enter must be a discrete submit, not a soft newline
-                "key:enter".to_string(),
-                "commit".to_string(),
-            ]
-        );
-        assert_eq!(pending.wake.as_deref(), Some("Resume T2c now"), "wake armed, not emitted");
-        // The wake text never appears in the clear sequence.
-        assert!(!cmds.iter().any(|c| c.get("text").and_then(Value::as_str) == Some("Resume T2c now")));
-    }
-
-    // [unit->REQ-HAZARD-CHECKPOINT-CLEAR-RACE]
-    #[test]
-    fn fire_emits_wake_only_and_disarms() {
-        // With ONLY a wake pending (no rename stashed), the fire emits the wake half alone.
-        let mut pending = Pending { wake: Some("go now".to_string()), ..Default::default() };
-        let fire = envelope_with_json(r#"{"checkpoint_fire":"v1"}"#);
-        let cmds = dispatch_event(&mut pending, &fire);
-        assert_eq!(
-            keys(&cmds),
-            vec![
-                "key:ctrl+s".to_string(),
-                "delay:50".to_string(),
-                "text:go now".to_string(),
-                "delay:50".to_string(), // text->enter settle: field-required for a paragraph-length wake (2026-07-04)
-                "key:enter".to_string(),
-                "commit".to_string(),
-            ]
-        );
-        assert!(pending.wake.is_none(), "wake drained after fire");
-    }
-
-    // [unit->REQ-HAZARD-EMPTY-RESPONSE-COMMIT]
-    #[test]
-    fn fire_with_nothing_pending_answers_a_bare_commit() {
-        // The hook fires {"checkpoint_fire"} on EVERY clear; with nothing pending the delivery is a
-        // no-op — but it must still terminate its inject sequence with a bare {commit}. A zero-record
-        // answer leaves the sequence unterminated -> 5s deadline -> the broker FAULTS + TERMINATES
-        // this binary (the every-clear kill pinned 2026-07-04).
-        let mut pending = Pending::default();
-        let fire = envelope_with_json(r#"{"checkpoint_fire":"v1"}"#);
-        let cmds = dispatch_event(&mut pending, &fire);
-        assert_eq!(keys(&cmds), vec!["commit".to_string()], "bare {{commit}}, no keys/text");
-    }
-
-    // [unit->REQ-DIST-BOUNDARY-RENAME]
-    #[test]
-    fn rename_stashes_and_answers_a_bare_commit() {
-        // The rename delivery emits NOTHING of its own — the name is stashed and rides the fire's
-        // combined sequence (two back-to-back sequences raced: flynn 2026-07-06 blend). The delivery
-        // still opened an inject sequence broker-side, so it answers the mandatory bare {commit}.
-        let mut pending = Pending::default();
-        let env = envelope_with_json(r#"{"rename":"v1","name":"perri @ NODE (proj/)"}"#);
-        let cmds = dispatch_event(&mut pending, &env);
-        assert_eq!(keys(&cmds), vec!["commit".to_string()], "stash-only: no keystrokes");
-        assert_eq!(pending.rename.as_deref(), Some("perri @ NODE (proj/)"), "name stashed");
-        assert!(pending.wake.is_none());
-    }
-
-    // [unit->REQ-DIST-BOUNDARY-RENAME]
-    #[test]
-    fn fire_after_rename_only_emits_the_rename_half() {
-        // A non-checkpoint /clear: rename stashed, no wake armed — the fire emits the rename half
-        // alone (same 6-record shape the standalone rename sequence had).
-        let mut pending = Pending { rename: Some("perri @ NODE (proj/)".to_string()), ..Default::default() };
-        let cmds = dispatch_event(&mut pending, &envelope_with_json(r#"{"checkpoint_fire":"v1"}"#));
-        assert_eq!(
-            keys(&cmds),
-            vec![
-                "key:ctrl+s".to_string(),
-                "delay:50".to_string(),
-                "text:/rename perri @ NODE (proj/)".to_string(),
-                "delay:50".to_string(),
-                "key:enter".to_string(),
-                "commit".to_string(),
-            ]
-        );
-        assert!(pending.rename.is_none(), "rename drained by the fire");
-    }
-
-    // [unit->REQ-DIST-BOUNDARY-RENAME] [unit->REQ-HAZARD-CHECKPOINT-CLEAR-RACE]
-    #[test]
-    fn checkpoint_boundary_is_one_combined_sequence_rename_then_wake() {
-        // THE 2026-07-06 REGRESSION (flynn): rename + wake must ride ONE inject sequence — rename
-        // half, enter->ctrl+s bridge, wake half, ONE commit. Two back-to-back sequences raced at the
-        // post-clear boundary and the wake text submitted INSIDE the /rename argument (session
-        // titled with the wake, no wake turn, agent dormant ~9.5h).
-        let mut pending = Pending::default();
-        dispatch_event(&mut pending, &envelope_with_json(r#"{"checkpoint":"v1","wake":"do the thing"}"#));
-        assert_eq!(pending.wake.as_deref(), Some("do the thing"), "armed");
-        let rn_cmds = dispatch_event(&mut pending, &envelope_with_json(r#"{"rename":"v1","name":"x @ y"}"#));
-        assert_eq!(keys(&rn_cmds), vec!["commit".to_string()], "rename delivery emits nothing");
-        assert_eq!(pending.wake.as_deref(), Some("do the thing"), "stash must not disturb the armed wake");
-        let cmds = dispatch_event(&mut pending, &envelope_with_json(r#"{"checkpoint_fire":"v1"}"#));
-        assert_eq!(
-            keys(&cmds),
-            vec![
-                "key:ctrl+s".to_string(),
-                "delay:50".to_string(),
-                "text:/rename x @ y".to_string(),
-                "delay:50".to_string(),
-                "key:enter".to_string(),  // rename submits...
-                "delay:150".to_string(),  // ...then the enter->ctrl+s bridge (BOUNDARY_BRIDGE_MS)
-                "key:ctrl+s".to_string(), // stash any residue (incl. a coalesced rename)
-                "delay:50".to_string(),
-                "text:do the thing".to_string(),
-                "delay:50".to_string(),
-                "key:enter".to_string(), // wake submits — the first post-checkpoint turn
-                "commit".to_string(),    // exactly ONE terminator
-            ]
-        );
-        assert!(pending.wake.is_none() && pending.rename.is_none(), "both drained");
-        assert_eq!(cmds.iter().filter(|c| c.get("commit").is_some()).count(), 1);
-        assert!(cmds.last().unwrap().get("commit").is_some());
-    }
-
-    // [unit->REQ-DIST-BOUNDARY-RENAME] [unit->REQ-HAZARD-EMPTY-RESPONSE-COMMIT]
-    #[test]
-    fn rename_with_blank_name_stashes_nothing() {
-        // A rename marker with a blank/absent name stashes nothing (never a stray `/rename `
-        // submit) and still answers the mandatory bare {commit}; the following fire is then a
-        // no-op bare {commit} too (nothing pending).
-        let mut pending = Pending::default();
-        for obj in [r#"{"rename":"v1","name":"  "}"#, r#"{"rename":"v1"}"#] {
-            let cmds = dispatch_event(&mut pending, &envelope_with_json(obj));
-            assert_eq!(keys(&cmds), vec!["commit".to_string()], "bare commit for {obj}");
-            assert!(pending.rename.is_none(), "nothing stashed for {obj}");
-        }
-        let cmds = dispatch_event(&mut pending, &envelope_with_json(r#"{"checkpoint_fire":"v1"}"#));
-        assert_eq!(keys(&cmds), vec!["commit".to_string()]);
-    }
-
-    // [unit->REQ-DIST-BOUNDARY-RENAME]
-    #[test]
-    fn rename_name_newlines_collapse_to_spaces() {
-        // Stray CR/LF in a name can never split the injection — same guard as the wake text.
-        let mut pending = Pending::default();
-        dispatch_event(&mut pending, &envelope_with_json("{\"rename\":\"v1\",\"name\":\"a\\nb\\r\\nc\"}"));
-        let cmds = dispatch_event(&mut pending, &envelope_with_json(r#"{"checkpoint_fire":"v1"}"#));
-        let text = cmds[2].get("text").and_then(Value::as_str).unwrap();
-        assert_eq!(text, "/rename a b  c");
-    }
-
-    // [unit->REQ-DIST-BOUNDARY-RENAME]
-    #[test]
-    fn normal_delivery_never_fires_rename() {
-        // A normal message body mentioning rename can't forge the marker (it lives in the json
-        // attr) — delivery stays the standard multi-line envelope path, nothing stashed.
-        let mut pending = Pending::default();
-        let cmds = dispatch_event(&mut pending, "<EVENT type=\"msg\" from=\"x\">please rename v1 this</EVENT>");
-        assert!(
-            !cmds.iter().any(|c| c.get("text").and_then(Value::as_str).is_some_and(|t| t.starts_with("/rename"))),
-            "body text must not trigger the rename branch"
-        );
-        assert!(pending.rename.is_none());
-    }
-
-    // [unit->REQ-HAZARD-EMPTY-RESPONSE-COMMIT]
-    #[test]
-    fn event_without_envelope_answers_a_bare_commit() {
-        // An event-typed line with no envelope has nothing to deliver, but it still opened an inject
-        // sequence broker-side — a bare {commit} terminates it instead of faulting at the deadline.
-        let mut pending = Pending::default();
-        let cmds = dispatch_line(&mut pending, &serde_json::json!({ "type": "event" }));
-        assert_eq!(keys(&cmds), vec!["commit".to_string()]);
-    }
-
-    // [unit->REQ-HAZARD-EMPTY-RESPONSE-COMMIT]
-    #[test]
-    fn non_event_lines_stay_silent_no_stray_commit() {
-        // init/input/unknown are stdin protocol lines, NOT inject deliveries — an unsolicited
-        // {commit} outside a sequence is protocol noise. They must emit NOTHING.
-        let mut pending = Pending::default();
-        for line in [
-            serde_json::json!({ "type": "init" }),
-            serde_json::json!({ "type": "input", "text": "operator typing" }),
-            serde_json::json!({ "type": "mystery" }),
-            serde_json::json!({ "no_type": true }),
-        ] {
-            assert!(dispatch_line(&mut pending, &line).is_empty(), "must stay silent: {line}");
-        }
-    }
-
-    // [unit->REQ-HAZARD-CHECKPOINT-CLEAR-RACE]
-    #[test]
-    fn arm_then_fire_orders_clear_before_wake() {
-        // End-to-end ordering on ONE persistent pending_wake: arm emits clear (no wake), then a later
-        // fire emits the wake (no clear) — the wake can never precede the clear.
-        let mut pending = Pending::default();
-        let arm = envelope_with_json(r#"{"checkpoint":"v1","wake":"do the thing"}"#);
-        let clear_cmds = dispatch_event(&mut pending, &arm);
-        let fire = envelope_with_json(r#"{"checkpoint_fire":"v1"}"#);
-        let wake_cmds = dispatch_event(&mut pending, &fire);
-        // Clear sequence types "/clear" and NOT the wake; wake sequence types the wake and NOT "/clear".
-        let clear_texts: Vec<&str> = clear_cmds.iter().filter_map(|c| c.get("text").and_then(Value::as_str)).collect();
-        let wake_texts: Vec<&str> = wake_cmds.iter().filter_map(|c| c.get("text").and_then(Value::as_str)).collect();
-        assert_eq!(clear_texts, vec!["/clear"]);
-        assert_eq!(wake_texts, vec!["do the thing"]);
-    }
-
-    // [unit->REQ-HAZARD-CHECKPOINT-CLEAR-RACE]
-    #[test]
-    fn arm_supersedes_a_previously_armed_wake() {
-        // At most one pending wake — a fresh checkpoint replaces a stale one.
-        let mut pending = Pending { wake: Some("stale".to_string()), ..Default::default() };
-        let arm = envelope_with_json(r#"{"checkpoint":"v1","wake":"fresh"}"#);
-        dispatch_event(&mut pending, &arm);
-        assert_eq!(pending.wake.as_deref(), Some("fresh"));
-    }
-
-    // [unit->REQ-DIST-CHECKPOINT-COMMUNE]
-    #[test]
-    fn checkpoint_without_wake_arms_the_default() {
-        let mut pending = Pending::default();
-        dispatch_event(&mut pending, &envelope_with_json(r#"{"checkpoint":"v1"}"#));
-        assert_eq!(pending.wake.as_deref(), Some("Proceed with next steps"));
-        // Blank wake also falls back to the default.
-        let mut pending2 = Pending::default();
-        dispatch_event(&mut pending2, &envelope_with_json(r#"{"checkpoint":"v1","wake":"   "}"#));
-        assert_eq!(pending2.wake.as_deref(), Some("Proceed with next steps"));
-    }
-
-    // [unit->REQ-HAZARD-CHECKPOINT-CLEAR-RACE]
-    #[test]
-    fn non_checkpoint_envelopes_deliver_normally() {
-        // A different marker, a plain message, and a body that merely MENTIONS the token all deliver
-        // normally (collision-proof: the marker only counts inside a structured json attr). None arm.
-        for env in [
-            envelope_with_json(r#"{"checkpoint":"v2"}"#),
-            envelope_with_json(r#"{"note":"hi"}"#),
-            "<EVENT type=\"msg\" from=\"a\">please run a checkpoint v1</EVENT>".to_string(),
-            "<EVENT type=\"msg\" from=\"a\">hi</EVENT>".to_string(),
-        ] {
-            let mut pending = Pending::default();
-            let cmds = dispatch_event(&mut pending, &env);
-            // Normal delivery is the 6-step choreography ending text-then-enter-then-commit — it never
-            // types "/clear" and never arms a wake.
-            assert_eq!(cmds.len(), 6, "normal delivery for: {env}");
-            assert!(
-                !cmds.iter().any(|c| c.get("text").and_then(Value::as_str) == Some("/clear")),
-                "must NOT clear for: {env}"
-            );
-            assert!(pending.wake.is_none(), "must NOT arm for: {env}");
-        }
-    }
-
-    // [unit->REQ-HAZARD-CHECKPOINT-CLEAR-RACE]
-    #[test]
-    fn malformed_checkpoint_json_falls_through_to_normal_delivery() {
-        // A json attr that isn't valid JSON must not panic, arm, or macro — degrade to normal delivery.
-        let mut pending = Pending::default();
-        let env = "<EVENT type=\"msg\" from=\"a\" json=\"{not valid json\">b</EVENT>";
-        let cmds = dispatch_event(&mut pending, env);
-        assert_eq!(cmds.len(), 6);
-        assert!(!cmds.iter().any(|c| c.get("text").and_then(Value::as_str) == Some("/clear")));
-        assert!(pending.wake.is_none());
-    }
-
-    #[test]
-    fn xml_attr_unescape_decodes_amp_last() {
-        // &amp;quot; must decode to &quot; (one level), not "" — &amp; is applied LAST.
-        assert_eq!(xml_attr_unescape("&amp;quot;"), "&quot;");
-        assert_eq!(xml_attr_unescape("&quot;&lt;&gt;&amp;"), "\"<>&");
-    }
-
-    #[test]
-    fn extract_json_attr_pulls_the_attr_value() {
-        let env = "<EVENT type=\"msg\" from=\"a\" json=\"&quot;v&quot;\">b</EVENT>";
-        assert_eq!(extract_json_attr(env).as_deref(), Some("&quot;v&quot;"));
-        // No json attr → None.
-        assert_eq!(extract_json_attr("<EVENT type=\"msg\">b</EVENT>"), None);
-    }
-
-    #[test]
-    fn event_dispatch_via_line() {
-        let v: Value = serde_json::from_str(
-            r#"{"type":"event","envelope":"<EVENT type=\"msg\" from=\"a\">b</EVENT>"}"#,
-        )
-        .unwrap();
-        let mut pending = Pending::default();
-        let cmds = dispatch_line(&mut pending, &v);
-        assert_eq!(cmds.len(), 6);
-        assert_eq!(cmds[0].get("key").and_then(Value::as_str), Some("ctrl+s"));
-    }
-
-    #[test]
-    fn init_and_input_and_unknown_types_emit_nothing() {
-        let mut pending = Pending::default();
-        for line in [
-            r#"{"type":"init","endpoint_id":"perri","node":"HFENDULEAM"}"#,
-            r#"{"type":"input"}"#,
-            r#"{"type":"future-thing","x":1}"#,
-            r#"{"no_type":true}"#,
-        ] {
-            let v: Value = serde_json::from_str(line).unwrap();
-            assert!(dispatch_line(&mut pending, &v).is_empty(), "no output for: {line}");
-        }
-    }
-
-    #[test]
-    fn unknown_fields_are_ignored_forward_compat() {
-        // A newer spt-core adding fields must not break dispatch (unknown keys ignored).
-        let v: Value = serde_json::from_str(
-            r#"{"type":"event","envelope":"<EVENT>z</EVENT>","priority":9,"trace_id":"t"}"#,
-        )
-        .unwrap();
-        let mut pending = Pending::default();
-        assert_eq!(dispatch_line(&mut pending, &v).len(), 6);
-    }
-
-    #[test]
-    fn output_commands_are_single_field_objects() {
-        // Each emitted command is exactly one of the contract shapes (key | delay_ms | text | commit).
-        for c in commands_for_event("m") {
-            let obj = c.as_object().unwrap();
-            assert_eq!(obj.len(), 1, "each command carries exactly one field: {c}");
-            let k = obj.keys().next().unwrap().as_str();
-            assert!(matches!(k, "key" | "delay_ms" | "text" | "commit"), "unexpected field {k}");
-        }
-    }
-}
diff --git a/traceable-reqs.toml b/traceable-reqs.toml
index 430cf75..6287376 100644
--- a/traceable-reqs.toml
+++ b/traceable-reqs.toml
@@ -1,480 +1,121 @@
-# traceable-reqs manifest for spt-claude-code — SEED.
-#
-# Authoritative requirement registry: every requirement and every KNOWN-HAZARDS
-# invariant lives here as a REQ-* id (see docs/TRACEABILITY.md for the full contract).
-#
-# SEED YOUR REQs FROM SCOPE.md "Parity-trim" — the DROP / TRANSFORM / KEEP / ADD buckets are
-# the parity reference. Mint a REQ-* per surface you port/transform/add as you START each
-# milestone (NOT up front). The registry below is intentionally EMPTY (commented shapes only).
-#
-# ACQUIRE the CLI (it is a released binary, not a crate dependency):
-#   gh release download --repo BigscreenVR/traceable-reqs \
-#     --pattern '*<your-platform>' --output traceable-reqs   # then chmod +x
-# (see INSTANTIATE.md for per-platform patterns + CI wiring.) Validate this seed against
-# the installed CLI before relying on it: `traceable-reqs check`.
-#
-# THE FOUR-STAGE CONTRACT: every requirement is traced from
-#   doc  (prose/design)  ->  impl (production code)  ->  unit (unit test)  ->  int (cross-process/node)
-# Tag evidence in the SAME commit, on/above the real evidence:
-#   // [impl->REQ-FOO]   // [unit->REQ-FOO]   <!-- [doc->REQ-FOO] -->
-#
-# ACTIVATION MODEL: every requirement starts inactive (`required_stages = []`) so `check`
-# stays green pre-code. A milestone ACTIVATES its requirements by setting their real
-# `required_stages` when work on them begins. Deferred items stay [] until promoted.
-# Never declare the full end-state stage list up front — activate incrementally as evidence
-# lands (add "int" at the final integrating wave).
+# OMP-native requirement registry. Evidence roots are intentionally limited to
+# the retained adapter surface; retired foreign-harness files are not scanned.
 
 [scan]
-# Every evidence location. A missing root makes evidence SILENTLY vanish from the trace —
-# audit this whenever a new evidence dir appears. ADD `plugin`, `skills`, `hooks`, `tests`
-# the moment those dirs are created (skeleton milestone, body #2) — until they exist a
-# nonexistent root is a hard manifest_error, so only list what is on disk now.
-roots = ["plugin", "ci", "ci/acceptance", "ci/publish", "ci/docs", "ci/manifest", "ci/digest", "ci/idle-translate", "adapter", "tools", "tests", "docs", "docs-site", "CONTEXT.md", "SCOPE.md", "AGENTS.md", "HANDOFF.md", "README.md"]
+roots = [
+  "OMP-ADAPTER-PLAN.md",
+  "docs/KNOWN-HAZARDS.md",
+  "docs/adr/0007-native-omp-tui-hosts-spt-extension.md",
+  "docs/adr/0008-omp-native-product-boundary.md",
+  "docs/adr/0009-all-endpoints-use-native-omp.md",
+  "docs/adr/0010-native-delivery-self-heals-or-closes.md",
+  "docs/adr/0011-endpoint-session-binding-is-immutable.md",
+  "docs/adr/0012-continuity-drops-live-under-spt.md",
+  "docs/adr/0013-release-gate-stops-at-the-adapter-boundary.md",
+  "adapter/omp-spt.toml",
+  "adapter/strings/omp-spt.mjs",
+  "tools/omp-spt/Cargo.toml",
+  "tools/omp-spt/src/main.rs",
+  "tools/omp-spt/src/digest_omp.rs",
+  "tools/omp-spt/src/history_omp.rs",
+  "tools/omp-spt/src/echo_commune_omp.rs",
+  "tools/omp-spt/src/psyche_omp.rs",
+  "tools/omp-spt/src/launch_omp.rs",
+  "tools/omp-spt/tests/launch_omp.rs",
+  "tests/manifest-shortcut.sh",
+  "tests/native-launch-manifest.sh",
+  "tests/omp-extension.mjs",
+  "tests/manifest-schema.sh",
+  "tests/adapter-archive.sh",
+  "ci/manifest/check-manifest.sh",
+  "ci/manifest/validate_manifest.py",
+  "ci/publish/package-adapter.sh",
+  "ci/publish/release-acquire-int.sh",
+  "ci/digest/build.sh",
+  "ci/digest/digest-proof-int.sh",
+]
 
 [policy]
-# Default policy applied at activation: doc + impl + unit. Networking/lifecycle/cross-node
-# reqs add "int". Until a req is activated, its per-req `required_stages = []` keeps it out
-# of the coverage gate.
 required_stages = []
 
-# ───────────────────────────── Requirements ─────────────────────────────────
-# Add requirements as you scope milestones, seeded from SCOPE.md "Parity-trim". Shape:
-#
-# [[requirements]]
-# id = "REQ-EXAMPLE-1"
-# title = "One-line statement of the requirement"
-# required_stages = []  # activate (e.g. ["doc","impl","unit"]) when the milestone starts
-#
-# KNOWN-HAZARDS invariants are first-class requirements — one REQ-HAZARD-* per invariant,
-# each requiring at least "unit" (add "int" where cross-process/cross-node):
-#
-# [[requirements]]
-# id = "REQ-HAZARD-EXAMPLE"
-# title = "The invariant, stated so a test can prove it"
-# required_stages = []
-
-# ── Milestone: SKELETON (thin cplugs plugin) — minted at kickoff, per-milestone (not
-# the whole registry up front). All inactive (required_stages = []) so `check` stays
-# green until body #2 lands evidence and flips each to ["doc"] / ["doc","impl"] etc.
-# Seeded from SCOPE.md "Parity-trim" (Distribution + ADD buckets).
-
-[[requirements]]
-id = "REQ-DIST-PLUGIN-SKELETON"
-title = "Marketplace artifact on cplugs is a thin skeleton: namespaced /sptc:* skill stubs + hooks.json + plugin.json, no embedded logic"
-required_stages = ["doc", "impl", "unit"]  # doc: ADR-0001 + RELEASE-RUNBOOK. impl: ci/publish/{validate,package}-skeleton.sh (installability gate + publish mechanic). unit: tests/skeleton-validate.sh (pass real + fail tampered).
-
-[[requirements]]
-id = "REQ-DIST-BOOTSTRAP-INSTALL"
-title = "SessionStart bootstrap installs spt-core when absent (invisible-installer pattern)"
-required_stages = ["doc", "impl"]  # doc: ADR-0001. impl: plugin/sptc/bootstrap.{sh,ps1}.
-
-[[requirements]]
-id = "REQ-DIST-HOOKS-API"
-title = "hooks.json delegates to `spt api` rather than carrying adapter logic"
-required_stages = ["doc", "impl", "unit", "int"]  # doc: ADR-0001/0002. impl: hooks.json + wrappers. unit: tests/hooks-parse.sh. int: ci/hooks/poll-int.sh — `spt api poll` on live v0.7.1 emits the canonical <EVENT> envelope, confirm-matched through render_frames; __REPLY_TO__ relic gone, multi-drain splits on </EVENT>. 5/5 green 2026-06-15 (throwaway perch, torn down).
-
-[[requirements]]
-id = "REQ-DIST-HOOK-BINARY"
-title = "Hook LOGIC lives in the consolidated `claude-spt hook <event>` binary (so it rides `spt adapter update`, not a cplugs republish); the plugin ships only a static-forever hooks.json + dispatch wrapper that resolves the binary via the lazily-substituted `[strings].hook_cmd = {adapter_dir}/claude-spt hook` (ADR-0006 ask #1 → resolve-not-execute; spt-core v0.16.0 {adapter_dir} + lazy [strings] subst). D1 / v0.9.0."
-required_stages = ["doc", "impl", "unit"]  # D1 — ACTIVATED 2026-06-28. doc: ADR-0006 (binary consolidation + ask#1 resolution) + UPDATE-NAMING-DOYLE-ASKS Ask 1 + V09-PLAN. impl: tools/claude-spt/src/hook.rs (the `hook <event>` subcommand — faithful port of the 8 wrappers + _common.sh) + main.rs Sub::Hook dispatch + plugin/sptc/hooks/dispatch.sh (static-forever resolve+exec, bootstrap-on-session-start, $SPTC_HOOK_BIN cache, --host-pid) + plugin/sptc/hooks/hooks.json (every event -> dispatch.sh <event>) + adapter/claude-spt.toml [strings].hook_cmd. unit: hook.rs #[cfg(test)] (json field parse, render_frames <EVENT>, unescape &amp;-last, skill_key, register_verb, cap/spill, checkpoint detect/wake, brief assemble + {id} subst + is_subagent + peer-gate + json_escape + emit shape; per-event command-line + stdout-contract construction) + tests/hooks-dispatch.sh (hooks.json static shape: every CC event routed to dispatch.sh; dispatch sh -n; referenced wrappers exist). Both {adapter_dir} + lazy-[strings] primitives empirically verified on live spt 0.16.0 (probe-d1, 2026-06-28). int DEFERRED (same harness-glue E2E bucket as the other deferred ints): a real CC session with the v0.9.0 plugin + registered adapter resolving `hook_cmd` and the binary firing each hook — needs the new plugin installed on a real-CC node.
-
-[[requirements]]
-id = "REQ-DIST-MANIFEST-SCHEMA"
-title = "CC adapter manifest validates against spt-core's published manifest.schema.json (from spt-releases)"
-required_stages = ["doc", "impl", "unit", "int"]  # doc: ADR-0001 (manifest layer + version-of-truth). impl: adapter/claude-spt.toml + vendored adapter/manifest.schema.json + ci/manifest/{validate_manifest.py,check-manifest.sh} (gate). unit: tests/manifest-schema.sh (pass real + fail tampered). int: ci/manifest/registration-int.sh — real `spt adapter add` (v0.7.0) cross-field registration-validation accepted the manifest, shipped profile resolved, [strings] read + overlay observable; 6/6 green 2026-06-15 (registry left clean via soft-remove). Cross-field discovery: [digest] requires source-or-[history].locate_template (not in JSON schema) — fixed with source="{home}/.claude/projects".
-
-[[requirements]]
-id = "REQ-DIST-SHORTCUT-BASENAME"
-title = "The adapter manifest brands the `spt endpoint run` launcher shortcut as `cc-<id>` via adapter.shortcut_basename = \"cc\" (the M12 cc launcher; decoupled from the sptc plugin name, ADR-0001)"
-required_stages = ["doc", "impl", "unit"]  # doc: ADR-0001 (cc launcher brand, decoupled from the s/sptc/spt/ plugin-name succession). impl: the cc-launcher BRINGUP machinery — adapter [session.self] (spawns `claude`) + [env.SPT_ENDPOINT_ID] (broker injects the endpoint id) + the SessionStart bind branch (sptc_register_verb -> `api bind`, the spt-hosted self-register path). unit: tests/manifest-shortcut.sh (brand-value guard) + tests/hooks-parse.sh sptc_register_verb (bind/seed/boundary branch). int (real `spt endpoint run` picker emits cc-<id> + real-claude bringup-bind) deferred — the shortcut-emitting picker "lands in a later spt-core wave" (per `endpoint run --help`); the bringup-bind is now contract-unblocked (doyle confirmed 2026-06-15: bind is establishing/intrinsic-auth, --set-session-id only, no token) but still needs a real-claude acceptance spawn (heavier tier). adapter add accepting the [session.self]/[env] blocks is covered by registration-int.sh step 4d (REQ-DIST-MANIFEST-SCHEMA int).
-
-[[requirements]]
-id = "REQ-CC-LAUNCHER-BIND"
-title = "spt-hosted bringup self-binds E2E: `spt endpoint run claude-spt <id>` spawns the [session.self] CC session which — via [env.SPT_ENDPOINT_ID]={id} (spt-core fills it, v0.11.0+ REQ-HAZARD-ENV-SUBST/F-013) + the SessionStart `bind` branch — registers a BOUND perch on disk reachable by `spt send` (live PTY inject, SENT). The M12 cc-launcher reachability, the gap that hid the wall-b zero-perch."
-required_stages = ["int"]  # doc (ADR-0001 cc-launcher) + impl (adapter [session.self] + [env.SPT_ENDPOINT_ID] + session-start.sh `bind` branch) + unit (tests/hooks-parse.sh sptc_register_verb bind) are owned by REQ-DIST-SHORTCUT-BASENAME; this REQ owns the now-unblocked real-claude bringup-bind INT (its sibling, the picker `cc-<id>` emission, stays deferred under REQ-DIST-SHORTCUT-BASENAME — a later spt-core wave). int: ci/launcher/bind-int.sh — real `spt endpoint run --adapter claude-spt --id <disp> --start` on spt >=0.11.0 → SessionStart fills SPT_ENDPOINT_ID + BINDS → owlery/<disp> bound perch on disk (info.json + ready) → `spt send <disp>` reaches it (SENT live PTY inject, REQ-SEND-SPT-HOSTED; QUEUED accepted) → full teardown. Was F-013-blocked (endpoint run did not substitute [env].value="{id}" → seed-not-bind → zero perch = the operator's wall-b NO_PERCH); doyle's v0.11.0 REQ-HAZARD-ENV-SUBST fix unblocked it. GREEN 2026-06-17 (disposable id, REQ-HAZARD-PERCH-COLLISION; box left clean). Self-gates SKIP on spt <0.11.0 / no SPTC_ACCEPTANCE. NB the spt-hosted bind path requires spt >=0.11.0 to bind (silently seeds on older) — manifest min_spt_core stays 0.9.0 for the ready/live flows; 0.11.0-floor-bump for the endpoint-run path is a flagged scope question, not yet taken.
-
-[[requirements]]
-id = "REQ-DIST-DIGEST-EXTRACTOR"
-title = "The claude-spt [digest] extractor (claude-spt-digest) maps Claude Code's JSONL transcript to the published digest-record NDJSON contract (role∈{input,agent,tool}; text/tool/ts), emitting RAW records for spt-core's renderer"
-required_stages = ["impl", "unit", "int"]  # impl: tools/claude-spt-digest (Rust — CC JSONL -> digest NDJSON; per-session locate of <slug>/<session_id>.jsonl under the projects root via the {session_id} the command receives; native UTF-8 stdout; defensive ~ expansion) + ci/digest/build.sh gate. unit: the crate's cargo tests (9: input/agent/tool mapping, arg-key preference, thinking+tool_result+noise+bad-json drops, UTF-8 round-trip, contract invariants, tilde expansion) run by ci/digest/build.sh. int: ci/digest/digest-proof-int.sh — `spt adapter digest-proof claude-spt --sample` on live v0.7.2 ran the published-shape extractor command (`--session {session_id} --in {source}`) and rendered DIGEST_PROOF_OK (5 parsed / 0 dropped). GREEN 2026-06-15 (registry left clean via soft-remove). Was F-004-blocked (digest-proof --sample passed an empty substitution-key map, cli.rs:5135) — doyle's spt-core PR#14 fix (v0.7.2, release counter 14) now fills {id}+{session_id} + an optional --session, matching runtime. doc deferred (the mapping is documented in the module + manifest [digest] comment; a docs-site section lands with the doc slice).
-
-[[requirements]]
-id = "REQ-DIST-DIGEST-FETCHER"
-title = "The [digest] seam runs under strategy=\"fetcher\" (spt-core v0.19.0, #17): the extractor IS the locator — `claude-spt digest --session {session_id} --config-dir {CLAUDE_CONFIG_DIR}` locates <config-root>/projects/<cwd-slug>/<session_id>.jsonl itself (no spt-core pre-read, no `source`, no harness slug in the catalog); the NEW [env.CLAUDE_CONFIG_DIR] direction=\"read\" capture (bind-time env → info.json.read_env → fill → ~expand, value=\"~/.claude\" fallback) delivers the ccs-relocated tree to the extractor in the DAEMON's context — the pre-0.19.0 inherited-env preference stays as the next precedence rung"
-required_stages = ["impl", "unit", "int"]  # impl: adapter/claude-spt.toml [digest] strategy="fetcher" + [env.CLAUDE_CONFIG_DIR] (declaration; .toml unscanned so the scannable impl is the extractor's locator chain: tools/claude-spt/src/digest.rs resolve_projects_root + --config-dir parse). unit: digest.rs cargo tests (config-dir parse, precedence config-dir→env→--in→~/.claude default, empty-capture guard) via ci/digest/build.sh. int: `spt adapter digest-proof claude-spt` on the live 0.19.0 binary running the fetcher-shape command (locate-in-tree, not --sample pre-read) — GREEN gates the v0.10.0 ship. doc deferred to the docs-site harness-contract slice (mirrors REQ-DIST-DIGEST-EXTRACTOR's precedent; the seam is documented in the manifest [digest]/[env] comments meanwhile).
-
-[[requirements]]
-id = "REQ-DIST-WHOAMI-JSON"
-title = "The hook binary resolves its own perch id ONLY from `spt whoami --json` (.self.id; self:null ⇒ no-perch; any parse failure ⇒ empty) — NEVER from a line of the human view, whose first line is a `SUBNET <name>` roster header on any subnet-member node (the doyle bug 2026-07-01: SessionStart crowned an agent \"SUBNET SPT_DEV\" and the brief's don't-run-whoami instruction made the wrong identity self-reinforce through an orchestration round)"
-required_stages = ["impl", "unit"]  # impl: tools/claude-spt/src/hook.rs self_id + parse_whoami_self (pure over the output string). unit: whoami_human_roster_is_never_an_id (the load-bearing regression — grouped-roster input resolves EMPTY, perched human `SELF:` line too) + whoami_json_self_id_contract (id/null/garbage/missing-key). Live validation on this node (2-subnet repro per doyle's check): disposable perch → real hook binary → banner id = perch id. `--json` is a v0.16.0 global flag — below our 0.19.0 floor everywhere, no version gate needed. int deferred: the SessionStart banner assertion rides the next hooks-int touch (poll-int.sh exercises self_id incidentally via the binary confirm-match).
-
 [[requirements]]
-id = "REQ-SKILL-LIVE"
-title = "/sptc:live upgrades THIS CC session to a LiveAgent: base claude-spt is live-capable ([session.psyche_init] in the BASE manifest, Option A) so ready-vs-live is the COMMAND not a profile — bare `spt api listen <id>` stamps the perch state=live_agent and the daemon hosts the Psyche (poll stays ready, livehost.rs:282 gate); the claude-spt-psyche runner keeps the Psyche claude alive (one --continue turn per pulse, NOT one-shot `claude -p`); a resident Monitor relay is the single delivery pipe; zero --adapter (host_binaries resolution, spt-core v0.9.0+)"
-required_stages = ["doc", "impl", "unit", "int"]  # doc: adapter/strings/skills/live.md (bare-listen bringup + poll/relay reconcile + Psyche-is-daemon-managed; Option A, no :live profile). impl: [session.psyche_init] in the BASE adapter/claude-spt.toml (the LiveAgent seam, 4 daemon keys, base-not-overlay) + min_spt_core_version=0.9.0 + the bare SessionStart seed (session-start.sh) + tools/claude-spt-psyche (the resident runner). unit: claude-spt-psyche cargo tests (arg parse, seed/pulse/poll command construction, blank-pulse guard) run by ci/psyche/build.sh. int: ci/psyche/live-relay-int.sh — plays CC's Monitor role (spawns a persistent CHILD `spt api ... listen <id>`, NOT --once) under a disposable id and asserts on real spt >=0.9.0: PSYCHE-SPAWN (the daemon livehost hosts the Psyche off the perch's live_agent online status — resident claude-spt-psyche runner + nested {id}-psyche perch dir; livehost.rs:282 gates on live_agent state) + RELAY (BOUND/READY + a probe relayed as the escaped <EVENT> envelope + live_agent kind). PSYCHE hosts off the BASE manifest (Option A — psyche_init in base; the live listen path stamps live_agent which actualizes it, poll stays ready). Gotchas baked in (doyle): anchor on the WINDOWS pid not git-bash `$$` (else STALE_SEED); `bind` before `send` (else NO_PERCH, no queue). The psyche binary resolves by bare name from the adapter install dir (REQ-INSTALL-11, Feature B v0.8.0+). Bare-flow (no --adapter; host_binaries resolution) is the spt-core v0.9.0 legacy-parity path — F-007 (how-to redirect) retired, the body is self-contained.
+id = "REQ-OMP-NATIVE-TUI"
+title = "The hosted launch contract hands validated OMP its packaged extension as the broker PTY process"
+required_stages = ["doc", "impl", "unit", "int"]
 
+# Intentionally inactive until an actual release runs the ADR-0013 acceptance gate. Deterministic
+# fake-process launch evidence must never satisfy this live endpoint requirement.
 [[requirements]]
-id = "REQ-UPS-INJECTION"
-title = "UserPromptSubmit hook detects /sptc:X and injects X's real instructions as additionalContext (SKILL.md files stay skeletons); must be empirically confirmed UPS fires on slash-commands"
-required_stages = ["doc", "impl", "unit", "int"]  # doc: ADR-0002. impl: user-prompt-submit.sh (skill-injection + drain) + _common.sh. unit: render_frames + sptc_skill_key tests. int: ci/hooks/poll-int.sh — the poll->additionalContext drain round-trip vs live v0.7.1 (<EVENT> envelope, render_frames confirm-match, multi-message). UPS-fires-on-slash empirical = ADR-0002 validation (CC 2.1.177); skill-injection resolve = registration-int 4c.
+id = "REQ-OMP-LIVE-RELEASE-GATE"
+title = "Pending live gate: a real OMP release must satisfy the ADR-0013 endpoint acceptance criteria"
+required_stages = []
 
 [[requirements]]
-id = "REQ-DIST-SESSIONSTART-BRIEF"
-title = "SessionStart injects agent-facing briefs as additionalContext: an identity brief (who + perch-live/don't-re-arm + send/reply/roster) for perched sessions (bind+boundary), and a peer-gated ring brief (spt ring + roster) for no-perch seed sessions; all prose is adapter-string-backed ([strings.briefs]), the hook only composes + {id}-substitutes, never authors prose; subagent (agent_type) sessions are skipped"
-required_stages = ["doc", "impl", "unit"]  # doc: docs-site harness-contract §SessionStart briefs. impl: session-start.sh emit-block + _common.sh (sptc_brief/assemble_perch/assemble_noperch/perch_brief/noperch_brief/is_subagent/has_peers_lines/node_has_peers/json_escape/emit_additional_context) + adapter/strings/briefs/*.md + [strings.briefs] in claude-spt.toml. unit: tests/hooks-parse.sh (assemble structure + {id} global subst + is_subagent + peer-gate line-count + json_escape + emit shape/empty). int PENDING: committed brief round-trip script (get-string file-backed resolve -> compose -> valid JSON) — manually proven 2026-06-19 via a renamed local probe adapter (probe-sptc), add "int" when the script lands + the published claude-spt adapter carries [strings.briefs]. NOTE: live-vs-ready flavor DEFERRED (public liveness-query gap, logged w/ doyle, post-v0.13.0 spt whoami --json).
-
-# ── Milestone: CI (autonomous fleet) — minted on-start. Deterministic gates + git push-trigger +
-# spt reporting bus. Seeded from SCOPE.md "CI model" + docs/CI.md. Real-claude acceptance is a
-# later slice (doc-only now). All harness-agnostic shell; runs on the Win+Linux fleet.
+id = "REQ-OMP-EXECUTABLE-RESOLUTION"
+title = "Fresh, resumed, and daemon-driven OMP turns resolve and validate Oh My Pi, reject executable collisions, and fail loudly"
+required_stages = ["doc", "impl", "unit", "int"]
 
 [[requirements]]
-id = "REQ-CI-GATES"
-title = "Deterministic gates (shell-syntax + unit tests + traceable-reqs check + manifest-schema + docs-drift), each a binary pass/fail, runnable as one command"
+id = "REQ-OMP-EXTENSION-CUSTODY"
+title = "The OMP extension serializes accepted deliveries and preserves sender custody through a correlated reply or explicit failure"
 required_stages = ["doc", "impl", "unit"]
 
 [[requirements]]
-id = "REQ-CI-MANUAL"
-title = "A manual 'run gates' command always exists — the same gate scripts runnable by hand on any fleet host"
-required_stages = ["doc", "impl"]
-
-[[requirements]]
-id = "REQ-CI-TRIGGER"
-title = "A git push hook fires the gates: pings a fleet runner-agent over spt rather than polling"
-required_stages = ["doc", "impl"]
-
-[[requirements]]
-id = "REQ-CI-BUS"
-title = "CI progress/results report over spt messaging (dogfood the product as its own CI nervous system)"
-required_stages = ["doc", "impl"]
-
-[[requirements]]
-id = "REQ-CI-OWL-DISCOVERY"
-title = "The spt messaging (bus) binary is located robustly at run time (per-version plugins path / PATH / configured) — never a hard-coded versioned path"
+id = "REQ-OMP-LISTENER-FAIL-CLOSED"
+title = "Unexpected listener exit retries within a finite budget and then performs SPT session-end plus OMP shutdown"
 required_stages = ["doc", "impl", "unit"]
 
 [[requirements]]
-id = "REQ-CI-ACCEPTANCE"
-title = "Acceptance = scripted orchestration spawning real claude/headless sessions as the system-under-test, asserting spt-state/digest output (LLM is SUT, never the runner)"
-required_stages = ["doc", "impl", "int"]  # doc: docs/CI.md. impl: ci/acceptance/{lib,run-acceptance}.sh + harness unit. int: real `claude -p` spawn asserted UPS-hook-fires green 2026-06-15 under disposable id sptc-ci-40322 (operator perch perri survived — guard proven e2e).
-
-[[requirements]]
-id = "REQ-HAZARD-PERCH-COLLISION"
-title = "The acceptance harness spawns every nested claude SUT under a DISPOSABLE identity (SPT_AGENT_ID=sptc-ci-<n>), never a live agent's perch id — a colliding id tears down the live agent's perch + poll stream (name-keyed, last-establish-wins)"
-required_stages = ["unit"]  # unit: tests/acceptance-harness.sh. Diagnosed 2026-06-15 (operator): nested claude loading the spt plugin established a perch under "perri" and displaced the live poll stream.
-
-[[requirements]]
-id = "REQ-HAZARD-MSYS-PATHCONV"
-title = "Hook wrappers read the CC payload from stdin, never from a /-leading positional argv (Git-Bash/MSYS path-mangles those on Windows)"
-required_stages = ["unit"]  # unit: tests/msys-hazard.sh. Confirmed live 2026-06-15 (UPS validation run A).
+id = "REQ-OMP-SESSION-IMMUTABLE"
+title = "One endpoint owns one OMP session for its lifetime and blocks every in-TUI session-changing action"
+required_stages = ["doc", "impl", "unit"]
 
 [[requirements]]
-id = "REQ-HAZARD-PSYCHE-PERMS-DEADLOCK"
-title = "Every CC process spt-core spawns NON-INTERACTIVELY carries --dangerously-skip-permissions: each claude-spt-psyche turn (seed + every pulse, detached/null-stdin), both [session.self] bringup commands (base claude + ccs profile, broker PTY), AND [session.resume] (native-resume into the broker PTY). An interactive permission prompt with no operator deadlocks the turn (silently, for the detached Psyche). The Psyche additionally runs inside a Read/Edit/Write tool sandbox so auto-approve is bounded."
-required_stages = ["doc", "unit"]  # doc: docs/KNOWN-HAZARDS.md §2.2 + docs/adr/0003-*. unit: tools/claude-spt-psyche/src/main.rs every_turn_is_sandboxed_to_legacy_owl_parity (psyche turns) + tests/manifest-shortcut.sh (all THREE CC spawn commands — both [session.self] + [session.resume] — carry the flag). Legacy parity: claude_skill_owl src/live/wrapper/claude.rs (init/resume/final all skip-permissions). Identified 2026-06-18 reaching psyche parity; extended to [session.resume] 2026-06-20 (v0.13.0 native-resume seam).
+id = "REQ-OMP-MESSAGE-CONTEXT"
+title = "Each peer delivery opens one ordinary OMP turn containing a message stub and the complete SPT event context"
+required_stages = ["doc", "impl", "unit"]
 
 [[requirements]]
-id = "REQ-HAZARD-PSYCHE-HOST-THRASH"
-title = "The psyche host's resident loop is PACED and TERMINAL on persistent instant cycles: a healthy iteration blocks (perch poll or a real claude turn); when iterations complete sub-2s repeatedly (claude dying at spawn — the F-h untrusted-cwd trust prompt — or a thrashing poll), the host backs off exponentially (500ms doubling, 5s cap) and after 8 consecutive instant cycles exits LOUD + NONZERO (PSYCHE_HOST_GIVE_UP stderr, exit 3) so the wrapper DEATH becomes visible to spt-core's psyche_host_error/residency machinery — a silent internal loop is invisible to it (field: ~3 boots/sec for 30min, ordinal 5358, F-h). Threshold coupling (doyle-ruled): core's C3(b) backstop trips at >=10 ledger boundaries/60s; for the pure instant-death class this guard fires FIRST (<=8 boundaries, <60s wall clock); failure modes that dodge the streak (just-over-threshold cycles resetting it) legitimately reach the core backstop — a core trip on a guarded wrapper is correct backstop behavior, not a bug."
-required_stages = ["doc", "unit"]  # RESOLVED-BY-DESIGN (v0.14.0 psyche-ephemeral redesign, F-030; PSYCHE-EPHEMERAL-PLAN.md): the resident loop this hazard guards — and its v0.13.4 per-pulse `spt ready --once` poll-fail leg — are DELETED. The shim is run-to-completion (one claude spawn per invocation, then exit), so the instant-cycle class + the multi-subnet READY_FAIL poll-refusal churn cannot occur adapter-side: there is no loop and no poll. Crashloop = repeated ephemeral deaths = core C3(b) ledger-rate territory BY DESIGN (the daemon's psyche_host_error surface consumes each death). Stages stay live on the SUCCESSOR invariant. doc: docs/KNOWN-HAZARDS.md §2.6 (resolution note kept for history). unit: tools/claude-spt/src/psyche.rs plan_is_stateless_one_turn_no_residency (plan() is pure and plans exactly one turn — no streaks, no backoff, no residency, nothing to thrash; the successor assertion replacing the retired thrash_guard + poll_refused code, which died with the loop). The subnet-less nested-resolution core seam (runner cannot know the subnet) folds into the F-030 wave. The deferred give-up/poll-fail live ints die with the loop (nothing to trigger).
+id = "REQ-OMP-READY-LIVE"
+title = "The adapter advertises exactly ReadyAgent and LiveAgent endpoint types on the same native OMP hosting path"
+required_stages = ["doc", "unit"]
 
 [[requirements]]
-id = "REQ-HAZARD-PSYCHE-IDENTITY-ENV"
-title = "Both psyche roles ([session.psyche_init] gate + [session.psyche_resume] spawn) declare env_remove = [\"OWL_SESSION_ID\", \"SPT_AGENT_ID\"] — a spawned Psyche must NEVER inherit its parent session's identity env, or its harness hooks resolve \"self\" to the PARENT (or a foreign top-level perch) and stamp/rebind THAT perch (field-observed F-028 C2: f015b-probe-psyche rebound hall-a's info.json.session_id via authenticate()'s dead-owner re-pin). The adapter's half of the f028 cross-perch-contamination guard pair; spt-core runtime honors role env_remove (public contract: manifest.schema.json SessionRole.env_remove)."
-required_stages = ["doc", "unit"]  # Declaration-only manifest seam (scanner does not read .toml — same convention as REQ-DIST-SESSION-RESUME): doc: docs/KNOWN-HAZARDS.md §2.5. unit: tests/manifest-shortcut.sh env-scrub block (env_remove present in BOTH [session.psyche_init] and [session.psyche_resume], both identity vars — v0.14.0 ephemeral: the scrub rides both roles now). Source: doyle's F-028 C2 adapter change brief 2026-07-03. int (a live psyche spawn asserting the vars absent from the child env) deferred to the next live-verify window.
+id = "REQ-OMP-CONTINUITY-DROPS"
+title = "Commune and signoff drops resolve project-locally under .spt on the published v0.29.0 endpoint-cwd contract"
+required_stages = ["doc", "unit"]
 
 [[requirements]]
 id = "REQ-PSYCHE-EPHEMERAL-SHIM"
-title = "The psyche runner is a run-to-completion EPHEMERAL shim, never a resident driver (PSYCHE-EPHEMERAL-PLAN.md; adapter half of the joint F-030 wave, frozen against doyle's W1/W2 psyche-turn contract 944a74b0 + the evidence answers). Contract: one invocation = at most ONE headless claude turn, then exit. ONE spawned role ([session.psyche_resume]) with TWO key shapes, discriminated on the mind FILE's content emptiness (W4, {psyche_context_file}): a NON-EMPTY mind file (a FreshWithPreload turn — core writes the mind non-empty) ADOPTS the core-minted sid (`claude -p --session-id {session_id}`, prompt = mind + blank line + event); an EMPTY mind file (a ContinueExisting turn — core writes it truly empty, no sentinel) RESUMES (`claude -p --resume {session_id}`, prompt = event). The per-turn EVENT rides the shim's STDIN; the mind rides a core-written FILE the shim reads ({psyche_context_file}, always-filled path); the composed prompt reaches claude via CLAUDE'S OWN STDIN (never claude argv — win32 cmdline cap); claude's STDOUT is captured and passed through as the psyche's sole outbound, with a NON-EMPTY ack guaranteed on a no-relay turn (core backstops via EmptyOutput). Blank composed prompt = the ack + exit 0 WITHOUT spawning claude (billing guard). Reseed is signalled by the reserved EXIT CODE 95 — emitted ONLY on a ContinueExisting resume whose session is gone (claude 'No conversation found with session ID'); EVERY OTHER nonzero keeps custody (generic PSYCHE_TURN_FAIL); no internal retry, no silent reseed (the daemon owns reseed; core C3(b) owns crashloop pacing). The shim mints NO perch (core spawn_and_bind) and writes NOTHING to the core-owned psyche-custody.json. sid custody is CORE's (F-030 mints the psyche-own sid + fills {session_id}; uuid_inject, no adapter capture-and-report)."
-required_stages = ["impl", "unit"]  # MINTED + ACTIVATED 2026-07-04 (build phase of the gated plan; registered before satisfying, rule 3). impl: tools/claude-spt/src/psyche.rs — the ephemeral shim (Args parse, is_first_turn/compose_prompt/turn_cmd, plan planner, classify_failure exit-95 discriminator, run_claude capture + ack, run() wiring) + adapter/claude-spt.toml [session.psyche_resume] table (+ [session.psyche_init] gate-only). unit: all_three_keys_required_order_independent, missing_any_required_flag_is_an_error, unknown_arg_is_rejected, nonempty_context_is_a_fresh_turn_empty_is_continue, first_turn_adopts_the_minted_sid, continue_turn_resumes_by_sid, first_prompt_is_mind_blankline_event, continue_prompt_is_event_only, blank_continue_event_plans_the_ack_no_spawn, first_turn_never_planned_as_ack_mind_is_nonempty, resume_session_gone_is_the_sole_reseed_signal (exit 95), a_fresh_turn_is_never_session_gone, other_resume_failures_keep_custody, every_turn_is_sandboxed_both_modes, the_shim_never_mints_no_spt_verb_in_the_turn, ack_is_non_empty. doc rides KNOWN-HAZARDS §2.6's resolution note + the plan file (activate a doc stage if a docs-site psyche page lands with F-030). int: the commune→ingest→psyche_resume→synthesis e2e THROUGH the shim — deferred to the F-030 + live-verify window (publish gate), alongside the parked RC re-runs.
-
-[[requirements]]
-id = "REQ-PSYCHE-CONTEXT-FILE-INDIRECTION"
-title = "The composed mind reaches the ephemeral psyche shim as a FILE, not an argv value (W4 contract amendment, doyle 9e6863d0, 2026-07-04). {psyche_context} (an argv value) is REPLACED by {psyche_context_file} — a path, ALWAYS filled, to a core-written mind file in the psyche's nested perch dir. Rationale: a ~20KB composed mind on argv risks the win32 ~32k CreateProcess cmdline cap; a file-always path kills the cliff with ONE code path (no inline-small/file-large branch). The shim READS the file to get the mind, then its fresh-vs-continue discrimination + prompt composition are byte-for-byte the pre-W4 logic on the file CONTENT. BINDING INVARIANT (doyle-pinned, core-side unit-asserted): a ContinueExisting turn writes the file TRULY EMPTY (0-byte or whitespace — the shim's emptiness test is trim-based) with NO sentinel token EVER; a non-empty body is EXCLUSIVELY FreshWithPreload (the composed mind, or the <fresh-psyche/>-class zero-context marker). Core owns the file's whole lifecycle (write-before-spawn every turn, overwrite in place); the shim NEVER writes or deletes it. A file-read failure is a generic keep-custody FAULT before any claude spawn — never the exit-95 reseed (which stays claude --resume session-gone only)."
-required_stages = ["impl", "unit"]  # MINTED + ACTIVATED 2026-07-04 (W4 amendment; adapter builds to the frozen shape ahead of todlando's core W4). impl: tools/claude-spt/src/psyche.rs — Args.psyche_context_file (required, always-filled) + read_context() + run()'s read-file prefix (read-fail → generic keep-custody exit before spawn) + adapter/claude-spt.toml both psyche roles' command/keys use {psyche_context_file}. unit: reads_the_mind_file_and_content_drives_the_discriminator (real temp file: non-empty→fresh, whitespace-only→continue), an_unreadable_mind_file_is_an_error_not_a_panic (missing file → Err → keep-custody fault). Manifest shape asserted by tests/manifest-shortcut.sh (psyche_resume command carries --psyche-context-file {psyche_context_file}; keys include psyche_context_file). doc rides the plan + KNOWN-HAZARDS (activate with F-030 docs). int: folds into the REQ-PSYCHE-EPHEMERAL-SHIM commune→resume→synthesis e2e (live-verify window). PARKS with v0.14.0 on the F-030/W4 core floor.
-
-[[requirements]]
-id = "REQ-HAZARD-HOOKCMD-DISPATCH-LOCKSTEP"
-title = "The [strings].hook_cmd SHAPE and the plugin dispatch.sh shim move in LOCKSTEP (or the dispatch contract is pinned): a shape change in one layer with the other stale must DEGRADE, never brick — the 2026-07-01 mid-session skew (old 0.1.8 dispatch execing `\"$bin\" <event>` × new bare-path hook_cmd) ran `claude-spt PreToolUse` → unknown-subcommand → nonzero exit on EVERY hook event → CC blocked all tools AND looped the Stop hook; zero self-repair until the operator ran /reload-plugins"
-required_stages = ["doc", "unit"]  # ACTIVATED (guard slice): unit — dispatch.sh handles BOTH hook_cmd shapes (bare + legacy ` hook`-suffixed) in BOTH directions (tests/hooks-dispatch.sh) AND claude-spt DEGRADES (exit 0, pass-through + stderr note) when a stale dispatch execs `claude-spt <CCEvent>` without the `hook` token, so a stale dispatch never bricks CC (main.rs / hook.rs unit tests). Still OPEN for a later int wave: post-update reconcile refreshes the LIVE plugin cache dir (incl. ccs instance roots ~/.ccs/instances/<x>/plugins, suspected miss) — the binary-side degrade above neutralizes the brick regardless, so that reconcile is a UX cleanup, not a blocker.
-
-# ── Milestone: DOCS-SITE (mdBook, drift-gated) — minted on-start. Dual-audience product docs
-# in docs-site/, built with mdBook, gated against drift. Seeded from docs/DOCS-STRATEGY.md.
-
-[[requirements]]
-id = "REQ-DOCS-SITE"
-title = "docs-site/ builds with mdBook from src/ (themed, Diátaxis-shaped, all-real-content — no placeholders)"
-required_stages = ["doc", "impl"]  # doc: DOCS-STRATEGY. impl: docs-site/book.toml + src/ pages.
-
-[[requirements]]
-id = "REQ-DOCS-DRIFT"
-title = "Generated docs (llms.txt) are CI-gated against drift: a deterministic generator's output must match what's checked in, and the book must build"
-required_stages = ["doc", "impl", "unit"]  # doc: DOCS-STRATEGY #10. impl: ci/docs/{gen-llms,check-docs}.sh + run-gates wiring. unit: tests/docs-gen.sh.
-
-[[requirements]]
-id = "REQ-PARITY-AUDIT"
-title = "The adapter's operative skill/profile surface is reconciled against the SCOPE.md LOCKED parity-trim (KEEP/ADD/DROP/TRANSFORM): every divergence is either resolved or logged as an accepted gap in docs/PARITY.md — the 'proven parity' record the sptc->spt succession flip gates on"
-required_stages = ["doc"]  # doc: docs/PARITY.md (the parity matrix + per-row evidence/finding). Pure reconciliation record (no code of its own); the per-surface impl/unit evidence lives on the surface's own REQ (REQ-SKILL-SUBNET, REQ-CCS-PROFILES, REQ-SKILL-LIVE, etc.).
+title = "Each LiveAgent Psyche event runs as one bounded OMP turn with file-backed context and explicit reseed signaling"
+required_stages = ["doc", "impl", "unit"]
 
 [[requirements]]
-id = "REQ-SKILL-SUBNET"
-title = "The adapter ships subnet membership skill(s) (create/join/show-code) wrapping the published `spt subnet <verb>` surface — the LOCKED-ADD cross-subnet entrypoint (v1 topology is mandatory, SCOPE)"
-required_stages = ["doc", "int"]  # doc: adapter/strings/skills/subnet.md (one /sptc:subnet skill covering status/create/show-code/join — mirrors the single `spt subnet` verb-family CLI). int: ci/manifest/registration-int.sh file-backed-resolve assertion (skills.subnet -> body) on live spt — the wiring proof. No separate `impl`/`unit` stage: a file-backed skill has no unit-testable code of its own (the manifest [strings.skills].subnet pointer + plugin stub are config, and the int proves they resolve end-to-end through the live registry — same model as the commune/force-stop skills, which carry no per-skill impl). (Skill points at `spt how-to subnet` + `spt subnet --help` as the canonical self-drive anchors — the how-to topic now ships.)
+id = "REQ-HISTORY-FETCHER"
+title = "The history fetcher locates exactly one OMP session and streams its JSONL bytes verbatim"
+required_stages = ["doc", "impl", "unit"]
 
 [[requirements]]
-id = "REQ-CCS-PROFILES"
-title = "The adapter ships a ccs profile template (claude-spt:ccs) — LOCKED-ADD overlay that retargets the spawn command template through `ccs` (a drop-in for the `claude` binary) and honors ccs's relocated CLAUDE_CONFIG_DIR transcript root in the digest extractor; templates only (user supplies their own ccs config/keys)"
-# Scoped to the default-profile shape the operator actually runs: `ccs` (bare), the account set via
-# `ccs auth default <name>`, NOT glm/kimi (those were SCOPE *examples*; this profile IS the example +
-# the operator's own SPT use). Validated against the known-good sister project claude_skill_owl:
-# (1) ccs is a drop-in for the `claude` binary, same argv (live/wrapper/claude.rs Tier-2 latch);
-# (2) ccs relocates Claude Code's state tree via CLAUDE_CONFIG_DIR, resolved IN-BINARY by
-# owlery::claude_projects_root ($CLAUDE_CONFIG_DIR/projects || $HOME/.claude/projects).
-# impl/unit = the CLAUDE_CONFIG_DIR-aware projects-root resolver in claude-spt-digest (a .toml
-# profile leaf does NOT register as impl evidence; the real impl is the env-aware extractor).
-# doc = manifest [profiles.ccs] overlay + docs/PARITY.md. int = registration-int profile-resolves
-# assertion (claude-spt:ccs resolves + adapter_label overlay observable; sole shipped overlay).
+id = "REQ-DIST-DIGEST-EXTRACTOR"
+title = "The OMP digest fetcher maps native session JSONL into the published harness-neutral digest record stream"
 required_stages = ["doc", "impl", "unit", "int"]
 
 [[requirements]]
-id = "REQ-SKILL-VERSION"
-title = "/spt:version reports the spt-core-tracked manifest/binary version (the version-of-truth, not the marketplace skeleton version)"
-required_stages = []
-
-# ── Milestone: SETUP-SLICE (the /sptc:setup activation bridge + LOCKED v1 setup paths) — minted
-# 2026-06-15, seeded from SCOPE.md §"/spt:setup" (LOCKED v1 = {1..7}) + finding F-005 (the
-# post-install adapter ACTIVATION step). Inactive (required_stages = []) until the slice executes —
-# REQ-SETUP-ACTIVATE activates to ["doc","impl","int"] (Wave 1); the {1..7} feature paths get their
-# own REQs as each later wave starts. The end-user --github activation target is blocked on doyle's
-# topology ruling (Q1-Q3, owl 2026-06-15) — see SETUP-SLICE-PLAN.md.
-
-[[requirements]]
-id = "REQ-SETUP-SUBNET"
-title = "/sptc:setup offers subnet onboarding (SCOPE LOCKED setup #3/#4): detect membership (`spt subnet status`); not-in-a-subnet -> offer create (`spt subnet create`, prints code/URI/QR) or join (`spt subnet join`); in-a-subnet -> show-code to invite / add-this-machine. Delegates the verb mechanics to /sptc:subnet and surfaces the OS-elevation requirement (create/join/show-code are seed-reveal/enroll-gated) with the per-context elevation paths; automated context-aware elevation is a deeper wave."
-required_stages = ["doc"]  # doc: adapter/strings/skills/setup.md + plugin/sptc/skills/setup/SKILL.md — the subnet-onboarding step (detect via `spt subnet status`; branch create/join/show-code; delegate to /sptc:subnet for full verb guidance; note elevation: Windows UAC | Linux desktop pkexec/polkit | Linux TTY sudo | headless -> print the command for the user). Doc-class instruction prose, no adapter-side code (same model as REQ-SETUP-ACTIVATE/REQ-SETUP-CCS). The subnet verbs themselves are wrapped by /sptc:subnet (REQ-SKILL-SUBNET, registration-int.sh); this REQ is only the SETUP-TIME onboarding/branch + elevation framing. Public-surface-complete (`spt subnet` verb-family exists; QR is emitted by spt-core's create/show-code). Full elevation AUTOMATION (the LOCKED elevation design) is a later sub-wave; setup #5 (legacy migration) is BLOCKED on F-008; #6 (OS-service) is installer-handled; #1 (cc launcher) gated on full-fat M12.
-
-[[requirements]]
-id = "REQ-SETUP-CCS"
-title = "/sptc:setup wires the ccs integration (SCOPE LOCKED setup #7): if `~/.ccs` is present, point the user at the shipped `claude-spt:ccs` profile (routes live/ready sessions through `ccs`, a drop-in for `claude`, via `--adapter claude-spt:ccs`) + sanity-check `ccs` on PATH; if absent, offer to install ccs with a one-sentence value prop (optional — base claude-spt is unaffected)."
-required_stages = ["doc"]  # doc: adapter/strings/skills/setup.md + plugin/sptc/skills/setup/SKILL.md — the ccs-wiring step (detect ~/.ccs; present -> reference the :ccs profile + verify ccs on PATH; absent -> offer install w/ value prop). Doc-class instruction prose, no adapter-side code of its own (same model as REQ-SETUP-ACTIVATE/REQ-SKILL-SUBNET). The :ccs profile's existence + leaf-replace resolution is covered separately by REQ-CCS-PROFILES (registration-int.sh); this REQ is only the SETUP-TIME detection/offer step. Public-surface-complete: `~/.ccs` detection + the existing :ccs profile, no unpublished dep.
+id = "REQ-SESSION-ECHO-COMMUNE"
+title = "The bounded echo-commune role summarizes one OMP session and reports real OMP failures without latching on a locate miss"
+required_stages = ["doc", "impl", "unit"]
 
 [[requirements]]
-id = "REQ-SETUP-ACTIVATE"
-title = "/sptc:setup, after confirming the spt binary is present, ACTIVATES the claude-spt adapter (`spt adapter add` — the manifest file in local dev; `--github <published-adapter-repo>` for end-users) so profiles/strings/hints/[digest] go live, then verifies (adapter no longer `deregistered`). Binary-present is NOT a no-op — this is the F-005 post-install activation bridge."
-required_stages = ["doc", "int"]  # doc: adapter/strings/skills/setup.md + plugin/sptc/skills/setup/SKILL.md — the activation step (probe `adapter list`; if missing/deregistered, `adapter add` local-file-form for dev | `--release` for end-user; verify active; PATH-binary caveat). A setup skill body is doc-class instruction prose (no adapter-side code of its own — same model as REQ-SKILL-SUBNET). int: ci/setup/activate-int.sh — the deregistered->active RE-ACTIVATE assertion (local file-form) + profiles/strings go live (slow lane, SPTC_ACCEPTANCE=1, spt>=0.7.0); dogfood-proven on spt 0.7.3. The END-USER `--release` acquisition leg is proven separately by REQ-DIST-ADAPTER-RELEASE int (ci/publish/release-acquire-int.sh). Acquisition RESOLVED (doyle owl 2026-06-15): monorepo file-form for dev, `adapter add --release SaberMage/claude-spt` (adapter.spt release asset) for end-user — no dedicated repo. See SETUP-SLICE-PLAN.md + REQ-DIST-ADAPTER-RELEASE.
+id = "REQ-DIST-MANIFEST-SCHEMA"
+title = "The omp-spt manifest validates offline against spt-core's published manifest schema"
+required_stages = ["doc", "impl", "unit"]
 
 [[requirements]]
 id = "REQ-DIST-ADAPTER-RELEASE"
-title = "The adapter ships to end users as an `adapter.spt` GitHub release asset (tar ROOT = manifest.toml + strings/ + the tool binaries), acquired via `spt adapter add --release SaberMage/claude-spt` — distribution straight from the monorepo, no dedicated repo (doyle's --release acquisition source, spt v0.7.3/counter-15)"
-required_stages = ["doc", "impl", "unit", "int"]  # doc: SETUP-SLICE-PLAN.md Wave C' + docs/RELEASE-RUNBOOK.md (the adapter.spt release-asset publish target). impl: ci/publish/package-adapter.sh (validate manifest + pack manifest.toml[renamed from claude-spt.toml]+strings/+release tool binaries at archive ROOT; dry-run default, --apply writes dist/adapter.spt; never uploads — the release/tag/upload stays the operator's step). unit: tests/adapter-archive.sh (the packed .spt root holds manifest.toml named exactly + strings/ + the three binaries [digest, psyche, cc-spt-idle-translate]; reject a malformed archive). int: ci/publish/release-acquire-int.sh — real `adapter add --release SaberMage/claude-spt` acquire on a clean target: claude-spt active, sourced from the _github install dir, profiles/strings from the .spt resolve (slow lane, SPTC_ACCEPTANCE=1, spt>=0.7.3, network); dogfood-proven on spt 0.7.3.
-
-[[requirements]]
-id = "REQ-DIST-ADAPTER-PEROS"
-title = "The adapter ships ONE host-agnostic MULTI-PLATFORM `adapter.spt` (ADR-0024 W1, spt-core >= 0.13.2): a single fat archive bundles every recognized target-triple's tool binaries under a `<triple>/` dir beside the SHARED manifest.toml + strings/ at the archive root; install classifies the triple dirs and flattens THIS node's triple into the install dir, so a bare-name command token resolves (REQ-INSTALL-11). `spt adapter add --release` (default asset adapter.spt) + the `[update] gh_release` avenue auto-resolve the host's binaries from the one asset — RETIRING the F-014 per-OS stopgap (the old single-OS adapter.spt-by-default that broke on a foreign host). v1 triples = x86_64-pc-windows-msvc + x86_64-unknown-linux-gnu (the only two spt-core recognizes in a fat archive; platforms beyond these ship a separate single-triple asset via `--asset`)."
-required_stages = ["doc", "impl", "unit"]  # doc: docs/RELEASE-RUNBOOK.md fat-archive packaging section (win native + linux cross-build via cargo-zigbuild — proven 2026-06-16, real ELF x86-64; bare `cargo build --target` fails `cc not found`, zig supplies the linker). impl: ci/publish/package-adapter.sh stages the shared root (manifest.toml + strings/) + each <triple>/ (win .exe, linux ELF) into ONE adapter.spt, refuses a < 0.13.2 floor, and guards the unrecognized-top-level-dir footgun. unit: tests/adapter-archive.sh asserts shared-root + both <triple>/ binary sets + no stray top-level dir + the fat-capable floor. int (real spt-core extract+flatten of the fat asset) folds into release-acquire-int.sh once the fat adapter.spt is published on a release; the win-triple flatten was LOCAL-dogfooded 2026-06-22 (extract → flatten win triple → translate-proof + digest-proof OK). NOTE: /sptc:setup's os-detection + `--asset` step is now OPTIONAL (the default fat adapter.spt is host-agnostic) — retained as harmless; simplifying setup to the bare default is a follow-on. See REQ-DIST-ADAPTER-RELEASE."
-
-# ── Milestone: V13-ADAPTER (spt-core harness-contract v0.13.0 seams) — minted 2026-06-20 from
-# doyle's owl: the v0.13.0 harness contract is PUBLISHED (sabermage.github.io/spt-releases/
-# harness-contract) ahead of the v0.13.0 binary (still v0.12.x on spt-releases). Two new RUN-group
-# seams are buildable against the contract NOW; their RUNTIME dogfood (the `int` stage) is GATED on
-# the v0.13.0 daemon — so both activate ["impl","unit"] and add "int" when doyle pings the binary
-# ship. doc DEFERRED to the docs-site harness-contract RUN-group slice (mirrors REQ-DIST-DIGEST-
-# EXTRACTOR's doc-deferred precedent — documented in the manifest/module comments meanwhile). See
-# V13-ADAPTER-PLAN.md.
-
-[[requirements]]
-id = "REQ-DIST-SESSION-RESUME"
-title = "The adapter manifest declares [session.resume] — Claude Code's NATIVE-RESUME verb (`claude -r {session_id} --remote-control {id} --dangerously-skip-permissions`, keys=[\"session_id\",\"id\"]) — so a spt-hosted resume (`spt endpoint run --resume` / picker Resume-from-history) reloads the REAL transcript by id instead of silently re-running [session.self] = a fresh blank session. {session_id} reloads the transcript (-r); {id} threads the endpoint as the remote-control session name (the RC channel native-resume drives, the same one `spt rc` / the idle-translation-binary use); skip-permissions for the non-interactive broker PTY (REQ-HAZARD-PSYCHE-PERMS-DEADLOCK). The PTY lands in the resumed session's recorded project cwd; CC resolves the transcript by {session_id}+cwd."
-required_stages = ["unit"]  # [session.resume] is a DECLARATION-ONLY seam: the in-repo deliverable is the manifest table adapter/claude-spt.toml (validated against CC's real `-r`/`--remote-control` flags — both exist in `claude --help`), and the traceable-reqs scanner does NOT read .toml, so there is no scannable impl artifact in-repo (the code that ACTS on the declaration is the spt-core daemon — out of repo, exercised at int). Same convention as REQ-DIST-SHORTCUT-BASENAME/REQ-DIST-SESSIONSTART-BRIEF (manifest tables documented in notes, evidence anchored on the acting code / asserting test). unit: tests/manifest-shortcut.sh — [session.resume] present, the `-r {session_id}` reload-fill + `--remote-control {id}` id-fill, and the 3rd skip-perms CC spawn (REQ-HAZARD-PSYCHE-PERMS-DEADLOCK). int DEFERRED (the impl-in-action): a real native-resume launch (resumed-transcript reload + RC drive) needs the v0.13.0 daemon (docs lead the binary, still v0.12.x on spt-releases) — add "int" when doyle ships it. doc DEFERRED to the docs-site harness-contract RUN-group slice (the seam is fully documented in the manifest [session.resume] comment meanwhile; mirrors REQ-DIST-DIGEST-EXTRACTOR's doc-deferred precedent). Public-surface-complete: the contract page (harness-contract/manifest.html#session.resume, since v0.13.0) is the authority; no spt-core internals. STATIC signals green on spt 0.13.1 (counter 28): registration accepts the [session.resume] role + `spt endpoint run --resume <RESUME>` flag present (conflicts --create). NB the v0.13.1 `translate-proof` tool validates the IDLE-TRANSLATION binary ONLY — it does NOT cover [session.resume]; the resume int stays a real-claude `endpoint run --resume` bringup (reattach the transcript + RC drive), the heavier tier, still deferred — so this REQ stays unit (not promoted by translate-proof).
-
-[[requirements]]
-id = "REQ-DIST-IDLE-TRANSLATE"
-title = "The adapter ships the [message-idle-translation-binary] (command=\"{adapter_dir}/claude-spt translate\", spt-core v0.16.0 seam — path deprecated; D3 fold into the consolidated binary) — a lifecycle-managed stdin→stdout JSON-lines filter that turns each idle inbound <EVENT> envelope into the keystroke choreography spt-core applies ATOMICALLY to the broker PTY: ctrl+s (stash any draft) · 50ms · <envelope> (type the text, no trailing CR) · 50ms · {key:enter} (submit the PTY line) · {commit:true} (terminate the inject sequence) — so an inbound message never clobbers a half-typed operator draft (CC auto-restores the stashed draft after submit; no trailing restore keystroke). The submit is a DISCRETE {key:enter}, NOT a trailing \\r in the text: a \\r byte does NOT submit a Claude Code message (corrected 2026-06-23). The trailing {commit} is MANDATORY: spt-core's run_inject_worker (broker.rs:1075-1090) ends a sequence only on {commit}; without it the broker FAULTs at the 5s INJECT_COMMIT_DEADLINE on every delivery (the enter key submits the line, {commit} releases the InjectFloor — two distinct signals). Idle delivery ONLY (the spt-hosted complement to the busy/mid-turn [inject] hook path); coexists with a live `spt rc` controller."
-required_stages = ["impl", "unit", "int"]  # D3 FOLD 2026-06-26: now the `translate` subcommand of tools/claude-spt (src/translate.rs) — seam is [message-idle-translation-binary].command="{adapter_dir}/claude-spt translate" (spt-core v0.16.0; path deprecated); built+tested by ci/digest/build.sh (ci/idle-translate/build.sh is a shim); packed as the ONE tool binary; translate-proof-int --dir points at tools/claude-spt. ORIGINAL (pre-fold): impl: tools/cc-spt-idle-translate (Rust JSON-lines filter — event→6-step choreography [stash · 50ms · <envelope> text · 50ms · {key:enter} submit · {commit:true} terminator; CC auto-restores the draft so NO trailing restore keystroke], init/input/unknown-type emit nothing, CR/LF in the envelope neutralized so the injection can't split — only the discrete enter submits (a \r byte does NOT submit a CC message, corrected 2026-06-23), forward-compat unknown fields ignored) + [message-idle-translation-binary] path="cc-spt-idle-translate" in adapter/claude-spt.toml + ci/idle-translate/build.sh gate (wired into ci/run-gates.sh) + packed into adapter.spt (ci/publish/package-adapter.sh, the 3rd binary). unit: the crate's 11 cargo tests (run by ci/idle-translate/build.sh: the choreography order, submit-is-discrete-enter-key-not-trailing-CR, mandatory terminating commit, stash-precedes-submit, single-ctrl+s no-trailing-restore, CR/LF neutralization, dispatch, no-output types, envelope-less event, unknown fields, single-field command shape) + tests/{manifest-shortcut.sh (manifest path), adapter-archive.sh (binary packs at root)}. int: ci/idle-translate/translate-proof-int.sh — `spt adapter translate-proof claude-spt --event …` on real spt >=0.13.1 (counter 28) spawns+feeds the binary daemon-identically and asserts TRANSLATE_PROOF_OK + "commit: yes" + the discrete {key:enter} submit (and that the text carries NO trailing \r). GREEN 2026-06-22 (disposable install-dir staged manifest.toml+strings+binary — the GhReleaseManaged resolver wants the extracted shape; soft-removed on teardown). This is the EMIT half ONLY; the daemon's atomic PTY APPLY + spawn-on-up/reap-on-down lifecycle stay covered by a real-claude bringup int (heavier tier, still deferred) — translate-proof explicitly does not exercise apply (ADR-0022). The no-{commit} FAULT (F-016) is exactly what the proof's no-commit gate catches. doc DEFERRED to the docs-site harness-contract RUN-group slice (documented in the manifest + module comment meanwhile). Public-surface-complete: the contract page (harness-contract/manifest.html, message-idle-translation-binary since v0.13.0) is the authority; the operator-specified ctrl+s choreography is the adapter's own UX layer atop the generic key/text/delay_ms protocol. SOURCE-CONFIRMED (doyle 2026-06-20): spt-core applies a {text} command VERBATIM (broker.rs:1016-1017, no control-char strip), so the envelope-internal CR/LF neutralization is required (an un-neutralized \n/\r would reach the PTY and could split the injection). CORRECTION (2026-06-23): the submit is now a DISCRETE {key:enter} after the text, NOT a trailing \r — empirically a \r byte in injected text does NOT trigger Claude Code's message submission (CC needs the discrete Enter key event; the earlier assumption that a verbatim \r == {key:enter} held at the byte level but not for CC's input handling). The published contract example always showed {text}{key:enter}; this adapter now follows it literally.
-
-# ─────────────── Checkpoint-commune wave (planned 2026-06-24, CHECKPOINT-COMMUNE-PLAN.md) ───────────────
-# All inactive (required_stages = []) — activate-don't-pre-fail. Activate per-task as the build starts.
-
-[[requirements]]
-id = "REQ-DIST-IDLE-MULTILINE"
-title = "The idle-translation binary renders each inbound <EVENT> envelope across MULTIPLE LINES in CC's input box for visual distinction — an embedded raw newline byte in the {text} payload after the opening <EVENT ...> tag and before the closing </EVENT> (spt-core writes {text} byte-verbatim including newlines, doyle-confirmed; CC soft-newlines on a bare newline, empirically gated). Cyan color is impossible (SGR bytes eaten by CC input handling; user-turns theme-fixed)."
-required_stages = ["impl", "unit", "int"]  # Feature 1 / task T1 — ACTIVATED 2026-06-24 after the empirical soft-newline gate PASSED (probe binary on a live spt-hosted endpoint: a two-line {text} landed as ONE user turn with the \n preserved, no early submit). impl: cc-spt-idle-translate frame_envelope splits the envelope opening-tag/\n/body/\n/closing-tag, embedding two deliberate \n's AFTER the stray-CR/LF-neutralize (degenerate fallback for non-<EVENT>…</EVENT> shapes incl. EVENT-PART). unit: the crate's framing tests (envelope_is_framed_across_three_lines + fallback/attrless/empty-body + stray-then-framing). int: ci/idle-translate/translate-proof-int.sh asserts the emitted {text} frames across lines (>\n … \n</EVENT>) — the EMIT half; the soft-newline APPLY half was the empirical probe (heavier tier, like the real-claude bringup int). Contract A frozen (doyle: {text} raw-verbatim; key-vocab + {text}-verbatim doc folds into spt-core v0.15.0 W4).
-
-[[requirements]]
-id = "REQ-DIST-CHECKPOINT-COMMUNE"
-title = "Agent-driven checkpoint: a live agent flags a commune with the literal trigger !!checkpoint!! (one = default wake; a pair brackets a custom wake directive); a PostToolUse hook detects the trigger in the Write tool_input.content for .claude/<id>-commune.md, sets the perch idle (api state idle), and self-sends a reserved wire-sentinel (spt send --from <id> <id>); the message loops back through the endpoint's own translation binary, which ARMS the wake and emits CLEAR-ONLY; the wake is fired separately AFTER the clear completes (the split ordering fix — see REQ-HAZARD-CHECKPOINT-CLEAR-RACE, which supersedes the old single-sequence ctrl+s·50ms·/clear·enter·500ms·wake·enter·commit macro). spt-hosted-only. INVARIANT: the commune is authored INLINE pre-clear (ADR-0004, Shape 1), never via a post-clear resume-Self refresh."
-required_stages = ["doc", "impl", "unit", "int"]  # Feature 2 / task T2 — ACTIVATED 2026-06-24. WIRE-SENTINEL is now spt-core v0.15.0 `spt send --json-payload '{"checkpoint":"v1","wake":…}'` (doyle, grounded in the gated W4 code) — a structured json ATTR on the <EVENT> envelope, NOT the old string-prefix sniff (collision-proof: the marker lives inside the opaque attr, can't forge from/type). doc: full-fat /sptc:commune SKILL.md (--checkpoint: single trigger=default wake, paired triggers bracket a custom wake) + ADR-0004 + the checkpoint [[hints]] entry. impl: cc-spt-idle-translate checkpoint branch (extract json attr -> xml-attr-unescape (&amp; LAST) -> serde parse -> checkpoint=="v1" -> clear+wake macro ctrl+s·50ms·/clear·enter·500ms·wake·enter·commit, default "Proceed with next steps") + NEW PostToolUse hook (manifest [hooks.PostToolUse] + hooks.json Write-matcher + post-tool-use.sh detector: !!checkpoint!! scan of tool_input content -> api state idle -> self-send --json-payload) + _common.sh pure helpers (sptc_has_checkpoint/sptc_checkpoint_wake/sptc_is_commune_write). unit: hooks-parse.sh checkpoint tests + the crate's checkpoint macro/parse/unescape tests. int: ci/idle-translate/translate-proof-int.sh checkpoint block (envelope w/ json attr fires the clear+wake macro, custom + default wake, normal delivery never clears) — the deterministic EMIT half. The LIVE self-send loopback (real `spt send --from <id> <id> --json-payload '{"checkpoint":"v1","wake":…}'` -> json envelope attr -> binary -> /clear+wake) was VALIDATED on-node 2026-06-24 on spt 0.15.0: a spt-hosted CC transcript showed the macro fire E2E (user turn `/clear`, next user turn = the wake). DEFERRED dogfood (NOT CI, logged in CHECKPOINT-COMMUNE-PLAN.md §Deferred validations): the PostToolUse WRITE-DETECT E2E — the hook detecting `!!checkpoint!!` in a Write + self-sending — needs the NEW plugin installed + real CC. The write-side !!checkpoint!! marker is one-shot (spt-core v0.15.0 strips it from durable+pending on ingest). min_spt_core BUMPED to 0.15.0 (manifest v0.7.0). Self-send loopback PROVEN 2026-06-24.
-
-[[requirements]]
-id = "REQ-TAG-PEER-MESSAGING"
-title = "An agent messages peers WITHOUT the Bash tool by embedding `@<t1,t2,t3 body @>` in its turn output: `@<` opens, the comma-separated target list runs to the first whitespace (no internal spaces), the body runs to the first `@>` (non-greedy, no escaping v1); a bare `@@id` is deliberately inert (prose discussing the syntax must not false-fire). A PreToolUse (mid-turn) + Stop (backstop) scan pulls the endpoint's own finalized digest output newer than a seq cursor (`endpoint digest <self> --after <cursor> --json`, `entries[].Agent.text` with a `seq`), dispatches `spt send --from <self> <target>` per valid target (self-target dropped+noted; unknown/offline surfaced via NO_PERCH, never silent-dropped; delivered = SENT/QUEUED/DEFERRED), and fires ONE confirm-back to the sender's OWN perch (`--active-only --ephemeral`, lands mid-turn) so the agent does not re-send via Bash. The seq cursor (state/digest/<eid>.seq) is the exactly-once double-send guard across both hooks — only seq-carrying (finalized) entries strictly above the cursor dispatch; a partial never fires."
-required_stages = ["impl", "unit"]  # ACTIVATED 2026-07-08 (NEXT-WORKLOAD-PLAN Item 2). impl: src/tag_scan.rs (pure grammar parse_tag_sections + seq-gated plan_dispatch) + hook.rs scan_and_dispatch wired into handle_pre_tool_use (mid-turn) and handle_stop (backstop), send_landed classifier, digest_cursor_rel cursor. unit: tag_scan.rs grammar + plan_dispatch tests + hook.rs scan_and_dispatch wiring tests (multi-target dispatch, unreachable-surfaced, self-drop, cursor advance, no-op-when-current). int DEFERRED (same harness-glue bucket as the other live E2Es — needs the built binary bounced onto a live endpoint): an agent emitting `@<doyle …@>` actually delivers to doyle + the confirm-back lands. Built on the published surface only (`endpoint digest --after`, `spt send --from/--active-only/--ephemeral` all verified present in spt 0.29.0) — adapter wiring, not an spt-core gap.
-
-[[requirements]]
-id = "REQ-COMMUNE-OUTPUT-SHORTCUT"
-title = "An agent writes its commune WITHOUT the Write tool by starting an output with `>>commune<<` (after leading whitespace); the rest of that output is the commune body, written to `.claude/<id>-commune.md` under the session cwd — the same file the /sptc:commune Write path targets, so the daemon's watch ingests+deletes it identically. The existing `!!checkpoint!!` in-body marker is reused for the checkpoint escalation (no new keyword): a commune body carrying it fires the same idle + checkpoint self-send loopback as the Write-path PostToolUse handler. COLLISION RULE (meta-recursion guard): once an output is a commune it is NOT scanned for `@<…@>` — a commune may quote the messaging syntax verbatim without dispatching."
-required_stages = ["impl", "unit"]  # ACTIVATED 2026-07-08 (NEXT-WORKLOAD-PLAN Item 2). impl: tag_scan::commune_body detector + plan_dispatch commune routing (suppresses tag scan) + hook.rs scan_and_dispatch commune leg (write_commune_file to cwd .claude/<id>-commune.md via write_spill; has_checkpoint→checkpoint_payload/checkpoint_wake reuse). unit: tag_scan.rs commune_body tests (start-only, leading-ws, checkpoint-preserved) + plan_dispatch commune-suppresses-tags test + hook.rs scan_commune_shortcut_writes_file_and_escalates_checkpoint. int DEFERRED (needs the built binary on a live endpoint + daemon watch): a `>>commune<<` output actually ingests as the commune. Reuses the proven checkpoint loopback (REQ-DIST-CHECKPOINT-COMMUNE); built on the published surface only.
-
-[[requirements]]
-id = "REQ-COMMUNE-CONTEXT-TIER-SLICING"
-title = "The two adapter-authored commune prompts must teach the two-slice context envelope so spt-core routes context per-agent-per-project instead of dumping everything in the live tier. spt-core ingests a commune (and the echo-commune summary) into durable tiers — `<live-context>` (agents/<id>/live-context.md, cross-project identity) and `<project-context>` (projects/<proj>/<id>/project-context.md, this-project detail), the same tiers `psyche-download` re-emits on resume — and routes by these tags; UNTAGGED text defaults to the live tier, so an unsliced commune pollutes the durable identity with project-specific noise that also leaks across projects (doyle finding 2026-07-08). FIX (prompt-only, both authoring paths): (1) the live-agent commune brief (adapter/strings/briefs/live-ops.md) instructs the agent to wrap project detail in `<project-context>…</project-context>` and cross-project/role context in `<live-context>…</live-context>`; (2) the echo-commune summarizer directive (echo_commune.rs compose_prompt) emits the same two slices for the no-signoff auto-summary. Untagged-defaults-to-live is stated in both so partial tagging is safe. The `<project-context-resolved name/>` sentinel is core-emitted OUTPUT only — never agent-authored."
-required_stages = ["impl", "unit"]  # MINTED + ACTIVATED 2026-07-08 (doyle two-slice finding; folded into v0.17.3). impl: tools/claude-spt/src/echo_commune.rs compose_prompt two-slice directive + adapter/strings/briefs/live-ops.md commune brief two-slice guidance (both authoring paths). unit: echo_commune.rs prompt_teaches_context_tier_slicing (asserts both `<project-context>`/`<live-context>` slices + the default-tier rule in the summarizer directive). Prompt-only; the ingest routing itself is spt-core's (published tier contract, CHECKPOINT-COMMUNE-PLAN §STDOUT). No int (behavioral routing is core-side; the adapter's obligation is the prompt text)."
-
-[[requirements]]
-id = "REQ-HAZARD-SEND-STATUS-STDERR"
-title = "The tag-send classifier must read `spt send`'s result token from STDERR, not stdout. `spt send` emits its `SENT`/`QUEUED`/`DEFERRED`/`NO_PERCH:` status on STDERR (stdout is empty) — the adapter's stdout-only `HookEnv::spt` helper (which nulls stderr) therefore saw `\"\"` for EVERY peer send and `send_landed(\"\")` classified it as unreachable, so the confirm-back reported `NO PERCH (not delivered)` for messages that HAD delivered (field 2026-07-08: every hook-driven `@<peer …@>` tag-send wrongly reported NO_PERCH though the peer received it; a direct interactive `spt send` looked fine only because the operator's terminal shows stderr). Self-target confirm-back was unaffected only because it ignores its own result. Root-caused offline via an isolated hook-binary rig: the peer-send child returned `raw=Some(\"\")` while stderr carried `SENT:doyle`. FIX: a dedicated `HookEnv::spt_send` that captures stdout+stderr merged (token found wherever spt-core emits it); scan_and_dispatch classifies peer sends through it. This is an spt-core contract observation (send status on stderr is undocumented in the harness-contract/CLI reference) filed to doyle — the adapter adapts regardless."
-required_stages = ["impl", "unit"]  # MINTED + ACTIVATED 2026-07-08 (operator RCA directive; v0.17.3). impl: tools/claude-spt/src/hook.rs HookEnv::spt_send (SysEnv captures both streams, merged; trailing newlines stripped) + scan_and_dispatch peer-send switched from spt to spt_send. unit: hook.rs scan_classifies_send_by_stderr_token_not_empty_stdout (Recorder with_send_responder models empty-stdout + stderr-token; asserts the confirm-back body reports `delivered → lia`, never NO PERCH — FAILS on the old stdout-only path). int DEFERRED to the live-verify window: an agent emitting `@<lia …@>` on a bounced endpoint gets a `delivered → lia` confirm-back (the exact field scenario). Public-surface only — adapter stream-handling, and the stderr-status finding is logged for doyle."
-
-[[requirements]]
-id = "REQ-DIST-RESUME-CONTEXT"
-title = "claude-spt SessionStart pulls the live agent resume context via the v0.15.0 `spt api psyche-download <self-id> [--session-id <sid>]` verb and injects stdout as additionalContext (skip on NO-CONTEXT) — closing a pre-existing parity gap (claude-spt rehydrates NO durable context today; F-020). One call returns durable role/live/project tiers + the freshest not-yet-synthesized <pending-commune>/<pending-signoff> (trigger stripped core-side); it is also the checkpoint re-seed fast-path."
-required_stages = ["impl", "unit", "int"]  # Parity wiring / task T3 — impl+unit ACTIVATED 2026-06-24 (coded against FROZEN contract B); int ACTIVATED 2026-06-24 when spt-core v0.15.0 (counter 34) PUBLISHED + verified on-node (doyle gate ruling: the CORE-CONTRACT half is deterministic CI, the SessionStart INJECTION E2E is logged dogfood). impl: session-start.sh bind|boundary brief branch -> sptc_psyche_download (mirrors `api poll` id-scoped auth: --session-id, no --project — project resolves from the bound cwd) + sptc_append_resume injects stdout VERBATIM below the identity brief, skip on NO-CONTEXT/empty (pre-v0.15.0 the verb is absent -> empty -> graceful skip). Fires on bind AND boundary — boundary IS the checkpoint re-seed path (post-/clear rebuild from the latest commune); the `api boundary` rotation itself is unchanged (additive pull). unit: tests/hooks-parse.sh sptc_append_resume skip-on-NO-CONTEXT tests. int: ci/psyche-download/psyche-download-int.sh — deterministic capability-detect CI against real spt 0.15.0 (NO real CC: a throwaway perch is bind-created): asserts verb-present + NO-CONTEXT (fresh perch -> exit 0, empty stdout, NO-CONTEXT:<id> stderr) + AUTH (wrong --session-id rejected) + POSITIVE (a not-yet-synthesized commune drop returned VERBATIM as <pending-commune>). GREEN on-node 2026-06-24. DEFERRED dogfood (NOT CI, logged in CHECKPOINT-COMMUNE-PLAN.md §Deferred validations): the SessionStart INJECTION E2E — session-start.sh actually consuming the pull + injecting into a live CC — needs the NEW plugin installed + real CC. No adapter-side raw-drop handling (core owns the race-free append).
-
-[[requirements]]
-id = "REQ-DIST-PRETOOL-POLL"
-title = "claude-spt wires a PreToolUse hook firing `api poll` so a live agent receives messages MID-TURN (legacy-parity reachability; today claude-spt drains only on UserPromptSubmit = between turns). F-021."
-required_stages = ["impl", "unit"]  # Reachability-parity item (F-021) — ACTIVATED 2026-06-25. Two coupled halves: (a) honest TURN-STATE lifecycle — UserPromptSubmit marks `api state busy` at turn-start, Stop marks `api state idle` at turn-end (spt-core never infers activity from quiescence — harness-contract/integration-checklist), so inbound DEFERS during a busy turn instead of idle-PTY-injecting; (b) the NEW PreToolUse hook drains those deferred messages MID-turn (`api poll {session_id} --include-deferred` -> additionalContext), the legacy spt poll+inject-on-PreToolUse reachability. UPS drain also gains --include-deferred. PreToolUse ALSO marks `api state busy` (idempotent) — the ONLY busy mark for a turn that starts WITHOUT a UserPromptSubmit (a Monitor-delivered message triggers a new turn with no user prompt; the first tool call is the earliest turn-active signal). Residual: a non-user text-only turn marks neither (low risk — no tool/PTY interleave; Stop re-idles). impl: plugin/sptc/hooks/pre-tool-use.sh (state busy before the drain) + the `api state busy` add in user-prompt-submit.sh + hooks.json PreToolUse entry + manifest [hooks.PreToolUse] / [hooks.UserPromptSubmit] busy+include-deferred. unit: tests/hooks-parse.sh PreToolUse-reachability wiring block (PreToolUse declared + routed, deferred-drain shape, UPS busy + include-deferred, Stop idle, manifest [hooks.PreToolUse]). int DEFERRED (same bucket as the other harness-glue E2Es — needs the NEW plugin installed + a real live CC): a mid-turn `spt send` to a busy live agent surfaces as additionalContext on the next tool call. `api state` + `api poll --include-deferred` are already on the public surface — adapter wiring, NOT an spt-core gap. Shapes verified against the published integration-checklist 2026-06-25.
-
-[[requirements]]
-id = "REQ-DIST-WORKER-PERCH-REACH"
-title = "Subagent worker perches are runtime-REACHABLE: a `spt send` to a nested worker perch (created by subagent-start.sh -> api worker-start; hostable_types includes Worker) actually delivers. Validates existing wiring; F-022."
-required_stages = []  # Reachability-parity validation (F-022). ACTIVATE at the reachability-parity milestone. int: bring up a CC session, spawn a subagent, confirm the worker perch appears in the roster + `spt send <worker-id>` delivers (worker-poll drains). Wiring is present (subagent-start.sh + hostable Worker); runtime reachability is the only open question.
-
-# ─────────────── UNIFY-CONSOLIDATE wave (planned 2026-06-24, UNIFY-CONSOLIDATE-PLAN.md) ───────────────
-# ADR-0005 (name unification) + ADR-0006 (one-command update + consolidated binary), doyle-independent
-# half (U1–U6). Target release: adapter v0.8.0. All MINTED inactive (required_stages = []) per the
-# activate-don't-pre-fail model; each U-task ACTIVATES its REQ (sets real stages) when its build starts.
-
-[[requirements]]
-id = "REQ-DIST-UPDATE-MESSAGE"
-title = "The adapter manifest [update] table carries a `message` markdown field, printed by spt-core ONLY on a real version apply: it tells the user to run /reload-plugins (the unavoidable TUI step) and points at the more-powerful `spt` CLI endpoint route (`spt endpoint run`) alongside /sptc:live. U1."
-required_stages = ["impl", "unit"]  # U1 (the [update].message field) ACTIVATED 2026-06-25; D2 ([update.post] composite) PROMOTED to +impl 2026-06-26 (spt-core v0.16.0). impl: tools/claude-spt/src/post_update.rs — the [update.post] stdin/stdout contract (update_applied_in parses the additive JSON context; arbiter_line emits the `!!update-message!!` sentinel on a successful reconcile so the static [update].message fires; diagnostics→stderr, stdout=arbiter; fail-isolated; three modes incl --dry-run). The manifest seams [update].message + [update.post]{command="{adapter_dir}/claude-spt post-update", self_verifies=false} are .toml (unscanned) — evidence is the unit assertions. unit: tests/manifest-shortcut.sh (message present + /reload-plugins notice + [update.post] table/command) + the crate's cargo tests (update_applied_in additive parse, arbiter_line sentinel/empty) + tests/manifest-schema.sh (validates against the re-vendored v0.16.0 schema with update.post). doc DEFERRED to the docs-site slice (designed in docs/adr/0006 + UPDATE-NAMING-DOYLE-ASKS.md). int DEFERRED to the publish dogfood: real `spt adapter update claude-spt` pulls the .spt then fires [update.post] → post-update reconciles the plugin → sentinel → [update].message prints (needs the v0.8.0 release published).
+title = "One multi-platform adapter.spt ships the manifest, native OMP extension, and omp-spt binary through BigscreenVR/omp-spt releases"
+required_stages = ["doc", "impl", "unit", "int"]
 
 [[requirements]]
 id = "REQ-DIST-BINARY-CONSOLIDATE"
-title = "claude-spt-digest + claude-spt-psyche merge into ONE `claude-spt` crate with clap subcommands (digest / psyche / post-update); post-update = the plugin-sync logic (detect claude|ccs CLI -> ensure cplugs marketplace -> claude plugin add|update -> print notice; does NOT run /reload-plugins). cc-spt-idle-translate stays separate (folds at D3). U2."
-required_stages = ["impl", "unit", "int"]  # U2 (the big refactor; preps post-update for D2) — ACTIVATED 2026-06-25, int promoted same day (proofs ran GREEN on the consolidated binary). impl: tools/claude-spt crate (main.rs subcommand dispatch [classify] + post_update.rs CLI-detect/marketplace/plugin reconciliation; digest+psyche folded in as subcommands) + manifest [digest].extractor `claude-spt digest …` + [session.psyche_init].command `claude-spt psyche …` + ci/digest/build.sh (canonical consolidated build) + ci/psyche/build.sh (shim, one build) + package-adapter.sh binary-set (claude-spt + cc-spt-idle-translate per triple). unit: the crate's cargo tests (37: subcommand classify dispatch + the ported digest/psyche tests + post-update CLI-pick / marketplace-registered / plugin-installed / pathext / notice). int: ci/digest/digest-proof-int.sh — `spt adapter digest-proof claude-spt --dir tools/claude-spt …` ran the consolidated binary's `digest` subcommand end-to-end through real spt (DIGEST_PROOF_OK, 5 parsed/0 dropped) — GREEN on-node 2026-06-25 on spt 0.15.0; the separate cc-spt-idle-translate stays green via translate-proof-int. tests/adapter-archive.sh [unit] asserts the archive packs the 2 binaries per triple. Old claude-spt-digest/claude-spt-psyche crates DELETED (evidence moved to tools/claude-spt). NB hand-rolled argv[1] dispatch, NOT clap (deviation from the JIT plan's "clap subcommands" — honors both predecessor crates' deliberate dependency-light ethos; a flat 3-way dispatch needs no framework). post-update is standalone-runnable + tested now but [update] can't invoke it until doyle ask #2 (D2).
-
-[[requirements]]
-id = "REQ-DIST-NAME-UNIFY"
-title = "GitHub repo renamed spt-claude-code -> claude-spt; [update].repo, README, CI, package scripts, every SaberMage/claude-spt reference + install-dir test assumptions (_github/SaberMage-claude-spt) updated. Adapter name claude-spt UNCHANGED; plugin sptc UNCHANGED this milestone (succession = D4, owl-gated). U3."
-required_stages = ["doc", "impl", "unit"]  # U3 — ACTIVATED 2026-06-25. GitHub repo RENAMED SaberMage/spt-claude-code -> SaberMage/claude-spt (`gh repo rename`, ADMIN, local remote updated). Owner-qualified ref-flip done across the OPERATIVE surface (manifest [update].repo, README install chains + agent prompt, ci/publish/{package-adapter,release-acquire-int}.sh, adapter/strings/skills/setup.md + plugin setup SKILL.md, docs/RELEASE-RUNBOOK.md, docs-site/book.toml). Historical records intentionally LEFT on the old slug (CHANGELOG past entries, docs/SPT-CORE-FINDINGS.md, docs/adr/0005 transition narrative, *-PLAN.md snapshots) — they record what was true then. Adapter name claude-spt UNCHANGED; plugin sptc UNCHANGED (succession = D4, owl-gated). doc: docs/adr/0005 ([doc->REQ-DIST-NAME-UNIFY], status notes the executed rename). impl: ci/publish/package-adapter.sh ([impl->REQ-DIST-NAME-UNIFY], release/install/update target = claude-spt). unit: tests/manifest-shortcut.sh ([update].repo == SaberMage/claude-spt + no stale slug regression guard). int DEFERRED to the v0.8.0 cut: a clean `spt adapter add --release SaberMage/claude-spt` re-acquires + runs on-node (release-acquire-int.sh, slow lane). No tests/ carried the old install-dir safe-name (verified). Cut (version bump + CHANGELOG + cplugs skeleton bump + publish) is HELD — operator-gated part 3.
-
-[[requirements]]
-id = "REQ-DIST-SKELETON-THIN"
-title = "commune/send/signoff skill bodies move OUT of the plugin SKILL.md (stubs: frontmatter + 'live agents only — /sptc:live first') and INTO adapter strings: a new perched SessionStart brief string (commune incl. --checkpoint, signoff) + the existing /sptc:live UPS body for the go-live moment, so reactive-skill prose rides `spt adapter update`. U4."
-required_stages = ["doc", "impl", "unit"]  # U4 — ACTIVATED 2026-06-25. Design Q RESOLVED: /sptc:live upgrades the session IN-PLACE (bare `spt api listen`), no Claude Code restart -> SessionStart does NOT re-fire; so the go-live guidance rides the /sptc:live UPS body, the perched brief only fires on bind/boundary. Both carry commune/signoff now. doc: thinned plugin/sptc/skills/{commune,send,signoff}/SKILL.md stubs ([doc->REQ-DIST-SKELETON-THIN]) + new adapter/strings/briefs/live-ops.md (commune incl --checkpoint + signoff) + the expanded go-live body adapter/strings/skills/live.md. impl: _common.sh sptc_perch_brief composes the live-ops brief into the perched SessionStart brief (appended to the messaging block — keeps sptc_assemble_perch + its test unchanged) + [strings.briefs].live-ops registration. unit: tests/hooks-parse.sh U4 block (live-ops carries commune+checkpoint+signoff, perch-brief composes it, manifest registers it, go-live body inlines it, the 3 SKILL.md are thin stubs, the pre-U4 full bodies removed). int DEFERRED: the perched brief carrying live-ops resolves through the live registry — folds into the REQ-DIST-SESSIONSTART-BRIEF brief round-trip int (still PENDING) once the published adapter carries briefs.live-ops. send's core (send/reply) already rode the messaging-perch brief; commune/signoff were full-fat in the plugin SKILL.md (the 2026-06-19 decision U4 supersedes). NB: SKILL.md + hooks (PreToolUse) changes are structural -> ONE cplugs skeleton bump at the v0.8.0 cut.
-
-[[requirements]]
-id = "REQ-DIST-INSTALL-UX"
-title = "README ships platform-specific install chains (cmd / PowerShell / bash) — check-for/install spt-core (call the spt-releases per-platform install script; claude-spt may be a user's first spt-core exposure) then `spt adapter add --release SaberMage/claude-spt` — plus a copy-paste agent prompt (the casual-user skin) running the chain in one sequenced Bash call, symmetric with the update lever. U5."
-required_stages = ["doc"]  # U5 — ACTIVATED 2026-06-25. doc-class (install instructions, like the REQ-SETUP-* skills — no adapter-side code of its own): README.md (added to [scan] roots) carries the per-OS install chains (bash / PowerShell / cmd: install spt-core via the published spt-releases script, then `spt adapter add --release SaberMage/claude-spt`) + the copy-paste agent-prompt skin + the symmetric `spt adapter update claude-spt` lever. doc tag rides README.md. llms.txt sync is unaffected (it derives only from docs-site/SUMMARY pages; gen-llms.sh) — the docs-drift gate stays green. Repo slug stays SaberMage/claude-spt until the U3 rename flips every reference at the v0.8.0 cut.
-
-[[requirements]]
-id = "REQ-DIST-CCS-PLUGIN-FOLLOWUP"
-title = "When `ccs` is installed alongside `claude`, the post-update plugin reconcile ALSO runs `ccs plugin update sptc@cplugs` (best-effort): ccs-launched sessions read their own per-account plugin tree (the CLAUDE_CONFIG_DIR relocation, ~/.ccs/instances/<account>/.claude), which the claude-side reconcile never touches — without the follow-up a ccs session keeps running the STALE plugin after every `spt adapter update`. Not fired when ccs is absent or when ccs IS the primary CLI (already reconciled). Best-effort by design: `update` (never `install` — a ccs account that never installed the plugin is not this reconcile's call), failure → stderr noise only, NEVER a post-update failure and NEVER the stdout arbiter channel. Operator ask 2026-07-01 (v0.10.3)."
-required_stages = ["impl", "unit"]  # MINTED + ACTIVATED 2026-07-01 (v0.10.3, operator ask mid-cut). impl: tools/claude-spt/src/post_update.rs — ccs_followup_needed (pure gate: has_ccs && primary != ccs) + ccs_followup_cmd (plugin update sptc@cplugs) + the best-effort spawn block in run() (after the primary reconcile, before the arbiter print; dry-run prints `would run: ccs plugin update sptc@cplugs`); spawns via launch.rs resolve_program_from (the npm ccs.cmd shim is unspawnable from a bare name on Windows — the same wall the launch shim hits; the primary reconcile spawn is ALSO resolved now, fixing the latent ccs-primary case). unit: the post_update.rs cargo test ccs_followup_only_when_ccs_present_and_not_primary (gate truth table + update-never-install argv). int DEFERRED: real `spt adapter update` on a dual-CLI node shows the follow-up line + a ccs session picks up the new plugin (on-node dogfood at the v0.10.3 cut — this node IS dual-CLI).
-
-[[requirements]]
-id = "REQ-DIST-RC-STARTUP"
-title = "Every spt-hosted CC bringup — [session.self] (fresh) AND [session.resume] (native-resume), base AND ccs profile — is NODE-AND-PROJECT-NAMED: display name `-n \"<id> @ <node> (<project>/)\"` + Remote Control `--remote-control <id>--<node>--<project-token>`, so a fleet of endpoints is cross-node- AND cross-project-distinguishable in the prompt box / /resume picker / RC list. Delivered ADAPTER-SIDE via the `claude-spt launch` spawn shim (v0.10.3+): the published fill catalog has NO {node} key (reported spt-core gap; {node} adopted v0.20.0) and NO {project} key, so the shim computes the node label (--node fill, else COMPUTERNAME/HOSTNAME/`hostname`) and the project folder (launch-cwd basename) ON-NODE and passes each name as one clean argv element. The display uses the raw project name (spaces/parens/slash fine — one argv element); RC gets the tokeny `<id>--<node>--<project-token>` form with a CHARACTER-SAFE project token (alphanumeric + `-`/`_`, other runs → `_`) since space-safety of explicit RC names is unverifiable from the public surface. Unknown project ⇒ drop only its suffix; unknown node ⇒ both names degrade to bare <id>. `spt rc <id>` is unaffected (broker attaches by ENDPOINT id, not CC's RC name). U6 origin: the {id}-only -n/RC threading."
-required_stages = ["impl", "unit"]  # U6 ACTIVATED 2026-06-25 ({id}-only, unit-only declaration seam). PROMOTED to impl+unit 2026-07-01 (v0.10.3): the stretch shipped adapter-side, so there is now scannable impl. impl: tools/claude-spt/src/launch.rs — Args parse (--id/--cli/--resume/--node), node_name (COMPUTERNAME → HOSTNAME → `hostname`), project_name (launch-cwd basename), rc_project_token (RC-safe sanitizer), display_name/rc_name (drop project suffix on unknown project, degrade-to-bare-id on unknown node), cli_argv ([-r sid] -n <display> --remote-control <rc> --dangerously-skip-permissions), Windows PATHEXT resolution (npm ccs.cmd shim unspawnable from a bare name), unix exec()/windows spawn+wait. Manifest seams (unscanned .toml): all four session commands = `{adapter_dir}/claude-spt launch [--cli ccs] --id {id} --node {node} [--resume {session_id}]`. unit: the launch.rs cargo tests (name shapes incl the (<project>/) display + <project-token> RC, rc_project_token sanitization, unknown-project/unknown-node degrade, fresh/resume argv, parser loudness, per-OS resolution) + tests/manifest-shortcut.sh (4 launch spawn lines, --id {id} on all, no bare claude/ccs bypass, shim emits -n/--remote-control + skip-perms cross-file guards). doc DEFERRED to the docs-site harness-contract RUN-group slice. int DEFERRED: a fresh `spt endpoint run` endpoint presents `<id> @ <node> (<project>/)` in the CC prompt box + stays `spt rc <id>`-attachable; on-node dogfood at the cut. {node} fill-key gap CLOSED by spt-core v0.20.0 (counter 40; doyle release ping 2026-07-02) and ADOPTED in v0.11.0: all four launch commands pass `--node {node}` (the daemon's ADVERTISED label — operator-set label ≠ raw hostname, so session names match the rest of the spt surface), keys lists declare "node", floor → 0.20.0. The shim STAYS as predicted (space-carrying display name remains untemplatable — single-token fills, doyle caveat) with hostname detection demoted to FALLBACK; a blank or literally-unsubstituted `{node}` (F-013 gap class) collapses to that fallback (launch.rs parses + guards; unit: parses_node_as_the_advertised_label + unsubstituted_or_blank_node_collapses_to_fallback; manifest shape: tests/manifest-shortcut.sh --node/{node}-keys assertions).
-
-[[requirements]]
-id = "REQ-DIST-BOUNDARY-ROTATE"
-title = "The /clear|compact SessionStart boundary rotation actually rotates the perch: the hook resolves the endpoint id via $SPT_ENDPOINT_ID FIRST (whoami-by-NEW-sid is a catch-22 — the new sid is unregistered until this very call succeeds, so it resolves self:null and the old code silently skipped rotation), persists the CURRENT session id to an adapter-owned state file ({adapter_dir}/state/session/<endpoint_id>.sid) at EVERY SessionStart, and presents the PRIOR session's sid from that file as the boundary auth proof (`--session-id <prior>`; the verb refuses `AUTH_REFUSED (need --token or matching --session-id)` without it — the departed session's env is gone, so a state file is the only carrier). doyle ruling F024D-BOUNDARY-RULING 2026-07-02: adapter-owned state is the contract-clean surface (glue-model, ADR-0021 family); NOT CLAUDE_ENV_FILE (per-session, dies with the rotation — the exact failure being fixed)."
-required_stages = ["impl", "unit", "int"]  # MINTED + ACTIVATED 2026-07-02 (F-024 correction arc; operator clean-room repro: fresh session + /clear wedges with zero hook errors). impl: tools/claude-spt/src/hook.rs — sid_state_rel (pure path builder, id sanitized), the boundary branch ($SPT_ENDPOINT_ID-first id, prior-sid proof read, spt_strict call), the every-SessionStart sid persistence after registration, HookEnv read_adapter_state/write_adapter_state/spt_strict seams (SysEnv resolves against current_exe dir). unit: boundary_prefers_endpoint_id_and_presents_prior_proof + boundary_persists_new_sid_for_next_rotation + bind_persists_sid_as_rotation_proof + sid_state_rel_shape_and_sanitize (Recorder-driven). int PROMOTED 2026-07-02 (doyle verdict E2E-0104 GREEN — HFENDULEAM, adapter 0.10.4, spt-core 0.19.1, endpoint hall-a): /clear on a real spt-hosted endpoint → info.json.session_id ROTATED (prior-sid auth accepted) + state/session/hall-a.sid ROLLED FORWARD in lockstep + post-rotation `spt send` DELIVERED with the true-injection token (rotation+delivery validated, not the brief — the v0.10.1 lesson). Evidence record: docs/SPT-CORE-FINDINGS.md F-024 closure block (live E2E, not scriptable in CI — needs a real spt-hosted CC issuing /clear). ENLYZEAM re-run = same assertions when the operator executes there; cross-node WAN delivery gated on BUILD-F023-WANIDLE (F-023, spt-core court).
-
-[[requirements]]
-id = "REQ-HAZARD-STALE-PLUGIN-RESOLUTION"
-title = "The adapter stays SAFE and DIAGNOSABLE when the harness resolves a STALE cached plugin version at session boot (observed live: ENLYZEAM booted the 0.1.8 dispatch 24 min after 0.1.9 was installed — F-024 domino #1; the buggy dispatch corrupted the per-session CLAUDE_ENV_FILE, which survives every resume, so ONE bad boot poisons the session lifetime and swallowed the /clear boundary). The harness picker is not adapter-controllable; the adapter therefore (a) degrades-never-bricks under any dispatch×adapter version pairing (the §3.1 lockstep invariant is the binding half), (b) minimizes the stale-pickable set — post-update reconcile reaches EVERY plugin root the node's CLIs read (claude config root + each ccs instance root) and superseded cached copies are purged or flagged, and (c) surfaces WHICH plugin version actually ran at least once per session (a stale pick must be a log line, not an ssh dig). CC-side root cause (resolver lag/pin/orphaned-dir) stays an open perri-court question."
-required_stages = ["doc"]  # MINTED + doc-ACTIVATED 2026-07-02 (doyle ask off the F-024 arc: hazard writeup). doc: docs/KNOWN-HAZARDS.md §3.2. Halves already shipped ride their own REQs (reconcile = REQ-DIST-CCS-PLUGIN-FOLLOWUP + the v0.10.2 post-update work; degrade = REQ-HAZARD-HOOKCMD-DISPATCH-LOCKSTEP, stages [] until its guard slice). The NEW halves — stale-copy purge/flag + per-session plugin-version surfacing — are unbuilt guard-slice work: add impl/unit here when that slice starts (activate, don't pre-fail).
-
-[[requirements]]
-id = "REQ-HAZARD-SESSION-PIN-WEDGE"
-title = "A missed/failed boundary rotation must NEVER be silent: the rotation verb demands the DEPARTED session's proof, and a silently-skipped or silently-refused rotation pins the perch to a dead session id — after which EVERY id-scoped api call (poll/state/boundary) from the live session is AUTH_REFUSED (stderr-only) with NO self-heal: the endpoint looks healthy (brief renders, session runs) while cross-node AND local delivery is permanently dead (the F-024 ENLYZEAM wedge, root-caused 2026-07-02). The hook binary therefore logs LOUDLY on (a) an unresolvable endpoint id at boundary time (skip = strand) and (b) a failed/refused boundary call (surfacing the AUTH_REFUSED reason), and never skips silently. Core-side self-heal (dead-owner re-pin does NOT cover /clear — the harness pid stays alive, refusal is correct squat protection) is doyle's parked Track-2 design; the adapter's prior-sid proof is THE fix for live rotation."
-required_stages = ["doc", "impl", "unit"]  # MINTED + ACTIVATED 2026-07-02 (doyle KH cross-ref, F024D-BOUNDARY-RULING). doc: docs/KNOWN-HAZARDS.md §2 entry (rotation-wedge invariant). impl: tools/claude-spt/src/hook.rs boundary branch — the loud-skip and loud-refusal env.log paths (no silent return). unit: boundary_empty_id_is_loud_never_silent + boundary_refusal_is_loud_with_reason (Recorder asserts the log lines exist and no boundary call / a failed call respectively). The wedge RECOVERY path (relaunch-without-/clear rebinds the recorded sid) is operator guidance in the KH entry, live-proven on ENLYZEAM 2026-07-02.
-
-[[requirements]]
-id = "REQ-HAZARD-CHECKPOINT-CLEAR-RACE"
-title = "The checkpoint clear+wake must NEVER submit the wake before /clear takes effect. A single inject sequence cannot straddle a /clear (the async clear re-runs SessionStart with network I/O, and every sequence must {commit} within the 5s INJECT_COMMIT_DEADLINE), so a fixed post-/clear delay races and the wake lands in the OLD session (field-observed: the followup hit first). The macro is SPLIT and synchronized on CC's own clear-done signal: (ARM) a {\"checkpoint\":\"v1\",…} envelope stashes the wake in the translation binary's in-memory pending_wake and emits CLEAR-ONLY (ctrl+s · 50ms · /clear · 50ms · enter · commit); (FIRE) the SessionStart hook, on a `clear` boundary, UNCONDITIONALLY self-sends {\"checkpoint_fire\":\"v1\"} and the binary emits WAKE-ONLY (ctrl+s · 50ms · wake · 50ms · enter · commit) iff a wake is armed, else no-ops. State lives ONLY in translate memory (no marker file; the hook is stateless). BOTH self-sends use --force-native so the signal is delivered through the translation binary's stdin (where the markers parse), never spooled to the active-poll channel (the ENLYZEAM plain-text misdelivery mode). Ordering is guaranteed by construction: the wake can only emit after SessionStart, which only fires after /clear completes. Residual (accepted v1): if the checkpoint's own clear fails to fire the signal, the armed wake fires on the NEXT clear — self-limited by the every-clear-fire model, documented in KNOWN-HAZARDS. Fires ONLY on `clear`, not `compact` (no checkpoint variant leverages /compact)."
-required_stages = ["doc", "impl", "unit", "int"]  # MINTED + ACTIVATED 2026-07-03 (checkpoint-clear-race fix, CHECKPOINT-CLEAR-RACE-PLAN.md). doc: docs/KNOWN-HAZARDS.md entry (the ordering invariant + the accepted orphan-wake residual). impl: tools/claude-spt/src/translate.rs — commands_for_clear (ARM emit) + commands_for_wake (FIRE emit) replace commands_for_checkpoint, is_checkpoint_fire parses {\"checkpoint_fire\":\"v1\"}, dispatch_event threads pending_wake (arm stores wake+emits clear-only; fire drains wake+emits wake-only or no-ops), CLEAR_DELAY_MS retired; tools/claude-spt/src/hook.rs — handle_post_tool_use adds --force-native to the checkpoint self-send, handle_session_start on a `clear` boundary marks idle + self-sends {\"checkpoint_fire\":\"v1\"} --force-native (checkpoint_fire_payload helper). unit: translate arm-emits-clear-only + fire-emits-wake-only-and-disarms + fire-with-no-wake-answers-bare-commit (was fire-with-no-wake-noops; re-anchored to REQ-HAZARD-EMPTY-RESPONSE-COMMIT for the terminator half) + arm-overwrites-pending + normal-delivery-unchanged; hook clear-boundary-fires-force-native + non-clear-does-not-fire + checkpoint-send-is-force-native (Recorder). int: ci/idle-translate checkpoint block asserts ARM emits clear-only (no wake) and a subsequent FIRE emits the wake (ordering: wake AFTER clear, never before). LIVE SUCCESSOR: ci/idle-translate/wake-survival-int.sh — real-box E2E driving a bound CC session through an actual /clear boundary, proving the wake EXECUTED via a side-effect file the woken session writes (broker-PTY sessions leave no transcript — side-effect proof is the only ground truth). GREEN on-node as wakefin3 (spt-core 0.24.0 + adapter 0.13.3, 2026-07-04, five-layer stack); SPTC_ACCEPTANCE-gated live-verify, not in run-gates."
-
-[[requirements]]
-id = "REQ-HAZARD-EMPTY-RESPONSE-COMMIT"
-title = "EVERY event-typed delivery the translation binary answers must terminate with a {commit} — including deliveries it deliberately answers with no keystrokes (a checkpoint_fire with nothing armed; an event without an envelope). An event answered with ZERO records leaves the broker's inject sequence unterminated → the 5s INJECT_COMMIT_DEADLINE expires → TRANSLATION_FAULT terminates the binary (pinned 2026-07-04 via doyle's 3-discriminant collab, iso wtrace stderr: fault follows the DUPLICATE fire, not the ARM; the ARM's commit was accepted). Because the SessionStart hook self-sends checkpoint_fire on EVERY clear (stateless by design), the unarmed-fire zero-record answer killed the binary at every non-checkpoint /clear boundary — the deterministic half of the B6 ghost. Scope is EVENT-typed responses ONLY: init/input/unknown stdin lines are protocol lines, not inject deliveries — an unsolicited {commit} outside a sequence is protocol noise and they stay silent (doyle-confirmed scoping 2026-07-04). Joint contract gap, not an adapter misread: the published harness contract documents {commit} as the sequence terminator but nowhere states an empty response still requires a bare {commit}, and its missed-commit consequence text is stale (says raw-inject fallback, removed core-side v0.14.3; truth = fault + terminate). Core-side docs amendment + explicit empty-response rule + miss!=fault deadline semantics ride doyle's C-1 chunk."
-required_stages = ["doc", "impl", "unit", "int"]  # MINTED + ACTIVATED 2026-07-04 (v0.13.1, the (B) zero-record pin); int ACTIVATED 2026-07-04 (core C-1 landed in spt-core 0.24.0). doc: docs/KNOWN-HAZARDS.md §2.7. impl: tools/claude-spt/src/translate.rs — dispatch_event's unarmed-fire branch + dispatch_line's event-without-envelope branch each answer vec![{commit:true}] instead of Vec::new(). unit: fire_with_no_armed_wake_answers_a_bare_commit + event_without_envelope_answers_a_bare_commit + non_event_lines_stay_silent_no_stray_commit (the scoping half — no stray commit on init/input/unknown). int: ci/idle-translate/wake-survival-int.sh — the deferred live every-clear-boundary survival assert, GRADUATED now core C-1 (miss!=fault) + C-2 (ready-restrand) shipped in spt-core 0.24.0. It drives a real /clear boundary and asserts the translate binary is ALIVE afterward — the every-clear zero-record kill (the deterministic half of the B6 ghost) would have terminated it. GREEN on-node as wakefin3 (box 0.24.0 + adapter 0.13.3, 2026-07-04); committed script is the reproducible SPTC_ACCEPTANCE-gated form (live-verify, not run-gates)."
-
-[[requirements]]
-id = "REQ-DIST-BOUNDARY-RENAME"
-title = "Every /clear boundary on an spt-hosted endpoint RE-ASSERTS the session display name (the boundary rename): CC drops the `-n \"<id> @ <node> (<project>/)\"` display name when a clear rotates the session, leaving the operator no rendered TUI anchor. The launch shim exports the computed display name as SPT_SESSION_NAME into the spawned CC env (single computation site — the same string that feeds `-n`, parity by construction); the SessionStart hook, on a `clear` boundary, self-sends {\"rename\":\"v1\",\"name\":\"<display name>\"} --force-native BEFORE the {\"checkpoint_fire\":\"v1\"} signal; the translation binary STASHES the name on the rename delivery (answering the mandatory bare {commit}) and emits the rename keystrokes as the FIRST HALF of the fire's ONE COMBINED post-clear sequence (ctrl+s . 50 . `/rename <name>` . 50 . enter . 150ms enter->ctrl+s bridge . ctrl+s . 50 . wake . 50 . enter . commit) — REVISED v0.15.1: the original design emitted rename and wake as two back-to-back inject sequences, which RACED at the just-rebuilt post-clear boundary (CC input processing lags the PTY stream; the rename's enter registered as a soft newline, the next sequence's ctrl+s failed to stash the residue, and the wake text submitted INSIDE the /rename argument — flynn 2026-07-06, session titled with the wake, NO wake turn, agent dormant ~9.5h, ~33% observed rate). The single sequence removes the inter-sequence race BY CONSTRUCTION; the stash NEVER touches pending wake. Ordering: rename submits before any armed wake fires (/rename is a local no-turn CC command — empirically confirmed 2026-07-05: inline rest-of-line arg, renames the CURRENT session, no agent turn). Missing SPT_SESSION_NAME (pre-0.14.1 spawn, non-shim spawn) => the hook SKIPS the rename send with a loud RENAME_SKIP:no-name log line, never silently; heals on respawn. /compact RETAINS the name (empirically confirmed 2026-07-05) so the compact boundary sends nothing — the existing no-send invariant stands. A rename envelope with a blank/absent name answers a bare {commit} (REQ-HAZARD-EMPTY-RESPONSE-COMMIT discipline), never a stray `/rename ` submit."
-required_stages = ["impl", "unit", "int"]  # MINTED + ACTIVATED 2026-07-05 (operator ask, grill-with-docs; v0.14.1). impl: tools/claude-spt/src/launch.rs — SPT_SESSION_NAME env on the spawned Command (both unix exec + windows spawn, same display_name computation as the -n argv element); tools/claude-spt/src/hook.rs — rename_payload helper + the clear-boundary rename self-send (before checkpoint_fire) + the RENAME_SKIP:no-name loud-skip path; tools/claude-spt/src/translate.rs — rename_directive (parses {\"rename\":\"v1\",\"name\":...} from the json attr) + the Pending stash + commands_for_boundary (the combined rename/wake single-sequence emit, BOUNDARY_BRIDGE_MS enter->ctrl+s bridge, CR/LF-sanitized) wired into dispatch_event. unit: launch.rs env-argv parity test; hook.rs clear_boundary_renames_before_fire (ordering assertion) + clear_without_name_skips_rename_loud + non-clear-sends-no-rename + rename_payload shape/escaping; translate.rs rename_stashes_and_answers_a_bare_commit + fire_after_rename_only_emits_the_rename_half + checkpoint_boundary_is_one_combined_sequence_rename_then_wake (the flynn 2026-07-06 regression test: arm -> stash -> fire = ONE sequence, rename half then bridge then wake half, exactly one commit) + rename_with_blank_name_stashes_nothing + rename_name_newlines_collapse_to_spaces + normal_delivery_never_fires_rename. int: ci/idle-translate/translate-proof-int.sh rename block — the real binary fed a rename envelope answers a bare {commit} with ZERO keystrokes (the stash half; the stateful combined emit is the crate unit above) through the daemon-identical translate-proof harness (the deterministic EMIT proof; live TUI name is unobservable file-side — broker-PTY sessions leave no transcript, banked rig gap). REGRESSION NET: ci/idle-translate/wake-survival-int.sh's real /clear boundary now exercises rename-before-wake end-to-end on every acceptance run (a broken rename leg would strand the wake and go red there). LIVE VERIFY: operator visual — post-clear TUI shows the re-asserted name (the feature's whole point is the rendered anchor).
-
-[[requirements]]
-id = "REQ-DIST-WORKER-LIFECYCLE"
-title = "Subagent working perches follow the WORKER-TRUTH wave-1 contract (spt-core v0.27.0, doyle freeze 2026-07-06) and NEVER leak silently. SubagentStart (parent context) calls `api worker-start <parent> --session-id <parent sid> --agent-id <cc agent id> --agent-type <type>` — NO worker-id positional (core hard-mints `{parent}-w{N}`), NO token (operator ruling: sid-symmetric auth, registration stores the sid, stop accepts stored OR parent-current sid — /clear rotation covered from both ends). The MINTED id is read from worker-start's BARE STDOUT (machine-readable result; empty/refused = LOUD log, never silent) and persisted in adapter-owned state keyed by the CC agent_id (state/worker/<agent_id>.wid — the SubagentStop payload carries only the CC agent_id, so the mapping is the adapter's to hold; same contract-clean carrier as the F-024 sid proof). SubagentStop looks up the minted id and calls `api worker-stop <minted-id> --session-id <parent sid>` STRICTLY: a refusal is LOUD (stderr reason surfaced — the pre-0.27.0 silent-swallow leaked 100% of workers, the 2026-07-06 six-worker leak), a missing mapping is LOUD (WORKER_STOP_SKIP breadcrumb), and the state row is cleared on success. Missing agent_id on either hook = LOUD skip, never a silent no-op. Floor: min_spt_core 0.27.0 (older cores clap-reject the id-less worker-start — the doyle-accepted skew; core's registration-time floor enforcement guards the reverse direction)."
-required_stages = ["impl", "unit"]  # MINTED + ACTIVATED 2026-07-06 (WORKER-TRUTH wave-1 adapter migration, v0.15.0; supersedes the worker-* legs of REQ-DIST-HOOKS-API's original shape). impl: tools/claude-spt/src/hook.rs — handle_subagent_start (strict worker-start, minted-id stdout capture, loud-refusal/loud-empty, state persist via worker_state_rel) + handle_subagent_stop (state lookup, strict worker-stop, loud-refusal/loud-missing-mapping, state clear) + worker_state_rel (sanitized state path, sid_state_rel sibling). unit: subagent_start_mints_and_persists + subagent_start_refusal_is_loud + subagent_stop_uses_minted_id_and_clears_state + subagent_stop_missing_mapping_is_loud + subagent_stop_refusal_is_loud + missing_agent_id_is_loud_never_silent (Recorder-driven). int DEFERRED: live subagent on a 0.27.0 box — spawn a Task subagent on an spt-hosted endpoint, assert the worker perch appears (endpoint list --workers) DURING the subagent and is GONE after SubagentStop (the exact 2026-07-06 leak scenario, now with core destroy+reap); on-node dogfood at the box's 0.27.0 window.
-
-[[requirements]]
-id = "REQ-HISTORY-FETCHER"
-title = "The [history] transcript-access seam (the echo-commune's feeder — 'stays opaque + single-session and feeds the echo-commune verbatim', published contract) is declared strategy=\"fetcher\": `claude-spt history --session {session_id} --config-dir {CLAUDE_CONFIG_DIR}` locates the CC JSONL transcript with the SAME locate/precedence machinery as the [digest] fetcher (--config-dir read-var fill -> $CLAUDE_CONFIG_DIR env -> ~/.claude/projects; depth-1 then bounded-recursive slug sweep) and streams the file to stdout VERBATIM — opaque bytes, core never parses them, only the adapter's own echo_commune summarizer reads them. A literally-unsubstituted `{CLAUDE_CONFIG_DIR}` argv value is treated as absent (F-013 literal-brace guard class). Missing transcript / missing --session = LOUD stderr (HISTORY_FAIL:) + exit 1, never silent-empty stdout (an empty history would silently produce a vacuous echo-commune)."
-required_stages = ["impl", "unit"]  # MINTED + ACTIVATED 2026-07-07 (v0.15.2, ECHO-COMMUNE-PLAN.md — field-forced by flynn's psyche_host_error on core 0.28.0). impl: tools/claude-spt/src/history.rs (locate reuse from digest.rs, verbatim stream, literal-brace guard, loud-fail). unit: history.rs in-module tests (locate hit streams verbatim, missing transcript is loud exit-1, literal {CLAUDE_CONFIG_DIR} treated as absent, missing --session is loud). int DEFERRED: core-driven echo-commune round-trip on-node (needs a core that fires the summarizer — field verify at the flynn respawn window).
-
-[[requirements]]
-id = "REQ-SESSION-ECHO-COMMUNE"
-title = "The [session.echo_commune] bounded-summarizer role (published contract: 'when a session ends without a signoff, spt-core runs a bounded summarizer over the session's history so the context delta is captured anyway'; core 0.27/0.28 also spawns it from the commune-sync per-event turn — flynn 2026-07-07 field pin) is declared and shipped: `claude-spt echo-commune --id {id} --session-id {session_id}` accepts history on STDIN when fed (kept for the future published wiring — doyle field pin 2026-07-07: core does NOT stdin-feed [history] today) and otherwise SELF-LOCATES the transcript across rungs, most-authoritative first: the perch info.json read_env.CLAUDE_CONFIG_DIR (doyle-sanctioned — the role spawn does not inherit the session env, so ccs-relocated transcripts are invisible to the env rung), $CLAUDE_CONFIG_DIR env, ~/.claude/projects, then every ~/.ccs/instances/<account>/projects. It takes a BOUNDED tail (whole JSONL lines, ~48KB cap), runs ONE headless `claude -p` turn (psyche-parity sandbox, Read-only tools — a summarizer never writes), and prints the context-delta summary to stdout for core to ingest. FAILURE DISCIPLINE (v0.15.4 revision — v0.15.2's exit-1-on-locate-miss rode the psyche host's 3-strike budget and LATCHED doyle's + perri's hosts): a locate-miss after every rung is GRACEFUL — ECHO_COMMUNE_NO_TRANSCRIPT: stderr breadcrumb + an explicit no-delta marker on stdout + exit 0 (the miss stays visible in the ingested mind; the host survives); only REAL faults (claude spawn-fail/nonzero/empty-output) stay loud nonzero (ECHO_COMMUNE_FAIL:). recursion_guard_env=\"SPT_ECHO_COMMUNE\" rides the role table; the hook binary BAILS (exit 0, zero api calls, zero perch writes) when $SPT_ECHO_COMMUNE is set, so the summarizer's spawned claude can never seed/bind/rebind a perch (sibling of the F-028 identity-env scrub, which rides env_remove on this table too)."
-required_stages = ["impl", "unit"]  # MINTED + ACTIVATED 2026-07-07 (v0.15.2, ECHO-COMMUNE-PLAN.md); REVISED same day at v0.15.4 (doyle RCA: read_env rung + ccs sweep + graceful locate-miss). impl: tools/claude-spt/src/echo_commune.rs (stdin-or-locate input plan, read_env_config_dir/owlery_info_path/ccs_instance_roots/self_locate rungs, no_transcript_delta graceful miss, bounded tail, one claude -p turn) + tools/claude-spt/src/hook.rs SPT_ECHO_COMMUNE bail + adapter/claude-spt.toml [session.echo_commune] table. unit: echo_commune.rs in-module tests (arg parse, stdin-vs-fallback plan, read_env extraction incl. skip-on-missing/empty/garbage, graceful-miss marker, ccs-shape locate, tail bound, prompt composition) + hook.rs guard test (env set => zero recorded calls) + main.rs dispatch. int DEFERRED: the core-driven round-trip (commune ingest on a live perch with NO psyche_host_error) — post-0.15.4 field verify incl. psyche-host strike-clear on doyle + perri.
-
-[[requirements]]
-id = "REQ-DIST-REACHABILITY-NOTICE"
-title = "Perched sessions are steered to BACKGROUND long-running work so the perch stays reachable — the spt reachability notice, ported from legacy owl's <owl_reachability_notice> (sibling claude_skill_owl hook_prompt.rs + hook_check.rs) and renamed to spt semantics (<spt_reachability_notice>, 'active spt perch'). Two injection sites, both perch-gated (a plain CC session is never told it has a perch): (1) UserPromptSubmit — EVERY perched turn's additionalContext closes with the general notice ('when spawning subagents or running long tasks, use run_in_background: true so you stay reachable for incoming messages'), appended AFTER any skill injection + drained messages (a notice never displaces a delivery); (2) PreToolUse — when the tool about to run is a subagent spawn (tool_name Agent, or its older payload name Task — matched both ways so a CC rename in either direction keeps the nudge alive), the targeted launch-this-in-background nudge rides the same emit, messages first, nudge last, and emits EVEN when the drain is empty (the point is catching the foreground spawn before it happens). Non-spawn tools with an empty drain stay silent — no per-Bash noise. Both ride the existing once-capped emit (spill guard unchanged). WHY (field, 2026-07-07 operator): every claude-spt agent ran subagents/long tasks in the FOREGROUND, going unreachable for the task's whole duration — the legacy-owl notice was the missing steering pressure."
-required_stages = ["impl", "unit"]  # MINTED + ACTIVATED 2026-07-07 (operator port ask; v0.15.3). impl: tools/claude-spt/src/hook.rs — reachability_notice (two variants) + is_agent_spawn_tool + the UPS always-append + the PreToolUse spawn-nudge wiring. unit: ups_appends_reachability_notice_on_perched_turns_only + ups_notice_rides_after_drained_messages + pre_tool_use_agent_spawn_gets_the_nudge_other_tools_do_not + agent_spawn_tool_matcher_covers_both_cc_names. int: not planned — the notice is a pure additionalContext string on hooks already int-covered (REQ-DIST-PRETOOL-POLL); live verify = operator observes agents backgrounding tasks.
-
-[[requirements]]
-id = "REQ-HAZARD-DANGLING-FRAME-LOUD"
-title = "A poll frame truncated mid-frame is NEVER dropped silently by render_frames. The original loop break'd on a dangling frame (opening <EVENT with no '>', or a body with no closing </EVENT>) — the message was taken from the spool (delivered=1) but nothing surfaced to the agent: the §2.8 silent-loss family, one seam upstream (framing instead of stdout channel). Hardening invariant: the dangling-frame arm emits a loud <sptc_frame_integrity> marker carrying the surviving partial content (unescaped) plus a spool-recovery pointer (owlery/<id>/spool.db, messages table), riding the existing capped emits on both drain paths. Never field-observed (seed #9's head-truncations were core-side idle-inject pacing with COMPLETE spool rows — structurally unable to produce this shape); closed by construction before it could cost a message."
-required_stages = ["doc", "impl", "unit"]  # MINTED + ACTIVATED 2026-07-07 (perri code-walk during seed-#9 seam exoneration; doyle ship-it ACK; TRUNCATION-PROBE-PLAN.md). doc: docs/KNOWN-HAZARDS.md §2.9. impl: tools/claude-spt/src/hook.rs — dangling-frame arm in render_frames. unit: render_frames dangling-frame cases (no-close body, mangled opening, partial-content survival, complete-frames-then-dangling mix, no marker on clean input). int: not planned — pure string transform under already-int-covered drain hooks (REQ-DIST-PRETOOL-POLL).
-
-[[requirements]]
-id = "REQ-HAZARD-PRETOOL-CONTEXT-ENVELOPE"
-title = "Every PreToolUse emission rides the {\"hookSpecificOutput\":{\"hookEventName\":\"PreToolUse\",\"additionalContext\":...}} JSON envelope — NEVER raw stdout. CC discards plain PreToolUse stdout (unlike UserPromptSubmit, whose raw stdout IS the context channel), so the F-021 mid-turn delivery leg's raw emission made every message drained during a busy turn a SILENT BLACK HOLE: taken from the spool (delivered=1, core honest) then thrown away by CC — invisible to agent, sender, and spool (field 2026-07-07, doyle node-wide RCA; three doyle->perri messages eaten including the outage evidence itself; binary exonerated by direct-drive repro). The cap decision is made on the WRAPPED byte size (JSON escaping can double newline-heavy drains); an over-cap drain spills the RAW text and sends a WRAPPED overflow pointer — a taken message must always surface somewhere the agent can read. Check ~/.claude/reference_docs/claude-code-hooks.md PER EVENT before wiring any hook output — never by analogy from another event."
-required_stages = ["doc", "impl", "unit"]  # MINTED + ACTIVATED 2026-07-07 (v0.15.4 urgent fix, doyle RCA screenshot). doc: docs/KNOWN-HAZARDS.md §2.8. impl: tools/claude-spt/src/hook.rs — wrap_pretool_context + emit_capped_pretool wired in handle_pre_tool_use. unit: pretool_envelope_shape_and_escaping (round-trip through serde) + pretool_overflow_spills_raw_and_wraps_the_pointer (wrapped-size cap decision) + pre_tool_use_busy_before_drain (envelope on the drain path) + pre_tool_use_agent_spawn_gets_the_nudge_other_tools_do_not (envelope on the nudge path). int DEFERRED: live mid-turn receive on-node post-apply (send while target busy, assert <sptc_messages> reaches the agent's turn — tonight's exact outage scenario).
-
-[[requirements]]
-id = "REQ-SKILL-LIVE-SPT-HOSTED-BRANCH"
-title = "The /sptc:live bringup instructions BRANCH on the session's delivery substrate: a NORMAL (operator-launched) CC session arms the step-2 Monitor `spt api listen <id>` resident relay as its single delivery pipe; an SPT-HOSTED session (daemon-launched via `spt endpoint run`, broker-delivered — recognized by the SessionStart identity brief already present + the perch bound before bringup) must NOT arm that Monitor listener. Field ground truth (flynn 2026-07-07, live-perch-monitor-reachability): in an spt-hosted session an in-session `spt api listen` CANNOT re-arm the perch — the bash.exe child breaks by-pid host_binaries resolution (ADAPTER_UNRESOLVED) and the Monitor-child pid breaks seed lineage (NO_SEED); inbound is ALREADY broker-delivered to the session's turn (the `<sptc_messages>` hook-injection / existing relay), so a second listener is redundant at best and a resolution-fault at worst. The skill states the branch explicitly, names the two failure branches, and directs the spt-hosted agent to rely on its existing broker delivery (send + continue; the reply surfaces on its own). ready.md carries the same branch note (a ready spt-hosted session likewise must not arm a second `spt ready` listener)."
-required_stages = ["doc"]  # MINTED + ACTIVATED 2026-07-07 (adapter-debts work order; ADAPTER-DEBTS or the session commune). doc: adapter/strings/skills/live.md (the spt-hosted branch in Bringup + the two failure branches) + adapter/strings/skills/ready.md (the matching note). No impl/unit: these are agent-facing prose strings the hook only file-backs + resolves (same class as REQ-DIST-SESSIONSTART-BRIEF's string bodies); the branch is a documentation contract, not new binary logic. Source: flynn's Monitor-reachability diagnosis (spt-hosted sessions are broker-delivered; an in-session Monitor listener structurally cannot re-arm them).
-
-[[requirements]]
-id = "REQ-SUPERVISOR-RELAY-RESPAWN"
-title = "DESIGN CANDIDATE (not yet implemented): the adapter's belt-and-suspenders answer to a dead in-session relay — when a live agent's resident Monitor relay dies mid-session (the delivery pipe silently stops), SOMETHING must notice and either respawn it or surface the death, so the agent does not go silently unreachable while appearing online. This is the ADAPTER half that folds into doyle's W4 supervisor-watchdog activation ruling (the core owns the watchdog itself; the adapter owns the relay-respawn / death-surfacing belt on top). SCOPE FENCE: this REQ is design/doc ONLY for now — do NOT build the watchdog or a respawn loop adapter-side until W4's activation ruling lands and assigns the boundary (core-vs-adapter). Captured now so the debt is tracked, not lost, and so the W4 wave has the adapter's requirement written when it activates."
-required_stages = []  # MINTED INACTIVE 2026-07-07 (adapter-debts work order). Design/doc candidate only — stays required_stages = [] (activation-model: never pre-fail a requirement not yet in build) until doyle's W4 supervisor-watchdog activation ruling assigns the core-vs-adapter boundary. Then activate with the real stages (doc the belt design → impl the relay-respawn/death-surfacing → unit → int the dead-relay recovery). Source: live-perch-monitor-reachability memory (a dead Monitor + trusting busy-path hook-injection = silent idle unreachability) + flynn's diagnosis. Do NOT implement the watchdog adapter-side pre-ruling — W4 is core's.
-
-[[requirements]]
-id = "REQ-HAZARD-RESUME-REBIND-WEDGE"
-title = "CC's in-TUI /resume must NEVER silently strand an spt-hosted endpoint's perch. Mechanism (operator hunch, perri-confirmed 2026-07-07 across our hook.rs + the CC SessionStart hook contract + the live `spt api boundary/bind` CLI contract): the /resume slash command ends the current session (SessionEnd reason=resume) and re-fires SessionStart(source=resume) in the SAME broker child process, so $SPT_ENDPOINT_ID is STILL set — the hook takes the spt-hosted registration path. register_verb routes ONLY clear/compact to the proofed `boundary` rotation; every other source (incl. resume) with an endpoint id present falls to a plain `bind`. That bind path (a) presented NO ownership proof and (b) used the exit-ignored `spt` seam (silent). But the perch is ALREADY bound — its info.json records the DEPARTED pre-resume sid — so a proofless re-pin to the resumed sid is squat-protection REFUSED by core, and the adapter swallowed the refusal: the perch strands on the departed sid, every id-scoped call (poll/state/boundary) is AUTH_REFUSED, delivery is dead while the endpoint still looks healthy — the SESSION-PIN-WEDGE (REQ-HAZARD-SESSION-PIN-WEDGE) reached via /resume instead of a missed /clear. FIX (adapter-only — the live CLI shows `boundary <MODE>` is a hard enum {clear,compact}, so a new 'resume' boundary mode is blocked core-side; `bind` however accepts `--session-id <SESSION_ID>` = 'proving association (matches the perch info.json)', so the proof rides bind, not a boundary mode): the spt-hosted bind now presents the departed sid from the adapter state file ({adapter_dir}/state/session/<id>.sid, the REQ-DIST-BOUNDARY-ROTATE carrier) as `--session-id <prior>` ownership proof whenever a prior sid exists AND differs from the current sid (a re-pin/rotation), and runs STRICT + LOUD on any refusal (bind({src}) re-pin FAILED — never the silent swallow). The FIRST (fresh-spawn, source=startup) bind still binds proofless (no recorded sid to prove against — broker parentage is the credential) but is now strict too. This closes the resume leg of the never-silent-wedge invariant."
-required_stages = ["impl", "unit"]  # MINTED + ACTIVATED 2026-07-07 (operator /resume hunch; RESUME-REBIND-WEDGE, v0.15.7). impl: tools/claude-spt/src/hook.rs — handle_session_start bind branch (prior-sid proof from sid_state_rel state, prior!=sid guard, spt_strict + loud bind-fail log replacing the exit-ignored env.spt). unit: hook.rs — resume_rebind_presents_prior_proof (source=resume + state=s-old + sid=s-new → bind ... --set-session-id s-new --session-id s-old) + fresh_bind_has_no_proof_and_is_strict (source=startup, empty state → proofless bind line unchanged, no log) + resume_rebind_refusal_is_loud (with_strict_err → bind({src}) re-pin FAILED surfaced) + resume_rebind_same_sid_omits_proof (prior==sid → no --session-id). int DEFERRED: live in-TUI /resume on a disposable spt-hosted broker endpoint (drive /resume, assert the perch sid rotates to the resumed sid + `spt send` still SENT, vs the pre-fix strand) — heavy (interactive slash-command in a broker PTY, no transcript; side-effect assertion only), folds into the live-verify window with doyle; the wedge-vs-stomp core-contract question (does core bind REFUSE a proofless re-pin of a live-owned perch, or silently stomp?) is out to doyle — the fix is correct under both (proof makes the rotation authorized; loudness ends the silent swallow either way).
-
-[[requirements]]
-id = "REQ-INJECT-VERIFY-ECHO"
-title = "The claude-spt manifest opts CC-hosted sessions into spt-core's Layer-2 inject echo-verify by declaring [env.SPT_INJECT_VERIFY_ECHO] direction=\"inject\" value=\"1\" (doyle W6 LIFECYCLE-TRUTH final wave, W6-DISPATCH-RULING item 3). W5-A shipped the broker seam as a declared-capability defaulting OFF; because CC's TUI re-renders typed text, an inject that echoes back is a valid delivery-verification belt, so a CC session opts IN via this flag. Per the adapter-glue boundary the ON switch is adapter DATA (a manifest [env] value), NOT a new spt-core requirement — the broker reads the injected capability at spawn and arms echo-verify for the session. FLOOR-SAFE (perri call, doyle-accepted 2026-07-07): the flag is inert on cores below the W5-A seam (an unknown env var the session ignores; the broker default stays OFF) and self-activates once the counter-49 core deploys — so min_spt_core is NOT bumped and the ship is decoupled from the core release (no counter-49 floor-gate ping needed)."
-required_stages = ["unit"]  # MINTED + ACTIVATED 2026-07-07 (doyle W6 leg; v0.15.8). Declaration-only manifest seam (the .toml is scan-invisible — same convention as REQ-DIST-SESSION-RESUME / REQ-HAZARD-PSYCHE-IDENTITY-ENV, whose manifest evidence lives in the shell test). unit: tests/manifest-shortcut.sh — the [env.SPT_INJECT_VERIFY_ECHO] block asserts (section present + direction="inject" + value="1"). doc rides the manifest [env] comment. int DEFERRED to the counter-49 live-verify window: a CC session spawned on a counter-49 core with the updated adapter has SPT_INJECT_VERIFY_ECHO=1 in its env AND the broker arms echo-verify (the full CC-sess→env-set→broker-arms E2E — the broker-arms half is unverifiable below counter-49 and out of the public surface, so it rides doyle's core-side wave verify).
-
-[[requirements]]
-id = "REQ-HAZARD-STUCK-ACTIVE-NO-IDLE"
-title = "A freshly-launched spt-hosted claude-spt endpoint that has never completed a turn must NOT silently black-hole every inbound message. The daemon's idle-gated delivery pushes to the translation binary only when the endpoint is IDLE; while ACTIVE it defers each message to the spool ('ENDPOINT_INJECT:<id>: endpoint ACTIVE -> spool, not injected') and drains only on the NEXT idle transition (IDLE_PARKED_DRAIN). The adapter marked `state idle` ONLY on Stop (turn end), a `/clear` boundary, or a checkpoint write — NEVER on a `startup` bringup and with NO handler for CC's idle-at-prompt Notification. So an endpoint launched then left (or a session whose first submission is a client-side `/login`/slash command that fires UserPromptSubmit→state busy but produces NO agent turn → no Stop) stays ACTIVE forever: every message spools delivered=0/taken=None and never drains, while the endpoint looks healthy (ONLINE, CONTROLLED). Field-diagnosed 2026-07-08 (operator /diagnose): `lia` (logged-out boot → `/login`, never a real turn) had 14 parked messages, all undelivered; marking her idle instantly drained all 14 via the (healthy) translation binary — proving the translation binary was never the fault, the stuck ACTIVE state was. TWO-LAYER FIX: (1) the spt-hosted bind path asserts `state idle` at bringup (a fresh session sits at an empty input box = idle → immediately receivable); (2) a new Notification hook (hooks.json `idle_prompt` matcher, $SPT_ENDPOINT_ID-gated) re-asserts `state idle` whenever CC reports the session idle at its prompt — the SELF-HEAL that recovers from a `/login` or any no-Stop submission that left it busy. permission_prompt/other notification types never route here (the matcher excludes them); a Notification with no session_id is a no-op (cannot prove ownership to the state verb)."
-required_stages = ["impl", "unit"]  # MINTED + ACTIVATED 2026-07-08 (operator /diagnose of lia; v0.15.9). impl: tools/claude-spt/src/hook.rs — the bind-branch `state idle` at bringup + handle_notification (idle_prompt self-heal, $SPT_ENDPOINT_ID gate, sid-required) + the Notification dispatch arm + CC_HOOK_EVENTS entry; plugin/sptc/hooks/hooks.json Notification→dispatch.sh with the idle_prompt matcher. unit: hook.rs startup_bind_marks_idle_for_immediate_receivability + notification_idle_prompt_marks_idle_when_spt_hosted + notification_noop_when_not_spt_hosted + notification_without_sid_is_a_noop + cc_hook_events_recognizer_matches_the_dispatch_arms (Notification added to the lockstep list) + tests/hooks-dispatch.sh (Notification routes to dispatch.sh + keeps the idle_prompt matcher). int DEFERRED to the live-verify window: a fresh spt-hosted endpoint launched and left untouched receives a `spt send` (drains without a manual state-idle) — the exact lia scenario, now self-healed; heavy (broker-PTY, side-effect assertion). Live recovery for any pre-fix stranded endpoint: `spt api --adapter claude-spt state idle <id> --session-id <its sid>` (proven on lia — flushed 14 parked)."
-
-[[requirements]]
-id = "REQ-HAZARD-STOPFAILURE-STUCK-BUSY"
-title = "An API-error turn-end must not leave an spt-hosted endpoint stuck ACTIVE/undrainable. CC fires NO `Stop` when a turn ends with an API error (matcher error types: rate_limit, authentication_failed, billing_error, invalid_request, server_error, max_output_tokens, unknown) — it fires `StopFailure` instead. The adapter marked idle ONLY on `Stop`, so an errored turn-end never got its idle mark and the daemon spooled every inbound without draining (same black-hole class as REQ-HAZARD-STUCK-ACTIVE-NO-IDLE, reached via API error instead of a never-completed first turn). FIX: wire `StopFailure` → `handle_stop_failure` → `state idle` (self_id-resolved, sid-scoped — mirrors the `Stop` idle mark); the error_type is logged (rare event; permanent observability + Step-0 coverage instrument)."
-required_stages = ["impl", "unit"]  # MINTED + ACTIVATED 2026-07-08 (NEXT-WORKLOAD-PLAN Item 1 fix 1; receive-heal). impl: tools/claude-spt/src/hook.rs handle_stop_failure + the StopFailure dispatch arm + CC_HOOK_EVENTS entry; plugin/sptc/hooks/hooks.json StopFailure→dispatch.sh (matcherless — all error types). unit: hook.rs stop_failure_marks_idle_when_perched_else_noop + cc_hook_events_recognizer_matches_the_dispatch_arms (StopFailure in the lockstep list) + tests/hooks-dispatch.sh (StopFailure wired to dispatch.sh). int DEFERRED to the live-verify window: drive a real rate-limit/server_error turn-end on a disposable spt-hosted endpoint and assert the perch marks idle + a spooled `spt send` drains (heavy — requires forcing an API error in a broker PTY, side-effect assertion only).
-
-[[requirements]]
-id = "REQ-HAZARD-INTERRUPT-STUCK-BUSY"
-title = "An operator Esc-interrupt must not leave an spt-hosted endpoint stuck ACTIVE/undrainable. Field-proven (lia 2026-07-08): an Esc fires NO `Stop` and NO `idle_prompt`, so the endpoint stays ACTIVE and the daemon black-holes every inbound (20+ min silence until the next UserPromptSubmit happens to drain the spool). An Esc DURING a tool call fires `PostToolUseFailure` with `is_interrupt == true` — the zero-latency heal hook. FIX: wire `PostToolUseFailure` → `handle_post_tool_use_failure`; on `is_interrupt == true` → `state idle` (self_id-resolved, sid-scoped). A NON-interrupt tool failure (a command exited nonzero) is NOT a turn-end — the agent keeps working — so it must NOT mark idle (that would drain the spool mid-turn); absent/false `is_interrupt` is likewise a no-op. Interrupt logs unconditionally (load-bearing); a non-interrupt failure logs only under the $SPTC_HOOK_TRACE Step-0 flag (else it spams the hot tool-failure path). COVERAGE NOTE: this heals Esc-during-a-tool-call; a pure-thinking Esc (no tool in flight) fires no PostToolUseFailure — whether it is covered by an idle_prompt Notification or needs the fix-3 digest-pull watcher is gated on the Step-0 live repro (NEXT-WORKLOAD-PLAN Item 1)."
-required_stages = ["impl", "unit"]  # MINTED 2026-07-08 (NEXT-WORKLOAD-PLAN Item 1). Covers fix 2 (hook fast-path) AND fix 3 (the hook-independent watcher — the real fix; Step-0 proved an Esc fires NO usable hook: Stop=clean-finish-only, StopFailure=API-error-only, PostToolUseFailure=tool-only-and-unreliable, pure-thinking Esc=nothing; field lia 2026-07-08). impl: tools/claude-spt/src/hook.rs handle_post_tool_use_failure + mark_idle_receive_heal (v0.16.1 hardening: id←$SPT_ENDPOINT_ID, sid←state/session/<id>.sid carrier when the payload omits session_id — empty --session-id is core-AUTH-refused) + PostToolUseFailure dispatch arm + CC_HOOK_EVENTS; plugin/sptc/hooks/hooks.json PostToolUseFailure→dispatch.sh; AND tools/claude-spt/src/interrupt_watch.rs (fix 3, v0.16.2 — a 15s heartbeat thread hosted by translate.rs pulls `spt endpoint digest <id> --last 1 --json`, detects the `[Request interrupted by user` marker on the latest turn, marks idle via the carrier sid; heal-once + re-arm) wired from translate.rs run() `init` handshake. Whole chain proven manually against a stuck lia (state idle w/ carrier sid → IDLE gate-armed → probe SENT) before code. unit: hook.rs post_tool_use_failure_interrupt_marks_idle + _noninterrupt_does_not_mark_idle + receive_heal_spt_hosted_uses_sid_carrier_when_payload_omits_sid + _prefers_payload_sid_and_covers_stop_failure + receive_heal_skips_when_no_sid_anywhere + cc_hook_events_recognizer + tests/hooks-dispatch.sh; interrupt_watch.rs interrupt_marker_matches_both_variants_only + parse_latest_input_* + heal_decision_* (heal-once/re-arm/hold-on-miss) + sid_carrier_path_matches_the_hook_writer_shape. int DEFERRED to the live-verify window: a real Esc (mid-tool AND pure-thinking) on a disposable spt-hosted endpoint → the watcher marks idle within ≤15s + a spooled `spt send` drains (heavy — interactive Esc in a broker PTY; the digest-detect→state-idle→drain chain is manually field-proven meanwhile)."
-
-[[requirements]]
-id = "REQ-OMP-NATIVE-TUI"
-title = "An attached omp-spt endpoint exposes OMP's native interactive TUI, not a headless RPC bridge terminal, while retaining SPT bind/listen/state/reply behavior through OMP's public extension API."
-required_stages = ["doc", "impl", "unit"]  # doc: ADR-0007. impl: adapter/strings/omp-spt.mjs + native-omp [session.self]/[session.resume] commands. unit: tests/omp-extension.mjs + tests/manifest-shortcut.sh. Live PTY acceptance is performed for the release candidate; automate it when Herdr has a stable TUI assertion surface suitable for CI.
+title = "One omp-spt helper binary dispatches only the retained OMP-native launch, digest, history, Psyche, and echo-commune roles"
+required_stages = ["impl", "unit"]
[raw output: artifact://349]