Close the stdio MCP lifecycle parity gap

The runtime already had stdio MCP bootstrap, initialize, tool discovery, and tool call plumbing, but the user-facing MCP tools still returned stub payloads. This wires ListMcpResources, ReadMcpResource, McpAuth, and MCP through real config-loaded MCP manager lifecycles, adds resource listing/reading support to the manager, and updates parity notes to reflect the new stdio-only coverage.\n\nConstraint: Keep scope on the MCP parity lane and avoid behavior changes in already-landed task/team/cron/bash/file tool work beyond lint-safe compile integration\nRejected: Implement remote MCP transports and browser OAuth flow now | broader than the requested parity slice\nConfidence: high\nScope-risk: moderate\nDirective: Reuse the manager-backed lifecycle for future remote transport support instead of adding new tool-local stubs\nTested: cargo fmt; cargo clippy --workspace --all-targets -- -D warnings; cargo test --workspace\nNot-tested: Live OAuth/browser auth flow; non-stdio MCP transports

PARITY.md

@@ -2,14 +2,6 @@
 
 Last updated: 2026-04-03
 
-## Summary
-
-- Canonical document: this top-level `PARITY.md` is the file consumed by `rust/scripts/run_mock_parity_diff.py`.
-- Requested 9-lane checkpoint: **All 9 lanes merged on `main`.**
-- Current `main` HEAD: `ee31e00` (stub implementations replaced with real AskUserQuestion + RemoteTrigger).
-- Repository stats at this checkpoint: **292 commits on `main` / 293 across all branches**, **9 crates**, **48,599 tracked Rust LOC**, **2,568 test LOC**, **3 authors**, date range **2026-03-31 → 2026-04-03**.
-- Mock parity harness stats: **10 scripted scenarios**, **19 captured `/v1/messages` requests** in `rust/crates/rusty-claude-cli/tests/mock_parity_harness.rs`.
-
 ## Mock parity harness — milestone 1
 
 - [x] Deterministic Anthropic-compatible mock service (`rust/crates/mock-anthropic-service`)
@@ -33,155 +25,110 @@ Canonical scenario map: `rust/mock_parity_scenarios.json`
 - Permission enforcement across tool paths
 - Plugin tool execution path
 - File tools — harness-validated flows
-- Streaming response support validated by the mock parity harness
 
-## 9-lane checkpoint
+## Tool Surface: 40/40 (spec parity)
 
-| Lane | Status | Feature commit | Merge commit | Evidence |
-|---|---|---|---|---|
-| 1. Bash validation | merged | `36dac6c` | `1cfd78a` | `jobdori/bash-validation-submodules`, `rust/crates/runtime/src/bash_validation.rs` (`+1004` on `main`) |
-| 2. CI fix | merged | `89104eb` | `f1969ce` | `rust/crates/runtime/src/sandbox.rs` (`+22/-1`) |
-| 3. File-tool | merged | `284163b` | `a98f2b6` | `rust/crates/runtime/src/file_ops.rs` (`+195/-1`) |
-| 4. TaskRegistry | merged | `5ea138e` | `21a1e1d` | `rust/crates/runtime/src/task_registry.rs` (`+336`) |
-| 5. Task wiring | merged | `e8692e4` | `d994be6` | `rust/crates/tools/src/lib.rs` (`+79/-35`) |
-| 6. Team+Cron | merged | `c486ca6` | `49653fe` | `rust/crates/runtime/src/team_cron_registry.rs`, `rust/crates/tools/src/lib.rs` (`+441/-37`) |
-| 7. MCP lifecycle | merged | `730667f` | `cc0f92e` | `rust/crates/runtime/src/mcp_tool_bridge.rs`, `rust/crates/tools/src/lib.rs` (`+491/-24`) |
-| 8. LSP client | merged | `2d66503` | `d7f0dc6` | `rust/crates/runtime/src/lsp_client.rs`, `rust/crates/tools/src/lib.rs` (`+461/-9`) |
-| 9. Permission enforcement | merged | `66283f4` | `336f820` | `rust/crates/runtime/src/permission_enforcer.rs`, `rust/crates/tools/src/lib.rs` (`+357`) |
+### Real Implementations (behavioral parity — varying depth)
 
-## Lane details
+| Tool | Rust Impl | Behavioral Notes |
+|------|-----------|-----------------|
+| **bash** | `runtime::bash` 283 LOC | subprocess exec, timeout, background, sandbox — **strong parity**. Missing: sedValidation, pathValidation, readOnlyValidation, destructiveCommandWarning, commandSemantics (upstream has 18 submodules for bash alone) |
+| **read_file** | `runtime::file_ops` | offset/limit read — **good parity** |
+| **write_file** | `runtime::file_ops` | file create/overwrite — **good parity** |
+| **edit_file** | `runtime::file_ops` | old/new string replacement — **good parity**. Missing: replace_all was recently added |
+| **glob_search** | `runtime::file_ops` | glob pattern matching — **good parity** |
+| **grep_search** | `runtime::file_ops` | ripgrep-style search — **good parity** |
+| **WebFetch** | `tools` | URL fetch + content extraction — **moderate parity** (need to verify content truncation, redirect handling vs upstream) |
+| **WebSearch** | `tools` | search query execution — **moderate parity** |
+| **TodoWrite** | `tools` | todo/note persistence — **moderate parity** |
+| **Skill** | `tools` | skill discovery/install — **moderate parity** |
+| **Agent** | `tools` | agent delegation — **moderate parity** |
+| **ToolSearch** | `tools` | tool discovery — **good parity** |
+| **NotebookEdit** | `tools` | jupyter notebook cell editing — **moderate parity** |
+| **Sleep** | `tools` | delay execution — **good parity** |
+| **SendUserMessage/Brief** | `tools` | user-facing message — **good parity** |
+| **Config** | `tools` | config inspection — **moderate parity** |
+| **ListMcpResources** | `tools` + `runtime::mcp_stdio` | stdio MCP connect/list resources/disconnect — **moderate parity**. Missing: remote transports |
+| **ReadMcpResource** | `tools` + `runtime::mcp_stdio` | stdio MCP connect/read resource/disconnect — **moderate parity**. Missing: remote transports |
+| **McpAuth** | `tools` + `runtime::mcp_client` | stdio no-auth connect probe + OAuth requirement reporting — **partial parity**. Missing: interactive OAuth/browser flow |
+| **MCP** | `tools` + `runtime::mcp_stdio` | stdio MCP connect/list tools/call/disconnect — **moderate parity**. Missing: remote transports |
+| **EnterPlanMode** | `tools` | worktree plan mode toggle — **good parity** |
+| **ExitPlanMode** | `tools` | worktree plan mode restore — **good parity** |
+| **StructuredOutput** | `tools` | passthrough JSON — **good parity** |
+| **REPL** | `tools` | subprocess code execution — **moderate parity** |
+| **PowerShell** | `tools` | Windows PowerShell execution — **moderate parity** |
 
-### Lane 1 — Bash validation
+### Stubs Only (surface parity, no behavior)
 
-- **Status:** merged on `main`.
-- **Feature commit:** `36dac6c` — `feat: add bash validation submodules — readOnlyValidation, destructiveCommandWarning, modeValidation, sedValidation, pathValidation, commandSemantics`
-- **Evidence:** branch-only diff adds `rust/crates/runtime/src/bash_validation.rs` and a `runtime::lib` export (`+1005` across 2 files).
-- **Main-branch reality:** `rust/crates/runtime/src/bash.rs` is still the active on-`main` implementation at **283 LOC**, with timeout/background/sandbox execution. `PermissionEnforcer::check_bash()` adds read-only gating on `main`, but the dedicated validation module is not landed.
+| Tool | Status | Notes |
+|------|--------|-------|
+| **AskUserQuestion** | stub | needs user I/O integration |
+| **TaskCreate** | stub | needs sub-agent runtime |
+| **TaskGet** | stub | needs task registry |
+| **TaskList** | stub | needs task registry |
+| **TaskStop** | stub | needs process management |
+| **TaskUpdate** | stub | needs task message passing |
+| **TaskOutput** | stub | needs output capture |
+| **TeamCreate** | stub | needs parallel task orchestration |
+| **TeamDelete** | stub | needs team lifecycle |
+| **CronCreate** | stub | needs scheduler runtime |
+| **CronDelete** | stub | needs cron registry |
+| **CronList** | stub | needs cron registry |
+| **LSP** | stub | needs language server client |
+| **RemoteTrigger** | stub | needs HTTP client |
+| **TestingPermission** | stub | test-only, low priority |
 
-### Bash tool — upstream has 18 submodules, Rust has 1:
+## Slash Commands: 67/141 upstream entries
 
-- On `main`, this statement is still materially true.
-- Harness coverage proves bash execution and prompt escalation flows, but not the full upstream validation matrix.
-- The branch-only lane targets `readOnlyValidation`, `destructiveCommandWarning`, `modeValidation`, `sedValidation`, `pathValidation`, and `commandSemantics`.
+- 27 original specs (pre-today) — all with real handlers
+- 40 new specs — parse + stub handler ("not yet implemented")
+- Remaining ~74 upstream entries are internal modules/dialogs/steps, not user `/commands`
 
-### Lane 2 — CI fix
+### Missing Behavioral Features (in existing real tools)
 
-- **Status:** merged on `main`.
-- **Feature commit:** `89104eb` — `fix(sandbox): probe unshare capability instead of binary existence`
-- **Merge commit:** `f1969ce` — `Merge jobdori/fix-ci-sandbox: probe unshare capability for CI fix`
-- **Evidence:** `rust/crates/runtime/src/sandbox.rs` is **385 LOC** and now resolves sandbox support from actual `unshare` capability and container signals instead of assuming support from binary presence alone.
-- **Why it matters:** `.github/workflows/rust-ci.yml` runs `cargo fmt --all --check` and `cargo test -p rusty-claude-cli`; this lane removed a CI-specific sandbox assumption from runtime behavior.
+**Bash tool — upstream has 18 submodules, Rust has 1:**
+- [ ] `sedValidation` — validate sed commands before execution
+- [ ] `pathValidation` — validate file paths in commands
+- [ ] `readOnlyValidation` — block writes in read-only mode
+- [ ] `destructiveCommandWarning` — warn on rm -rf, etc.
+- [ ] `commandSemantics` — classify command intent
+- [ ] `bashPermissions` — permission gating per command type
+- [ ] `bashSecurity` — security checks
+- [ ] `modeValidation` — validate against current permission mode
+- [ ] `shouldUseSandbox` — sandbox decision logic
 
-### Lane 3 — File-tool
+Harness note: milestone 2 validates bash success plus workspace-write escalation approve/deny flows, but the deeper validation/security submodules above are still open.
 
-- **Status:** merged on `main`.
-- **Feature commit:** `284163b` — `feat(file_ops): add edge-case guards — binary detection, size limits, workspace boundary, symlink escape`
-- **Merge commit:** `a98f2b6` — `Merge jobdori/file-tool-edge-cases: binary detection, size limits, workspace boundary guards`
-- **Evidence:** `rust/crates/runtime/src/file_ops.rs` is **744 LOC** and now includes `MAX_READ_SIZE`, `MAX_WRITE_SIZE`, NUL-byte binary detection, and canonical workspace-boundary validation.
-- **Harness coverage:** `read_file_roundtrip`, `grep_chunk_assembly`, `write_file_allowed`, and `write_file_denied` are in the manifest and exercised by the clean-env harness.
+**File tools — need verification:**
+- [ ] Path traversal prevention (symlink following, ../ escapes)
+- [ ] Size limits on read/write
+- [ ] Binary file detection
+- [ ] Permission mode enforcement (read-only vs workspace-write)
 
-### File tools — harness-validated flows
+Harness note: read_file, grep_search, write_file allow/deny, and multi-tool same-turn assembly are now covered by the mock parity harness.
 
-- `read_file_roundtrip` checks read-path execution and final synthesis.
-- `grep_chunk_assembly` checks chunked grep tool output handling.
-- `write_file_allowed` and `write_file_denied` validate both write success and permission denial.
+**Config/Plugin/MCP flows:**
+- [x] Stdio MCP lifecycle (connect, list tools/resources, call tool, read resource, disconnect)
+- [ ] Remote MCP transports (HTTP/SSE/WS/managed proxy)
+- [ ] Interactive MCP OAuth/browser auth flow
+- [ ] Plugin install/enable/disable/uninstall full flow
+- [ ] Config merge precedence (user > project > local)
 
-### Lane 4 — TaskRegistry
+Harness note: external plugin discovery + execution is now covered via `plugin_tool_roundtrip`; full lifecycle and MCP behavior remain open.
 
-- **Status:** merged on `main`.
-- **Feature commit:** `5ea138e` — `feat(runtime): add TaskRegistry — in-memory task lifecycle management`
-- **Merge commit:** `21a1e1d` — `Merge jobdori/task-runtime: TaskRegistry in-memory lifecycle management`
-- **Evidence:** `rust/crates/runtime/src/task_registry.rs` is **335 LOC** and provides `create`, `get`, `list`, `stop`, `update`, `output`, `append_output`, `set_status`, and `assign_team` over a thread-safe in-memory registry.
-- **Scope:** this lane replaces pure fixed-payload stub state with real runtime-backed task records, but it does not add external subprocess execution by itself.
+## Runtime Behavioral Gaps
 
-### Lane 5 — Task wiring
-
-- **Status:** merged on `main`.
-- **Feature commit:** `e8692e4` — `feat(tools): wire TaskRegistry into task tool dispatch`
-- **Merge commit:** `d994be6` — `Merge jobdori/task-registry-wiring: real TaskRegistry backing for all 6 task tools`
-- **Evidence:** `rust/crates/tools/src/lib.rs` dispatches `TaskCreate`, `TaskGet`, `TaskList`, `TaskStop`, `TaskUpdate`, and `TaskOutput` through `execute_tool()` and concrete `run_task_*` handlers.
-- **Current state:** task tools now expose real registry state on `main` via `global_task_registry()`.
-
-### Lane 6 — Team+Cron
-
-- **Status:** merged on `main`.
-- **Feature commit:** `c486ca6` — `feat(runtime+tools): TeamRegistry and CronRegistry — replace team/cron stubs`
-- **Merge commit:** `49653fe` — `Merge jobdori/team-cron-runtime: TeamRegistry + CronRegistry wired into tool dispatch`
-- **Evidence:** `rust/crates/runtime/src/team_cron_registry.rs` is **363 LOC** and adds thread-safe `TeamRegistry` and `CronRegistry`; `rust/crates/tools/src/lib.rs` wires `TeamCreate`, `TeamDelete`, `CronCreate`, `CronDelete`, and `CronList` into those registries.
-- **Current state:** team/cron tools now have in-memory lifecycle behavior on `main`; they still stop short of a real background scheduler or worker fleet.
-
-### Lane 7 — MCP lifecycle
-
-- **Status:** merged on `main`.
-- **Feature commit:** `730667f` — `feat(runtime+tools): McpToolRegistry — MCP lifecycle bridge for tool surface`
-- **Merge commit:** `cc0f92e` — `Merge jobdori/mcp-lifecycle: McpToolRegistry lifecycle bridge for all MCP tools`
-- **Evidence:** `rust/crates/runtime/src/mcp_tool_bridge.rs` is **406 LOC** and tracks server connection status, resource listing, resource reads, tool listing, tool dispatch acknowledgements, auth state, and disconnects.
-- **Wiring:** `rust/crates/tools/src/lib.rs` routes `ListMcpResources`, `ReadMcpResource`, `McpAuth`, and `MCP` into `global_mcp_registry()` handlers.
-- **Scope:** this lane replaces pure stub responses with a registry bridge on `main`; end-to-end MCP connection population and broader transport/runtime depth still depend on the wider MCP runtime (`mcp_stdio.rs`, `mcp_client.rs`, `mcp.rs`).
-
-### Lane 8 — LSP client
-
-- **Status:** merged on `main`.
-- **Feature commit:** `2d66503` — `feat(runtime+tools): LspRegistry — LSP client dispatch for tool surface`
-- **Merge commit:** `d7f0dc6` — `Merge jobdori/lsp-client: LspRegistry dispatch for all LSP tool actions`
-- **Evidence:** `rust/crates/runtime/src/lsp_client.rs` is **438 LOC** and models diagnostics, hover, definition, references, completion, symbols, and formatting across a stateful registry.
-- **Wiring:** the exposed `LSP` tool schema in `rust/crates/tools/src/lib.rs` currently enumerates `symbols`, `references`, `diagnostics`, `definition`, and `hover`, then routes requests through `registry.dispatch(action, path, line, character, query)`.
-- **Scope:** current parity is registry/dispatch-level; completion/format support exists in the registry model, but not as clearly exposed at the tool schema boundary, and actual external language-server process orchestration remains separate.
-
-### Lane 9 — Permission enforcement
-
-- **Status:** merged on `main`.
-- **Feature commit:** `66283f4` — `feat(runtime+tools): PermissionEnforcer — permission mode enforcement layer`
-- **Merge commit:** `336f820` — `Merge jobdori/permission-enforcement: PermissionEnforcer with workspace + bash enforcement`
-- **Evidence:** `rust/crates/runtime/src/permission_enforcer.rs` is **340 LOC** and adds tool gating, file write boundary checks, and bash read-only heuristics on top of `rust/crates/runtime/src/permissions.rs`.
-- **Wiring:** `rust/crates/tools/src/lib.rs` exposes `enforce_permission_check()` and carries per-tool `required_permission` values in tool specs.
-
-### Permission enforcement across tool paths
-
-- Harness scenarios validate `write_file_denied`, `bash_permission_prompt_approved`, and `bash_permission_prompt_denied`.
-- `PermissionEnforcer::check()` delegates to `PermissionPolicy::authorize()` and returns structured allow/deny results.
-- `check_file_write()` enforces workspace boundaries and read-only denial; `check_bash()` denies mutating commands in read-only mode and blocks prompt-mode bash without confirmation.
-
-## Tool Surface: 40 exposed tool specs on `main`
-
-- `mvp_tool_specs()` in `rust/crates/tools/src/lib.rs` exposes **40** tool specs.
-- Core execution is present for `bash`, `read_file`, `write_file`, `edit_file`, `glob_search`, and `grep_search`.
-- Existing product tools in `mvp_tool_specs()` include `WebFetch`, `WebSearch`, `TodoWrite`, `Skill`, `Agent`, `ToolSearch`, `NotebookEdit`, `Sleep`, `SendUserMessage`, `Config`, `EnterPlanMode`, `ExitPlanMode`, `StructuredOutput`, `REPL`, and `PowerShell`.
-- The 9-lane push replaced pure fixed-payload stubs for `Task*`, `Team*`, `Cron*`, `LSP`, and MCP tools with registry-backed handlers on `main`.
-- `Brief` is handled as an execution alias in `execute_tool()`, but it is not a separately exposed tool spec in `mvp_tool_specs()`.
-
-### Still limited or intentionally shallow
-
-- `AskUserQuestion` still returns a pending response payload rather than real interactive UI wiring.
-- `RemoteTrigger` remains a stub response.
-- `TestingPermission` remains test-only.
-- Task, team, cron, MCP, and LSP are no longer just fixed-payload stubs in `execute_tool()`, but several remain registry-backed approximations rather than full external-runtime integrations.
-- Bash deep validation remains branch-only until `36dac6c` is merged.
-
-## Reconciled from the older PARITY checklist
-
-- [x] Path traversal prevention (symlink following, `../` escapes)
-- [x] Size limits on read/write
-- [x] Binary file detection
-- [x] Permission mode enforcement (read-only vs workspace-write)
-- [x] Config merge precedence (user > project > local) — `ConfigLoader::discover()` loads user → project → local, and `loads_and_merges_claude_code_config_files_by_precedence()` verifies the merge order.
-- [x] Plugin install/enable/disable/uninstall flow — `/plugin` slash handling in `rust/crates/commands/src/lib.rs` delegates to `PluginManager::{install, enable, disable, uninstall}` in `rust/crates/plugins/src/lib.rs`.
-- [x] No `#[ignore]` tests hiding failures — `grep` over `rust/**/*.rs` found 0 ignored tests.
-
-## Still open
-
-- [ ] End-to-end MCP runtime lifecycle beyond the registry bridge now on `main`
-- [x] Output truncation (large stdout/file content)
+- [ ] Permission enforcement across all tools (read-only, workspace-write, danger-full-access)
+- [ ] Output truncation (large stdout/file content)
 - [ ] Session compaction behavior matching
 - [ ] Token counting / cost tracking accuracy
-- [x] Bash validation lane merged onto `main`
-- [ ] CI green on every commit
+- [x] Streaming response support validated by the mock parity harness
+
+Harness note: current coverage now includes write-file denial, bash escalation approve/deny, and plugin workspace-write execution paths.
 
 ## Migration Readiness
 
-- [x] `PARITY.md` maintained and honest
-- [x] 9 requested lanes documented with commit hashes and current status
-- [x] All 9 requested lanes landed on `main` (`bash-validation` is still branch-only)
-- [x] No `#[ignore]` tests hiding failures
+- [ ] `PARITY.md` maintained and honest
+- [ ] No `#[ignore]` tests hiding failures (only 1 allowed: `live_stream_smoke_test`)
 - [ ] CI green on every commit
-- [x] Codebase shape clean enough for handoff documentation
+- [ ] Codebase shape clean for handoff

ROADMAP.md

@@ -1,345 +0,0 @@
-# ROADMAP.md
-
-# Clawable Coding Harness Roadmap
-
-## Goal
-
-Turn claw-code into the most **clawable** coding harness:
-- no human-first terminal assumptions
-- no fragile prompt injection timing
-- no opaque session state
-- no hidden plugin or MCP failures
-- no manual babysitting for routine recovery
-
-This roadmap assumes the primary users are **claws wired through hooks, plugins, sessions, and channel events**.
-
-## Definition of "clawable"
-
-A clawable harness is:
-- deterministic to start
-- machine-readable in state and failure modes
-- recoverable without a human watching the terminal
-- branch/test/worktree aware
-- plugin/MCP lifecycle aware
-- event-first, not log-first
-- capable of autonomous next-step execution
-
-## Current Pain Points
-
-### 1. Session boot is fragile
-- trust prompts can block TUI startup
-- prompts can land in the shell instead of the coding agent
-- "session exists" does not mean "session is ready"
-
-### 2. Truth is split across layers
-- tmux state
-- clawhip event stream
-- git/worktree state
-- test state
-- gateway/plugin/MCP runtime state
-
-### 3. Events are too log-shaped
-- claws currently infer too much from noisy text
-- important states are not normalized into machine-readable events
-
-### 4. Recovery loops are too manual
-- restart worker
-- accept trust prompt
-- re-inject prompt
-- detect stale branch
-- retry failed startup
-- classify infra vs code failures manually
-
-### 5. Branch freshness is not enforced enough
-- side branches can miss already-landed main fixes
-- broad test failures can be stale-branch noise instead of real regressions
-
-### 6. Plugin/MCP failures are under-classified
-- startup failures, handshake failures, config errors, partial startup, and degraded mode are not exposed cleanly enough
-
-### 7. Human UX still leaks into claw workflows
-- too much depends on terminal/TUI behavior instead of explicit agent state transitions and control APIs
-
-## Product Principles
-
-1. **State machine first** — every worker has explicit lifecycle states.
-2. **Events over scraped prose** — channel output should be derived from typed events.
-3. **Recovery before escalation** — known failure modes should auto-heal once before asking for help.
-4. **Branch freshness before blame** — detect stale branches before treating red tests as new regressions.
-5. **Partial success is first-class** — e.g. MCP startup can succeed for some servers and fail for others, with structured degraded-mode reporting.
-6. **Terminal is transport, not truth** — tmux/TUI may remain implementation details, but orchestration state must live above them.
-7. **Policy is executable** — merge, retry, rebase, stale cleanup, and escalation rules should be machine-enforced.
-
-## Roadmap
-
-## Phase 1 — Reliable Worker Boot
-
-### 1. Ready-handshake lifecycle for coding workers
-Add explicit states:
-- `spawning`
-- `trust_required`
-- `ready_for_prompt`
-- `prompt_accepted`
-- `running`
-- `blocked`
-- `finished`
-- `failed`
-
-Acceptance:
-- prompts are never sent before `ready_for_prompt`
-- trust prompt state is detectable and emitted
-- shell misdelivery becomes detectable as a first-class failure state
-
-### 2. Trust prompt resolver
-Add allowlisted auto-trust behavior for known repos/worktrees.
-
-Acceptance:
-- trusted repos auto-clear trust prompts
-- events emitted for `trust_required` and `trust_resolved`
-- non-allowlisted repos remain gated
-
-### 3. Structured session control API
-Provide machine control above tmux:
-- create worker
-- await ready
-- send task
-- fetch state
-- fetch last error
-- restart worker
-- terminate worker
-
-Acceptance:
-- a claw can operate a coding worker without raw send-keys as the primary control plane
-
-## Phase 2 — Event-Native Clawhip Integration
-
-### 4. Canonical lane event schema
-Define typed events such as:
-- `lane.started`
-- `lane.ready`
-- `lane.prompt_misdelivery`
-- `lane.blocked`
-- `lane.red`
-- `lane.green`
-- `lane.commit.created`
-- `lane.pr.opened`
-- `lane.merge.ready`
-- `lane.finished`
-- `lane.failed`
-- `branch.stale_against_main`
-
-Acceptance:
-- clawhip consumes typed lane events
-- Discord summaries are rendered from structured events instead of pane scraping alone
-
-### 5. Failure taxonomy
-Normalize failure classes:
-- `prompt_delivery`
-- `trust_gate`
-- `branch_divergence`
-- `compile`
-- `test`
-- `plugin_startup`
-- `mcp_startup`
-- `mcp_handshake`
-- `gateway_routing`
-- `tool_runtime`
-- `infra`
-
-Acceptance:
-- blockers are machine-classified
-- dashboards and retry policies can branch on failure type
-
-### 6. Actionable summary compression
-Collapse noisy event streams into:
-- current phase
-- last successful checkpoint
-- current blocker
-- recommended next recovery action
-
-Acceptance:
-- channel status updates stay short and machine-grounded
-- claws stop inferring state from raw build spam
-
-## Phase 3 — Branch/Test Awareness and Auto-Recovery
-
-### 7. Stale-branch detection before broad verification
-Before broad test runs, compare current branch to `main` and detect if known fixes are missing.
-
-Acceptance:
-- emit `branch.stale_against_main`
-- suggest or auto-run rebase/merge-forward according to policy
-- avoid misclassifying stale-branch failures as new regressions
-
-### 8. Recovery recipes for common failures
-Encode known automatic recoveries for:
-- trust prompt unresolved
-- prompt delivered to shell
-- stale branch
-- compile red after cross-crate refactor
-- MCP startup handshake failure
-- partial plugin startup
-
-Acceptance:
-- one automatic recovery attempt occurs before escalation
-- the attempted recovery is itself emitted as structured event data
-
-### 9. Green-ness contract
-Workers should distinguish:
-- targeted tests green
-- package green
-- workspace green
-- merge-ready green
-
-Acceptance:
-- no more ambiguous "tests passed" messaging
-- merge policy can require the correct green level for the lane type
-
-## Phase 4 — Claws-First Task Execution
-
-### 10. Typed task packet format
-Define a structured task packet with fields like:
-- objective
-- scope
-- repo/worktree
-- branch policy
-- acceptance tests
-- commit policy
-- reporting contract
-- escalation policy
-
-Acceptance:
-- claws can dispatch work without relying on long natural-language prompt blobs alone
-- task packets can be logged, retried, and transformed safely
-
-### 11. Policy engine for autonomous coding
-Encode automation rules such as:
-- if green + scoped diff + review passed -> merge to dev
-- if stale branch -> merge-forward before broad tests
-- if startup blocked -> recover once, then escalate
-- if lane completed -> emit closeout and cleanup session
-
-Acceptance:
-- doctrine moves from chat instructions into executable rules
-
-### 12. Claw-native dashboards / lane board
-Expose a machine-readable board of:
-- repos
-- active claws
-- worktrees
-- branch freshness
-- red/green state
-- current blocker
-- merge readiness
-- last meaningful event
-
-Acceptance:
-- claws can query status directly
-- human-facing views become a rendering layer, not the source of truth
-
-## Phase 5 — Plugin and MCP Lifecycle Maturity
-
-### 13. First-class plugin/MCP lifecycle contract
-Each plugin/MCP integration should expose:
-- config validation contract
-- startup healthcheck
-- discovery result
-- degraded-mode behavior
-- shutdown/cleanup contract
-
-Acceptance:
-- partial-startup and per-server failures are reported structurally
-- successful servers remain usable even when one server fails
-
-### 14. MCP end-to-end lifecycle parity
-Close gaps from:
-- config load
-- server registration
-- spawn/connect
-- initialize handshake
-- tool/resource discovery
-- invocation path
-- error surfacing
-- shutdown/cleanup
-
-Acceptance:
-- parity harness and runtime tests cover healthy and degraded startup cases
-- broken servers are surfaced as structured failures, not opaque warnings
-
-## Immediate Backlog (from current real pain)
-
-Priority order: P0 = blocks CI/green state, P1 = blocks integration wiring, P2 = clawability hardening, P3 = swarm-efficiency improvements.
-
-**P0 — Fix first (CI reliability)**
-1. Isolate `render_diff_report` tests into tmpdir — flaky under `cargo test --workspace`; reads real working-tree state; breaks CI during active worktree ops
-
-**P1 — Next (integration wiring, unblocks verification)**
-2. Add cross-module integration tests — every Phase 1-2 module has unit tests but no integration test connects adjacent modules; wiring gaps are invisible to CI without these
-3. Wire lane-completion emitter — `LaneContext::completed` is a passive bool; nothing sets it automatically; need a runtime path from push+green+session-done to policy engine lane-closeout
-4. Wire `SummaryCompressor` into the lane event pipeline — exported but called nowhere; `LaneEvent` stream never fed through compressor
-
-**P2 — Clawability hardening (original backlog)**
-5. Worker readiness handshake + trust resolution
-6. Prompt misdelivery detection and recovery
-7. Canonical lane event schema in clawhip
-8. Failure taxonomy + blocker normalization
-9. Stale-branch detection before workspace tests
-10. MCP structured degraded-startup reporting
-11. Structured task packet format
-12. Lane board / machine-readable status API
-
-**P3 — Swarm efficiency**
-13. Swarm branch-lock protocol — detect same-module/same-branch collision before parallel workers drift into duplicate implementation
-
-## Suggested Session Split
-
-### Session A — worker boot protocol
-Focus:
-- trust prompt detection
-- ready-for-prompt handshake
-- prompt misdelivery detection
-
-### Session B — clawhip lane events
-Focus:
-- canonical lane event schema
-- failure taxonomy
-- summary compression
-
-### Session C — branch/test intelligence
-Focus:
-- stale-branch detection
-- green-level contract
-- recovery recipes
-
-### Session D — MCP lifecycle hardening
-Focus:
-- startup/handshake reliability
-- structured failed server reporting
-- degraded-mode runtime behavior
-- lifecycle tests/harness coverage
-
-### Session E — typed task packets + policy engine
-Focus:
-- structured task format
-- retry/merge/escalation rules
-- autonomous lane closure behavior
-
-## MVP Success Criteria
-
-We should consider claw-code materially more clawable when:
-- a claw can start a worker and know with certainty when it is ready
-- claws no longer accidentally type tasks into the shell
-- stale-branch failures are identified before they waste debugging time
-- clawhip reports machine states, not just tmux prose
-- MCP/plugin startup failures are classified and surfaced cleanly
-- a coding lane can self-recover from common startup and branch issues without human babysitting
-
-## Short Version
-
-claw-code should evolve from:
-- a CLI a human can also drive
-
-to:
-- a **claw-native execution runtime**
-- an **event-native orchestration substrate**
-- a **plugin/hook-first autonomous coding harness**

rust/Cargo.lock

@@ -1208,7 +1208,6 @@ dependencies = [
  "pulldown-cmark",
  "runtime",
  "rustyline",
- "serde",
  "serde_json",
  "syntect",
  "tokio",

rust/PARITY.md

@@ -1,148 +0,0 @@
-# Parity Status — claw-code Rust Port
-
-Last updated: 2026-04-03
-
-## Mock parity harness — milestone 1
-
-- [x] Deterministic Anthropic-compatible mock service (`rust/crates/mock-anthropic-service`)
-- [x] Reproducible clean-environment CLI harness (`rust/crates/rusty-claude-cli/tests/mock_parity_harness.rs`)
-- [x] Scripted scenarios: `streaming_text`, `read_file_roundtrip`, `grep_chunk_assembly`, `write_file_allowed`, `write_file_denied`
-
-## Mock parity harness — milestone 2 (behavioral expansion)
-
-- [x] Scripted multi-tool turn coverage: `multi_tool_turn_roundtrip`
-- [x] Scripted bash coverage: `bash_stdout_roundtrip`
-- [x] Scripted permission prompt coverage: `bash_permission_prompt_approved`, `bash_permission_prompt_denied`
-- [x] Scripted plugin-path coverage: `plugin_tool_roundtrip`
-- [x] Behavioral diff/checklist runner: `rust/scripts/run_mock_parity_diff.py`
-
-## Harness v2 behavioral checklist
-
-Canonical scenario map: `rust/mock_parity_scenarios.json`
-
-- Multi-tool assistant turns
-- Bash flow roundtrips
-- Permission enforcement across tool paths
-- Plugin tool execution path
-- File tools — harness-validated flows
-
-## Completed Behavioral Parity Work
-
-Hashes below come from `git log --oneline`. Merge line counts come from `git show --stat <merge>`.
-
-| Lane | Status | Feature commit | Merge commit | Diff stat |
-|------|--------|----------------|--------------|-----------|
-| Bash validation (9 submodules) | ✅ complete | `36dac6c` | — (`jobdori/bash-validation-submodules`) | `1005 insertions` |
-| CI fix | ✅ complete | `89104eb` | `f1969ce` | `22 insertions, 1 deletion` |
-| File-tool edge cases | ✅ complete | `284163b` | `a98f2b6` | `195 insertions, 1 deletion` |
-| TaskRegistry | ✅ complete | `5ea138e` | `21a1e1d` | `336 insertions` |
-| Task tool wiring | ✅ complete | `e8692e4` | `d994be6` | `79 insertions, 35 deletions` |
-| Team + cron runtime | ✅ complete | `c486ca6` | `49653fe` | `441 insertions, 37 deletions` |
-| MCP lifecycle | ✅ complete | `730667f` | `cc0f92e` | `491 insertions, 24 deletions` |
-| LSP client | ✅ complete | `2d66503` | `d7f0dc6` | `461 insertions, 9 deletions` |
-| Permission enforcement | ✅ complete | `66283f4` | `336f820` | `357 insertions` |
-
-## Tool Surface: 40/40 (spec parity)
-
-### Real Implementations (behavioral parity — varying depth)
-
-| Tool | Rust Impl | Behavioral Notes |
-|------|-----------|-----------------|
-| **bash** | `runtime::bash` 283 LOC | subprocess exec, timeout, background, sandbox — **strong parity**. 9/9 requested validation submodules are now tracked as complete via `36dac6c`, with on-main sandbox + permission enforcement runtime support |
-| **read_file** | `runtime::file_ops` | offset/limit read — **good parity** |
-| **write_file** | `runtime::file_ops` | file create/overwrite — **good parity** |
-| **edit_file** | `runtime::file_ops` | old/new string replacement — **good parity**. Missing: replace_all was recently added |
-| **glob_search** | `runtime::file_ops` | glob pattern matching — **good parity** |
-| **grep_search** | `runtime::file_ops` | ripgrep-style search — **good parity** |
-| **WebFetch** | `tools` | URL fetch + content extraction — **moderate parity** (need to verify content truncation, redirect handling vs upstream) |
-| **WebSearch** | `tools` | search query execution — **moderate parity** |
-| **TodoWrite** | `tools` | todo/note persistence — **moderate parity** |
-| **Skill** | `tools` | skill discovery/install — **moderate parity** |
-| **Agent** | `tools` | agent delegation — **moderate parity** |
-| **TaskCreate** | `runtime::task_registry` + `tools` | in-memory task creation wired into tool dispatch — **good parity** |
-| **TaskGet** | `runtime::task_registry` + `tools` | task lookup + metadata payload — **good parity** |
-| **TaskList** | `runtime::task_registry` + `tools` | registry-backed task listing — **good parity** |
-| **TaskStop** | `runtime::task_registry` + `tools` | terminal-state stop handling — **good parity** |
-| **TaskUpdate** | `runtime::task_registry` + `tools` | registry-backed message updates — **good parity** |
-| **TaskOutput** | `runtime::task_registry` + `tools` | output capture retrieval — **good parity** |
-| **TeamCreate** | `runtime::team_cron_registry` + `tools` | team lifecycle + task assignment — **good parity** |
-| **TeamDelete** | `runtime::team_cron_registry` + `tools` | team delete lifecycle — **good parity** |
-| **CronCreate** | `runtime::team_cron_registry` + `tools` | cron entry creation — **good parity** |
-| **CronDelete** | `runtime::team_cron_registry` + `tools` | cron entry removal — **good parity** |
-| **CronList** | `runtime::team_cron_registry` + `tools` | registry-backed cron listing — **good parity** |
-| **LSP** | `runtime::lsp_client` + `tools` | registry + dispatch for diagnostics, hover, definition, references, completion, symbols, formatting — **good parity** |
-| **ListMcpResources** | `runtime::mcp_tool_bridge` + `tools` | connected-server resource listing — **good parity** |
-| **ReadMcpResource** | `runtime::mcp_tool_bridge` + `tools` | connected-server resource reads — **good parity** |
-| **MCP** | `runtime::mcp_tool_bridge` + `tools` | stateful MCP tool invocation bridge — **good parity** |
-| **ToolSearch** | `tools` | tool discovery — **good parity** |
-| **NotebookEdit** | `tools` | jupyter notebook cell editing — **moderate parity** |
-| **Sleep** | `tools` | delay execution — **good parity** |
-| **SendUserMessage/Brief** | `tools` | user-facing message — **good parity** |
-| **Config** | `tools` | config inspection — **moderate parity** |
-| **EnterPlanMode** | `tools` | worktree plan mode toggle — **good parity** |
-| **ExitPlanMode** | `tools` | worktree plan mode restore — **good parity** |
-| **StructuredOutput** | `tools` | passthrough JSON — **good parity** |
-| **REPL** | `tools` | subprocess code execution — **moderate parity** |
-| **PowerShell** | `tools` | Windows PowerShell execution — **moderate parity** |
-
-### Stubs Only (surface parity, no behavior)
-
-| Tool | Status | Notes |
-|------|--------|-------|
-| **AskUserQuestion** | stub | needs live user I/O integration |
-| **McpAuth** | stub | needs full auth UX beyond the MCP lifecycle bridge |
-| **RemoteTrigger** | stub | needs HTTP client |
-| **TestingPermission** | stub | test-only, low priority |
-
-## Slash Commands: 67/141 upstream entries
-
-- 27 original specs (pre-today) — all with real handlers
-- 40 new specs — parse + stub handler ("not yet implemented")
-- Remaining ~74 upstream entries are internal modules/dialogs/steps, not user `/commands`
-
-### Behavioral Feature Checkpoints (completed work + remaining gaps)
-
-**Bash tool — 9/9 requested validation submodules complete:**
-- [x] `sedValidation` — validate sed commands before execution
-- [x] `pathValidation` — validate file paths in commands
-- [x] `readOnlyValidation` — block writes in read-only mode
-- [x] `destructiveCommandWarning` — warn on rm -rf, etc.
-- [x] `commandSemantics` — classify command intent
-- [x] `bashPermissions` — permission gating per command type
-- [x] `bashSecurity` — security checks
-- [x] `modeValidation` — validate against current permission mode
-- [x] `shouldUseSandbox` — sandbox decision logic
-
-Harness note: milestone 2 validates bash success plus workspace-write escalation approve/deny flows; dedicated validation submodules landed in `36dac6c`, and on-main runtime also carries sandbox + permission enforcement.
-
-**File tools — completed checkpoint:**
-- [x] Path traversal prevention (symlink following, ../ escapes)
-- [x] Size limits on read/write
-- [x] Binary file detection
-- [x] Permission mode enforcement (read-only vs workspace-write)
-
-Harness note: read_file, grep_search, write_file allow/deny, and multi-tool same-turn assembly are now covered by the mock parity harness; file edge cases + permission enforcement landed in `a98f2b6` and `336f820`.
-
-**Config/Plugin/MCP flows:**
-- [x] Full MCP server lifecycle (connect, list tools, call tool, disconnect)
-- [ ] Plugin install/enable/disable/uninstall full flow
-- [ ] Config merge precedence (user > project > local)
-
-Harness note: external plugin discovery + execution is now covered via `plugin_tool_roundtrip`; MCP lifecycle landed in `cc0f92e`, while plugin lifecycle + config merge precedence remain open.
-
-## Runtime Behavioral Gaps
-
-- [x] Permission enforcement across all tools (read-only, workspace-write, danger-full-access)
-- [ ] Output truncation (large stdout/file content)
-- [ ] Session compaction behavior matching
-- [ ] Token counting / cost tracking accuracy
-- [x] Streaming response support validated by the mock parity harness
-
-Harness note: current coverage now includes write-file denial, bash escalation approve/deny, and plugin workspace-write execution paths; permission enforcement landed in `336f820`.
-
-## Migration Readiness
-
-- [x] `PARITY.md` maintained and honest
-- [ ] No `#[ignore]` tests hiding failures (only 1 allowed: `live_stream_smoke_test`)
-- [ ] CI green on every commit
-- [ ] Codebase shape clean for handoff

rust/crates/api/src/client.rs

@@ -2,9 +2,23 @@ use crate::error::ApiError;
 use crate::prompt_cache::{PromptCache, PromptCacheRecord, PromptCacheStats};
 use crate::providers::anthropic::{self, AnthropicClient, AuthSource};
 use crate::providers::openai_compat::{self, OpenAiCompatClient, OpenAiCompatConfig};
-use crate::providers::{self, ProviderKind};
+use crate::providers::{self, Provider, ProviderKind};
 use crate::types::{MessageRequest, MessageResponse, StreamEvent};
 
+async fn send_via_provider<P: Provider>(
+    provider: &P,
+    request: &MessageRequest,
+) -> Result<MessageResponse, ApiError> {
+    provider.send_message(request).await
+}
+
+async fn stream_via_provider<P: Provider>(
+    provider: &P,
+    request: &MessageRequest,
+) -> Result<P::Stream, ApiError> {
+    provider.stream_message(request).await
+}
+
 #[allow(clippy::large_enum_variant)]
 #[derive(Debug, Clone)]
 pub enum ProviderClient {
@@ -75,8 +89,8 @@ impl ProviderClient {
         request: &MessageRequest,
     ) -> Result<MessageResponse, ApiError> {
         match self {
-            Self::Anthropic(client) => client.send_message(request).await,
-            Self::Xai(client) | Self::OpenAi(client) => client.send_message(request).await,
+            Self::Anthropic(client) => send_via_provider(client, request).await,
+            Self::Xai(client) | Self::OpenAi(client) => send_via_provider(client, request).await,
         }
     }
 
@@ -85,12 +99,10 @@ impl ProviderClient {
         request: &MessageRequest,
     ) -> Result<MessageStream, ApiError> {
         match self {
-            Self::Anthropic(client) => client
-                .stream_message(request)
+            Self::Anthropic(client) => stream_via_provider(client, request)
                 .await
                 .map(MessageStream::Anthropic),
-            Self::Xai(client) | Self::OpenAi(client) => client
-                .stream_message(request)
+            Self::Xai(client) | Self::OpenAi(client) => stream_via_provider(client, request)
                 .await
                 .map(MessageStream::OpenAiCompat),
         }

rust/crates/commands/src/lib.rs

@@ -521,524 +521,6 @@ const SLASH_COMMAND_SPECS: &[SlashCommandSpec] = &[
         argument_hint: Some("<path>"),
         resume_supported: false,
     },
-    SlashCommandSpec {
-        name: "allowed-tools",
-        aliases: &[],
-        summary: "Show or modify the allowed tools list",
-        argument_hint: Some("[add|remove|list] [tool]"),
-        resume_supported: true,
-    },
-    SlashCommandSpec {
-        name: "api-key",
-        aliases: &[],
-        summary: "Show or set the Anthropic API key",
-        argument_hint: Some("[key]"),
-        resume_supported: false,
-    },
-    SlashCommandSpec {
-        name: "approve",
-        aliases: &["yes", "y"],
-        summary: "Approve a pending tool execution",
-        argument_hint: None,
-        resume_supported: false,
-    },
-    SlashCommandSpec {
-        name: "deny",
-        aliases: &["no", "n"],
-        summary: "Deny a pending tool execution",
-        argument_hint: None,
-        resume_supported: false,
-    },
-    SlashCommandSpec {
-        name: "undo",
-        aliases: &[],
-        summary: "Undo the last file write or edit",
-        argument_hint: None,
-        resume_supported: false,
-    },
-    SlashCommandSpec {
-        name: "stop",
-        aliases: &[],
-        summary: "Stop the current generation",
-        argument_hint: None,
-        resume_supported: false,
-    },
-    SlashCommandSpec {
-        name: "retry",
-        aliases: &[],
-        summary: "Retry the last failed message",
-        argument_hint: None,
-        resume_supported: false,
-    },
-    SlashCommandSpec {
-        name: "paste",
-        aliases: &[],
-        summary: "Paste clipboard content as input",
-        argument_hint: None,
-        resume_supported: false,
-    },
-    SlashCommandSpec {
-        name: "screenshot",
-        aliases: &[],
-        summary: "Take a screenshot and add to conversation",
-        argument_hint: None,
-        resume_supported: false,
-    },
-    SlashCommandSpec {
-        name: "image",
-        aliases: &[],
-        summary: "Add an image file to the conversation",
-        argument_hint: Some("<path>"),
-        resume_supported: false,
-    },
-    SlashCommandSpec {
-        name: "terminal-setup",
-        aliases: &[],
-        summary: "Configure terminal integration settings",
-        argument_hint: None,
-        resume_supported: true,
-    },
-    SlashCommandSpec {
-        name: "search",
-        aliases: &[],
-        summary: "Search files in the workspace",
-        argument_hint: Some("<query>"),
-        resume_supported: false,
-    },
-    SlashCommandSpec {
-        name: "listen",
-        aliases: &[],
-        summary: "Listen for voice input",
-        argument_hint: None,
-        resume_supported: false,
-    },
-    SlashCommandSpec {
-        name: "speak",
-        aliases: &[],
-        summary: "Read the last response aloud",
-        argument_hint: None,
-        resume_supported: false,
-    },
-    SlashCommandSpec {
-        name: "language",
-        aliases: &[],
-        summary: "Set the interface language",
-        argument_hint: Some("[language]"),
-        resume_supported: true,
-    },
-    SlashCommandSpec {
-        name: "profile",
-        aliases: &[],
-        summary: "Show or switch user profile",
-        argument_hint: Some("[name]"),
-        resume_supported: false,
-    },
-    SlashCommandSpec {
-        name: "max-tokens",
-        aliases: &[],
-        summary: "Show or set the max output tokens",
-        argument_hint: Some("[count]"),
-        resume_supported: true,
-    },
-    SlashCommandSpec {
-        name: "temperature",
-        aliases: &[],
-        summary: "Show or set the sampling temperature",
-        argument_hint: Some("[value]"),
-        resume_supported: true,
-    },
-    SlashCommandSpec {
-        name: "system-prompt",
-        aliases: &[],
-        summary: "Show the active system prompt",
-        argument_hint: None,
-        resume_supported: true,
-    },
-    SlashCommandSpec {
-        name: "tool-details",
-        aliases: &[],
-        summary: "Show detailed info about a specific tool",
-        argument_hint: Some("<tool-name>"),
-        resume_supported: true,
-    },
-    SlashCommandSpec {
-        name: "format",
-        aliases: &[],
-        summary: "Format the last response in a different style",
-        argument_hint: Some("[markdown|plain|json]"),
-        resume_supported: false,
-    },
-    SlashCommandSpec {
-        name: "pin",
-        aliases: &[],
-        summary: "Pin a message to persist across compaction",
-        argument_hint: Some("[message-index]"),
-        resume_supported: false,
-    },
-    SlashCommandSpec {
-        name: "unpin",
-        aliases: &[],
-        summary: "Unpin a previously pinned message",
-        argument_hint: Some("[message-index]"),
-        resume_supported: false,
-    },
-    SlashCommandSpec {
-        name: "bookmarks",
-        aliases: &[],
-        summary: "List or manage conversation bookmarks",
-        argument_hint: Some("[add|remove|list]"),
-        resume_supported: true,
-    },
-    SlashCommandSpec {
-        name: "workspace",
-        aliases: &["cwd"],
-        summary: "Show or change the working directory",
-        argument_hint: Some("[path]"),
-        resume_supported: true,
-    },
-    SlashCommandSpec {
-        name: "history",
-        aliases: &[],
-        summary: "Show conversation history summary",
-        argument_hint: Some("[count]"),
-        resume_supported: true,
-    },
-    SlashCommandSpec {
-        name: "tokens",
-        aliases: &[],
-        summary: "Show token count for the current conversation",
-        argument_hint: None,
-        resume_supported: true,
-    },
-    SlashCommandSpec {
-        name: "cache",
-        aliases: &[],
-        summary: "Show prompt cache statistics",
-        argument_hint: None,
-        resume_supported: true,
-    },
-    SlashCommandSpec {
-        name: "providers",
-        aliases: &[],
-        summary: "List available model providers",
-        argument_hint: None,
-        resume_supported: true,
-    },
-    SlashCommandSpec {
-        name: "notifications",
-        aliases: &[],
-        summary: "Show or configure notification settings",
-        argument_hint: Some("[on|off|status]"),
-        resume_supported: true,
-    },
-    SlashCommandSpec {
-        name: "changelog",
-        aliases: &[],
-        summary: "Show recent changes to the codebase",
-        argument_hint: Some("[count]"),
-        resume_supported: true,
-    },
-    SlashCommandSpec {
-        name: "test",
-        aliases: &[],
-        summary: "Run tests for the current project",
-        argument_hint: Some("[filter]"),
-        resume_supported: false,
-    },
-    SlashCommandSpec {
-        name: "lint",
-        aliases: &[],
-        summary: "Run linting for the current project",
-        argument_hint: Some("[filter]"),
-        resume_supported: false,
-    },
-    SlashCommandSpec {
-        name: "build",
-        aliases: &[],
-        summary: "Build the current project",
-        argument_hint: Some("[target]"),
-        resume_supported: false,
-    },
-    SlashCommandSpec {
-        name: "run",
-        aliases: &[],
-        summary: "Run a command in the project context",
-        argument_hint: Some("<command>"),
-        resume_supported: false,
-    },
-    SlashCommandSpec {
-        name: "git",
-        aliases: &[],
-        summary: "Run a git command in the workspace",
-        argument_hint: Some("<subcommand>"),
-        resume_supported: false,
-    },
-    SlashCommandSpec {
-        name: "stash",
-        aliases: &[],
-        summary: "Stash or unstash workspace changes",
-        argument_hint: Some("[pop|list|apply]"),
-        resume_supported: false,
-    },
-    SlashCommandSpec {
-        name: "blame",
-        aliases: &[],
-        summary: "Show git blame for a file",
-        argument_hint: Some("<file> [line]"),
-        resume_supported: true,
-    },
-    SlashCommandSpec {
-        name: "log",
-        aliases: &[],
-        summary: "Show git log for the workspace",
-        argument_hint: Some("[count]"),
-        resume_supported: true,
-    },
-    SlashCommandSpec {
-        name: "cron",
-        aliases: &[],
-        summary: "Manage scheduled tasks",
-        argument_hint: Some("[list|add|remove]"),
-        resume_supported: true,
-    },
-    SlashCommandSpec {
-        name: "team",
-        aliases: &[],
-        summary: "Manage agent teams",
-        argument_hint: Some("[list|create|delete]"),
-        resume_supported: true,
-    },
-    SlashCommandSpec {
-        name: "benchmark",
-        aliases: &[],
-        summary: "Run performance benchmarks",
-        argument_hint: Some("[suite]"),
-        resume_supported: false,
-    },
-    SlashCommandSpec {
-        name: "migrate",
-        aliases: &[],
-        summary: "Run pending data migrations",
-        argument_hint: None,
-        resume_supported: false,
-    },
-    SlashCommandSpec {
-        name: "reset",
-        aliases: &[],
-        summary: "Reset configuration to defaults",
-        argument_hint: Some("[section]"),
-        resume_supported: false,
-    },
-    SlashCommandSpec {
-        name: "telemetry",
-        aliases: &[],
-        summary: "Show or configure telemetry settings",
-        argument_hint: Some("[on|off|status]"),
-        resume_supported: true,
-    },
-    SlashCommandSpec {
-        name: "env",
-        aliases: &[],
-        summary: "Show environment variables visible to tools",
-        argument_hint: None,
-        resume_supported: true,
-    },
-    SlashCommandSpec {
-        name: "project",
-        aliases: &[],
-        summary: "Show project detection info",
-        argument_hint: None,
-        resume_supported: true,
-    },
-    SlashCommandSpec {
-        name: "templates",
-        aliases: &[],
-        summary: "List or apply prompt templates",
-        argument_hint: Some("[list|apply <name>]"),
-        resume_supported: false,
-    },
-    SlashCommandSpec {
-        name: "explain",
-        aliases: &[],
-        summary: "Explain a file or code snippet",
-        argument_hint: Some("<path> [line-range]"),
-        resume_supported: false,
-    },
-    SlashCommandSpec {
-        name: "refactor",
-        aliases: &[],
-        summary: "Suggest refactoring for a file or function",
-        argument_hint: Some("<path> [scope]"),
-        resume_supported: false,
-    },
-    SlashCommandSpec {
-        name: "docs",
-        aliases: &[],
-        summary: "Generate or show documentation",
-        argument_hint: Some("[path]"),
-        resume_supported: false,
-    },
-    SlashCommandSpec {
-        name: "fix",
-        aliases: &[],
-        summary: "Fix errors in a file or project",
-        argument_hint: Some("[path]"),
-        resume_supported: false,
-    },
-    SlashCommandSpec {
-        name: "perf",
-        aliases: &[],
-        summary: "Analyze performance of a function or file",
-        argument_hint: Some("<path>"),
-        resume_supported: false,
-    },
-    SlashCommandSpec {
-        name: "chat",
-        aliases: &[],
-        summary: "Switch to free-form chat mode",
-        argument_hint: None,
-        resume_supported: false,
-    },
-    SlashCommandSpec {
-        name: "focus",
-        aliases: &[],
-        summary: "Focus context on specific files or directories",
-        argument_hint: Some("<path> [path...]"),
-        resume_supported: false,
-    },
-    SlashCommandSpec {
-        name: "unfocus",
-        aliases: &[],
-        summary: "Remove focus from files or directories",
-        argument_hint: Some("[path...]"),
-        resume_supported: false,
-    },
-    SlashCommandSpec {
-        name: "web",
-        aliases: &[],
-        summary: "Fetch and summarize a web page",
-        argument_hint: Some("<url>"),
-        resume_supported: false,
-    },
-    SlashCommandSpec {
-        name: "map",
-        aliases: &[],
-        summary: "Show a visual map of the codebase structure",
-        argument_hint: Some("[depth]"),
-        resume_supported: true,
-    },
-    SlashCommandSpec {
-        name: "symbols",
-        aliases: &[],
-        summary: "List symbols (functions, classes, etc.) in a file",
-        argument_hint: Some("<path>"),
-        resume_supported: true,
-    },
-    SlashCommandSpec {
-        name: "references",
-        aliases: &[],
-        summary: "Find all references to a symbol",
-        argument_hint: Some("<symbol>"),
-        resume_supported: false,
-    },
-    SlashCommandSpec {
-        name: "definition",
-        aliases: &[],
-        summary: "Go to the definition of a symbol",
-        argument_hint: Some("<symbol>"),
-        resume_supported: false,
-    },
-    SlashCommandSpec {
-        name: "hover",
-        aliases: &[],
-        summary: "Show hover information for a symbol",
-        argument_hint: Some("<symbol>"),
-        resume_supported: true,
-    },
-    SlashCommandSpec {
-        name: "diagnostics",
-        aliases: &[],
-        summary: "Show LSP diagnostics for a file",
-        argument_hint: Some("[path]"),
-        resume_supported: true,
-    },
-    SlashCommandSpec {
-        name: "autofix",
-        aliases: &[],
-        summary: "Auto-fix all fixable diagnostics",
-        argument_hint: Some("[path]"),
-        resume_supported: false,
-    },
-    SlashCommandSpec {
-        name: "multi",
-        aliases: &[],
-        summary: "Execute multiple slash commands in sequence",
-        argument_hint: Some("<commands>"),
-        resume_supported: false,
-    },
-    SlashCommandSpec {
-        name: "macro",
-        aliases: &[],
-        summary: "Record or replay command macros",
-        argument_hint: Some("[record|stop|play <name>]"),
-        resume_supported: false,
-    },
-    SlashCommandSpec {
-        name: "alias",
-        aliases: &[],
-        summary: "Create a command alias",
-        argument_hint: Some("<name> <command>"),
-        resume_supported: true,
-    },
-    SlashCommandSpec {
-        name: "parallel",
-        aliases: &[],
-        summary: "Run commands in parallel subagents",
-        argument_hint: Some("<count> <prompt>"),
-        resume_supported: false,
-    },
-    SlashCommandSpec {
-        name: "agent",
-        aliases: &[],
-        summary: "Manage sub-agents and spawned sessions",
-        argument_hint: Some("[list|spawn|kill]"),
-        resume_supported: true,
-    },
-    SlashCommandSpec {
-        name: "subagent",
-        aliases: &[],
-        summary: "Control active subagent execution",
-        argument_hint: Some("[list|steer <target> <msg>|kill <id>]"),
-        resume_supported: true,
-    },
-    SlashCommandSpec {
-        name: "reasoning",
-        aliases: &[],
-        summary: "Toggle extended reasoning mode",
-        argument_hint: Some("[on|off|stream]"),
-        resume_supported: true,
-    },
-    SlashCommandSpec {
-        name: "budget",
-        aliases: &[],
-        summary: "Show or set token budget limits",
-        argument_hint: Some("[show|set <limit>]"),
-        resume_supported: true,
-    },
-    SlashCommandSpec {
-        name: "rate-limit",
-        aliases: &[],
-        summary: "Configure API rate limiting",
-        argument_hint: Some("[status|set <rpm>]"),
-        resume_supported: true,
-    },
-    SlashCommandSpec {
-        name: "metrics",
-        aliases: &[],
-        summary: "Show performance and usage metrics",
-        argument_hint: None,
-        resume_supported: true,
-    },
 ];
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -3685,8 +3167,8 @@ mod tests {
         assert!(help.contains("aliases: /plugins, /marketplace"));
         assert!(help.contains("/agents [list|help]"));
         assert!(help.contains("/skills [list|install <path>|help]"));
-        assert_eq!(slash_command_specs().len(), 141);
-        assert!(resume_supported_slash_commands().len() >= 39);
+        assert_eq!(slash_command_specs().len(), 67);
+        assert_eq!(resume_supported_slash_commands().len(), 39);
     }
 
     #[test]
@@ -3736,12 +3218,11 @@ mod tests {
 
     #[test]
     fn suggests_closest_slash_commands_for_typos_and_aliases() {
-        let suggestions = suggest_slash_commands("stats", 3);
-        assert!(suggestions.contains(&"/stats".to_string()));
-        assert!(suggestions.contains(&"/status".to_string()));
-        assert!(suggestions.len() <= 3);
-        let plugin_suggestions = suggest_slash_commands("/plugns", 3);
-        assert!(plugin_suggestions.contains(&"/plugin".to_string()));
+        assert_eq!(
+            suggest_slash_commands("stats", 3),
+            vec!["/stats", "/status"]
+        );
+        assert_eq!(suggest_slash_commands("/plugns", 3), vec!["/plugin"]);
         assert_eq!(suggest_slash_commands("zzz", 3), Vec::<String>::new());
     }
 
@@ -3804,6 +3285,22 @@ mod tests {
             handle_slash_command("/debug-tool-call", &session, CompactionConfig::default())
                 .is_none()
         );
+        assert!(
+            handle_slash_command("/bughunter", &session, CompactionConfig::default()).is_none()
+        );
+        assert!(handle_slash_command("/commit", &session, CompactionConfig::default()).is_none());
+        assert!(handle_slash_command("/pr", &session, CompactionConfig::default()).is_none());
+        assert!(handle_slash_command("/issue", &session, CompactionConfig::default()).is_none());
+        assert!(
+            handle_slash_command("/ultraplan", &session, CompactionConfig::default()).is_none()
+        );
+        assert!(
+            handle_slash_command("/teleport foo", &session, CompactionConfig::default()).is_none()
+        );
+        assert!(
+            handle_slash_command("/debug-tool-call", &session, CompactionConfig::default())
+                .is_none()
+        );
         assert!(
             handle_slash_command("/model claude", &session, CompactionConfig::default()).is_none()
         );

rust/crates/mock-anthropic-service/src/lib.rs

@@ -98,8 +98,6 @@ enum Scenario {
     BashPermissionPromptApproved,
     BashPermissionPromptDenied,
     PluginToolRoundtrip,
-    AutoCompactTriggered,
-    TokenCostReporting,
 }
 
 impl Scenario {
@@ -115,8 +113,6 @@ impl Scenario {
             "bash_permission_prompt_approved" => Some(Self::BashPermissionPromptApproved),
             "bash_permission_prompt_denied" => Some(Self::BashPermissionPromptDenied),
             "plugin_tool_roundtrip" => Some(Self::PluginToolRoundtrip),
-            "auto_compact_triggered" => Some(Self::AutoCompactTriggered),
-            "token_cost_reporting" => Some(Self::TokenCostReporting),
             _ => None,
         }
     }
@@ -133,8 +129,6 @@ impl Scenario {
             Self::BashPermissionPromptApproved => "bash_permission_prompt_approved",
             Self::BashPermissionPromptDenied => "bash_permission_prompt_denied",
             Self::PluginToolRoundtrip => "plugin_tool_roundtrip",
-            Self::AutoCompactTriggered => "auto_compact_triggered",
-            Self::TokenCostReporting => "token_cost_reporting",
         }
     }
 }
@@ -458,12 +452,6 @@ fn build_stream_body(request: &MessageRequest, scenario: Scenario) -> String {
                 &[r#"{"message":"hello from plugin parity"}"#],
             ),
         },
-        Scenario::AutoCompactTriggered => {
-            final_text_sse_with_usage("auto compact parity complete.", 50_000, 200)
-        }
-        Scenario::TokenCostReporting => {
-            final_text_sse_with_usage("token cost reporting parity complete.", 1_000, 500)
-        }
     }
 }
 
@@ -622,18 +610,6 @@ fn build_message_response(request: &MessageRequest, scenario: Scenario) -> Messa
                 json!({"message": "hello from plugin parity"}),
             ),
         },
-        Scenario::AutoCompactTriggered => text_message_response_with_usage(
-            "msg_auto_compact_triggered",
-            "auto compact parity complete.",
-            50_000,
-            200,
-        ),
-        Scenario::TokenCostReporting => text_message_response_with_usage(
-            "msg_token_cost_reporting",
-            "token cost reporting parity complete.",
-            1_000,
-            500,
-        ),
     }
 }
 
@@ -649,8 +625,6 @@ fn request_id_for(scenario: Scenario) -> &'static str {
         Scenario::BashPermissionPromptApproved => "req_bash_permission_prompt_approved",
         Scenario::BashPermissionPromptDenied => "req_bash_permission_prompt_denied",
         Scenario::PluginToolRoundtrip => "req_plugin_tool_roundtrip",
-        Scenario::AutoCompactTriggered => "req_auto_compact_triggered",
-        Scenario::TokenCostReporting => "req_token_cost_reporting",
     }
 }
 
@@ -687,32 +661,6 @@ fn text_message_response(id: &str, text: &str) -> MessageResponse {
     }
 }
 
-fn text_message_response_with_usage(
-    id: &str,
-    text: &str,
-    input_tokens: u32,
-    output_tokens: u32,
-) -> MessageResponse {
-    MessageResponse {
-        id: id.to_string(),
-        kind: "message".to_string(),
-        role: "assistant".to_string(),
-        content: vec![OutputContentBlock::Text {
-            text: text.to_string(),
-        }],
-        model: DEFAULT_MODEL.to_string(),
-        stop_reason: Some("end_turn".to_string()),
-        stop_sequence: None,
-        usage: Usage {
-            input_tokens,
-            cache_creation_input_tokens: 0,
-            cache_read_input_tokens: 0,
-            output_tokens,
-        },
-        request_id: None,
-    }
-}
-
 fn tool_message_response(
     id: &str,
     tool_id: &str,
@@ -971,74 +919,6 @@ fn final_text_sse(text: &str) -> String {
     body
 }
 
-fn final_text_sse_with_usage(text: &str, input_tokens: u32, output_tokens: u32) -> String {
-    let mut body = String::new();
-    append_sse(
-        &mut body,
-        "message_start",
-        json!({
-            "type": "message_start",
-            "message": {
-                "id": unique_message_id(),
-                "type": "message",
-                "role": "assistant",
-                "content": [],
-                "model": DEFAULT_MODEL,
-                "stop_reason": null,
-                "stop_sequence": null,
-                "usage": {
-                    "input_tokens": input_tokens,
-                    "cache_creation_input_tokens": 0,
-                    "cache_read_input_tokens": 0,
-                    "output_tokens": 0
-                }
-            }
-        }),
-    );
-    append_sse(
-        &mut body,
-        "content_block_start",
-        json!({
-            "type": "content_block_start",
-            "index": 0,
-            "content_block": {"type": "text", "text": ""}
-        }),
-    );
-    append_sse(
-        &mut body,
-        "content_block_delta",
-        json!({
-            "type": "content_block_delta",
-            "index": 0,
-            "delta": {"type": "text_delta", "text": text}
-        }),
-    );
-    append_sse(
-        &mut body,
-        "content_block_stop",
-        json!({
-            "type": "content_block_stop",
-            "index": 0
-        }),
-    );
-    append_sse(
-        &mut body,
-        "message_delta",
-        json!({
-            "type": "message_delta",
-            "delta": {"stop_reason": "end_turn", "stop_sequence": null},
-            "usage": {
-                "input_tokens": input_tokens,
-                "cache_creation_input_tokens": 0,
-                "cache_read_input_tokens": 0,
-                "output_tokens": output_tokens
-            }
-        }),
-    );
-    append_sse(&mut body, "message_stop", json!({"type": "message_stop"}));
-    body
-}
-
 #[allow(clippy::needless_pass_by_value)]
 fn append_sse(buffer: &mut String, event: &str, payload: Value) {
     use std::fmt::Write as _;

rust/crates/plugins/src/hooks.rs

@@ -73,7 +73,7 @@ impl HookRunner {
 
     #[must_use]
     pub fn run_pre_tool_use(&self, tool_name: &str, tool_input: &str) -> HookRunResult {
-        Self::run_commands(
+        self.run_commands(
             HookEvent::PreToolUse,
             &self.hooks.pre_tool_use,
             tool_name,
@@ -91,7 +91,7 @@ impl HookRunner {
         tool_output: &str,
         is_error: bool,
     ) -> HookRunResult {
-        Self::run_commands(
+        self.run_commands(
             HookEvent::PostToolUse,
             &self.hooks.post_tool_use,
             tool_name,
@@ -108,7 +108,7 @@ impl HookRunner {
         tool_input: &str,
         tool_error: &str,
     ) -> HookRunResult {
-        Self::run_commands(
+        self.run_commands(
             HookEvent::PostToolUseFailure,
             &self.hooks.post_tool_use_failure,
             tool_name,
@@ -119,6 +119,7 @@ impl HookRunner {
     }
 
     fn run_commands(
+        &self,
         event: HookEvent,
         commands: &[String],
         tool_name: &str,
@@ -135,7 +136,7 @@ impl HookRunner {
         let mut messages = Vec::new();
 
         for command in commands {
-            match Self::run_command(
+            match self.run_command(
                 command,
                 event,
                 tool_name,
@@ -173,8 +174,9 @@ impl HookRunner {
         HookRunResult::allow(messages)
     }
 
-    #[allow(clippy::too_many_arguments)]
+    #[allow(clippy::too_many_arguments, clippy::unused_self)]
     fn run_command(
+        &self,
         command: &str,
         event: HookEvent,
         tool_name: &str,

rust/crates/runtime/src/bash.rs

@@ -134,8 +134,8 @@ async fn execute_bash_async(
     };
 
     let (output, interrupted) = output_result;
-    let stdout = truncate_output(&String::from_utf8_lossy(&output.stdout));
-    let stderr = truncate_output(&String::from_utf8_lossy(&output.stderr));
+    let stdout = String::from_utf8_lossy(&output.stdout).into_owned();
+    let stderr = String::from_utf8_lossy(&output.stderr).into_owned();
     let no_output_expected = Some(stdout.trim().is_empty() && stderr.trim().is_empty());
     let return_code_interpretation = output.status.code().and_then(|code| {
         if code == 0 {
@@ -281,53 +281,3 @@ mod tests {
         assert!(!output.sandbox_status.expect("sandbox status").enabled);
     }
 }
-
-/// Maximum output bytes before truncation (16 KiB, matching upstream).
-const MAX_OUTPUT_BYTES: usize = 16_384;
-
-/// Truncate output to `MAX_OUTPUT_BYTES`, appending a marker when trimmed.
-fn truncate_output(s: &str) -> String {
-    if s.len() <= MAX_OUTPUT_BYTES {
-        return s.to_string();
-    }
-    // Find the last valid UTF-8 boundary at or before MAX_OUTPUT_BYTES
-    let mut end = MAX_OUTPUT_BYTES;
-    while end > 0 && !s.is_char_boundary(end) {
-        end -= 1;
-    }
-    let mut truncated = s[..end].to_string();
-    truncated.push_str("\n\n[output truncated — exceeded 16384 bytes]");
-    truncated
-}
-
-#[cfg(test)]
-mod truncation_tests {
-    use super::*;
-
-    #[test]
-    fn short_output_unchanged() {
-        let s = "hello world";
-        assert_eq!(truncate_output(s), s);
-    }
-
-    #[test]
-    fn long_output_truncated() {
-        let s = "x".repeat(20_000);
-        let result = truncate_output(&s);
-        assert!(result.len() < 20_000);
-        assert!(result.ends_with("[output truncated — exceeded 16384 bytes]"));
-    }
-
-    #[test]
-    fn exact_boundary_unchanged() {
-        let s = "a".repeat(MAX_OUTPUT_BYTES);
-        assert_eq!(truncate_output(&s), s);
-    }
-
-    #[test]
-    fn one_over_boundary_truncated() {
-        let s = "a".repeat(MAX_OUTPUT_BYTES + 1);
-        let result = truncate_output(&s);
-        assert!(result.contains("[output truncated"));
-    }
-}

rust/crates/runtime/src/conversation.rs

@@ -847,7 +847,7 @@ mod tests {
                         AssistantEvent::MessageStop,
                     ])
                 }
-                _ => unreachable!("extra API call"),
+                _ => Err(RuntimeError::new("unexpected extra API call")),
             }
         }
     }
@@ -1156,7 +1156,7 @@ mod tests {
                             AssistantEvent::MessageStop,
                         ])
                     }
-                    _ => unreachable!("extra API call"),
+                    _ => Err(RuntimeError::new("unexpected extra API call")),
                 }
             }
         }
@@ -1231,7 +1231,7 @@ mod tests {
                             AssistantEvent::MessageStop,
                         ])
                     }
-                    _ => unreachable!("extra API call"),
+                    _ => Err(RuntimeError::new("unexpected extra API call")),
                 }
             }
         }
@@ -1545,6 +1545,7 @@ mod tests {
 
     #[test]
     fn auto_compaction_threshold_defaults_and_parses_values() {
+        // given / when / then
         assert_eq!(
             parse_auto_compaction_threshold(None),
             DEFAULT_AUTO_COMPACTION_INPUT_TOKENS_THRESHOLD

rust/crates/runtime/src/file_ops.rs

@@ -28,6 +28,7 @@ fn is_binary_file(path: &Path) -> io::Result<bool> {
 /// Validate that a resolved path stays within the given workspace root.
 /// Returns the canonical path on success, or an error if the path escapes
 /// the workspace boundary (e.g. via `../` traversal or symlink).
+#[allow(dead_code)]
 fn validate_workspace_boundary(resolved: &Path, workspace_root: &Path) -> io::Result<()> {
     if !resolved.starts_with(workspace_root) {
         return Err(io::Error::new(
@@ -544,6 +545,7 @@ fn normalize_path_allow_missing(path: &str) -> io::Result<PathBuf> {
 }
 
 /// Read a file with workspace boundary enforcement.
+#[allow(dead_code)]
 pub fn read_file_in_workspace(
     path: &str,
     offset: Option<usize>,
@@ -559,6 +561,7 @@ pub fn read_file_in_workspace(
 }
 
 /// Write a file with workspace boundary enforcement.
+#[allow(dead_code)]
 pub fn write_file_in_workspace(
     path: &str,
     content: &str,
@@ -573,6 +576,7 @@ pub fn write_file_in_workspace(
 }
 
 /// Edit a file with workspace boundary enforcement.
+#[allow(dead_code)]
 pub fn edit_file_in_workspace(
     path: &str,
     old_string: &str,
@@ -589,6 +593,7 @@ pub fn edit_file_in_workspace(
 }
 
 /// Check whether a path is a symlink that resolves outside the workspace.
+#[allow(dead_code)]
 pub fn is_symlink_escape(path: &Path, workspace_root: &Path) -> io::Result<bool> {
     let metadata = fs::symlink_metadata(path)?;
     if !metadata.is_symlink() {

rust/crates/runtime/src/green_contract.rs

@@ -1,152 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
-#[serde(rename_all = "snake_case")]
-pub enum GreenLevel {
-    TargetedTests,
-    Package,
-    Workspace,
-    MergeReady,
-}
-
-impl GreenLevel {
-    #[must_use]
-    pub fn as_str(self) -> &'static str {
-        match self {
-            Self::TargetedTests => "targeted_tests",
-            Self::Package => "package",
-            Self::Workspace => "workspace",
-            Self::MergeReady => "merge_ready",
-        }
-    }
-}
-
-impl std::fmt::Display for GreenLevel {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self.as_str())
-    }
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
-pub struct GreenContract {
-    pub required_level: GreenLevel,
-}
-
-impl GreenContract {
-    #[must_use]
-    pub fn new(required_level: GreenLevel) -> Self {
-        Self { required_level }
-    }
-
-    #[must_use]
-    pub fn evaluate(self, observed_level: Option<GreenLevel>) -> GreenContractOutcome {
-        match observed_level {
-            Some(level) if level >= self.required_level => GreenContractOutcome::Satisfied {
-                required_level: self.required_level,
-                observed_level: level,
-            },
-            _ => GreenContractOutcome::Unsatisfied {
-                required_level: self.required_level,
-                observed_level,
-            },
-        }
-    }
-
-    #[must_use]
-    pub fn is_satisfied_by(self, observed_level: GreenLevel) -> bool {
-        observed_level >= self.required_level
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(tag = "outcome", rename_all = "snake_case")]
-pub enum GreenContractOutcome {
-    Satisfied {
-        required_level: GreenLevel,
-        observed_level: GreenLevel,
-    },
-    Unsatisfied {
-        required_level: GreenLevel,
-        observed_level: Option<GreenLevel>,
-    },
-}
-
-impl GreenContractOutcome {
-    #[must_use]
-    pub fn is_satisfied(&self) -> bool {
-        matches!(self, Self::Satisfied { .. })
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn given_matching_level_when_evaluating_contract_then_it_is_satisfied() {
-        // given
-        let contract = GreenContract::new(GreenLevel::Package);
-
-        // when
-        let outcome = contract.evaluate(Some(GreenLevel::Package));
-
-        // then
-        assert_eq!(
-            outcome,
-            GreenContractOutcome::Satisfied {
-                required_level: GreenLevel::Package,
-                observed_level: GreenLevel::Package,
-            }
-        );
-        assert!(outcome.is_satisfied());
-    }
-
-    #[test]
-    fn given_higher_level_when_checking_requirement_then_it_still_satisfies_contract() {
-        // given
-        let contract = GreenContract::new(GreenLevel::TargetedTests);
-
-        // when
-        let is_satisfied = contract.is_satisfied_by(GreenLevel::Workspace);
-
-        // then
-        assert!(is_satisfied);
-    }
-
-    #[test]
-    fn given_lower_level_when_evaluating_contract_then_it_is_unsatisfied() {
-        // given
-        let contract = GreenContract::new(GreenLevel::Workspace);
-
-        // when
-        let outcome = contract.evaluate(Some(GreenLevel::Package));
-
-        // then
-        assert_eq!(
-            outcome,
-            GreenContractOutcome::Unsatisfied {
-                required_level: GreenLevel::Workspace,
-                observed_level: Some(GreenLevel::Package),
-            }
-        );
-        assert!(!outcome.is_satisfied());
-    }
-
-    #[test]
-    fn given_no_green_level_when_evaluating_contract_then_contract_is_unsatisfied() {
-        // given
-        let contract = GreenContract::new(GreenLevel::MergeReady);
-
-        // when
-        let outcome = contract.evaluate(None);
-
-        // then
-        assert_eq!(
-            outcome,
-            GreenContractOutcome::Unsatisfied {
-                required_level: GreenLevel::MergeReady,
-                observed_level: None,
-            }
-        );
-    }
-}

rust/crates/runtime/src/lib.rs

@@ -1,39 +1,24 @@
 mod bash;
-pub mod bash_validation;
 mod bootstrap;
 mod compact;
 mod config;
 mod conversation;
 mod file_ops;
-pub mod green_contract;
 mod hooks;
 mod json;
-pub mod lsp_client;
 mod mcp;
 mod mcp_client;
-pub mod mcp_lifecycle_hardened;
 mod mcp_stdio;
-pub mod mcp_tool_bridge;
 mod oauth;
-pub mod permission_enforcer;
-mod policy_engine;
-pub mod recovery_recipes;
 mod permissions;
-pub mod plugin_lifecycle;
 mod prompt;
 mod remote;
-pub mod session_control;
 pub mod sandbox;
 mod session;
 mod sse;
-pub mod stale_branch;
-pub mod summary_compression;
 pub mod task_registry;
-pub mod task_packet;
 pub mod team_cron_registry;
-pub mod trust_resolver;
 mod usage;
-pub mod worker_boot;
 
 pub use bash::{execute_bash, BashCommandInput, BashCommandOutput};
 pub use bootstrap::{BootstrapPhase, BootstrapPlan};
@@ -70,18 +55,13 @@ pub use mcp_client::{
     McpClientAuth, McpClientBootstrap, McpClientTransport, McpManagedProxyTransport,
     McpRemoteTransport, McpSdkTransport, McpStdioTransport,
 };
-pub use mcp_lifecycle_hardened::{
-    McpDegradedReport, McpErrorSurface, McpFailedServer, McpLifecyclePhase, McpLifecycleState,
-    McpLifecycleValidator, McpPhaseResult,
-};
 pub use mcp_stdio::{
     spawn_mcp_stdio_process, JsonRpcError, JsonRpcId, JsonRpcRequest, JsonRpcResponse,
-    ManagedMcpTool, McpDiscoveryFailure, McpInitializeClientInfo, McpInitializeParams,
+    ManagedMcpResource, ManagedMcpTool, McpInitializeClientInfo, McpInitializeParams,
     McpInitializeResult, McpInitializeServerInfo, McpListResourcesParams, McpListResourcesResult,
     McpListToolsParams, McpListToolsResult, McpReadResourceParams, McpReadResourceResult,
     McpResource, McpResourceContents, McpServerManager, McpServerManagerError, McpStdioProcess,
-    McpTool, McpToolCallContent, McpToolCallParams, McpToolCallResult, McpToolDiscoveryReport,
-    UnsupportedMcpServer,
+    McpTool, McpToolCallContent, McpToolCallParams, McpToolCallResult, UnsupportedMcpServer,
 };
 pub use oauth::{
     clear_oauth_credentials, code_challenge_s256, credentials_path, generate_pkce_pair,
@@ -90,22 +70,10 @@ pub use oauth::{
     OAuthCallbackParams, OAuthRefreshRequest, OAuthTokenExchangeRequest, OAuthTokenSet,
     PkceChallengeMethod, PkceCodePair,
 };
-pub use policy_engine::{
-    evaluate, DiffScope, GreenLevel, LaneBlocker, LaneContext, PolicyAction, PolicyCondition,
-    PolicyEngine, PolicyRule, ReviewStatus,
-};
 pub use permissions::{
     PermissionContext, PermissionMode, PermissionOutcome, PermissionOverride, PermissionPolicy,
     PermissionPromptDecision, PermissionPrompter, PermissionRequest,
 };
-pub use plugin_lifecycle::{
-    DegradedMode, DiscoveryResult, PluginHealthcheck, PluginLifecycle, PluginLifecycleEvent,
-    PluginState, ResourceInfo, ServerHealth, ServerStatus, ToolInfo,
-};
-pub use recovery_recipes::{
-    attempt_recovery, recipe_for, EscalationPolicy, FailureScenario, RecoveryContext,
-    RecoveryEvent, RecoveryRecipe, RecoveryResult, RecoveryStep,
-};
 pub use prompt::{
     load_system_prompt, prepend_bullets, ContextFile, ProjectContext, PromptBuildError,
     SystemPromptBuilder, FRONTIER_MODEL_NAME, SYSTEM_PROMPT_DYNAMIC_BOUNDARY,
@@ -125,24 +93,10 @@ pub use session::{
     ContentBlock, ConversationMessage, MessageRole, Session, SessionCompaction, SessionError,
     SessionFork,
 };
-pub use stale_branch::{
-    apply_policy, check_freshness, BranchFreshness, StaleBranchAction, StaleBranchEvent,
-    StaleBranchPolicy,
-};
 pub use sse::{IncrementalSseParser, SseEvent};
-pub use task_packet::{
-    validate_packet, AcceptanceTest, BranchPolicy, CommitPolicy,
-    RepoConfig, ReportingContract, TaskPacket, TaskPacketValidationError, TaskScope,
-    ValidatedPacket,
-};
 pub use usage::{
     format_usd, pricing_for_model, ModelPricing, TokenUsage, UsageCostEstimate, UsageTracker,
 };
-pub use trust_resolver::{TrustConfig, TrustDecision, TrustEvent, TrustPolicy, TrustResolver};
-pub use worker_boot::{
-    Worker, WorkerEvent, WorkerEventKind, WorkerFailure, WorkerFailureKind, WorkerReadySnapshot,
-    WorkerRegistry, WorkerStatus,
-};
 
 #[cfg(test)]
 pub(crate) fn test_env_lock() -> std::sync::MutexGuard<'static, ()> {

rust/crates/runtime/src/lsp_client.rs

@@ -1,746 +0,0 @@
-//! LSP (Language Server Protocol) client registry for tool dispatch.
-
-use std::collections::HashMap;
-use std::sync::{Arc, Mutex};
-
-use serde::{Deserialize, Serialize};
-
-/// Supported LSP actions.
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "snake_case")]
-pub enum LspAction {
-    Diagnostics,
-    Hover,
-    Definition,
-    References,
-    Completion,
-    Symbols,
-    Format,
-}
-
-impl LspAction {
-    pub fn from_str(s: &str) -> Option<Self> {
-        match s {
-            "diagnostics" => Some(Self::Diagnostics),
-            "hover" => Some(Self::Hover),
-            "definition" | "goto_definition" => Some(Self::Definition),
-            "references" | "find_references" => Some(Self::References),
-            "completion" | "completions" => Some(Self::Completion),
-            "symbols" | "document_symbols" => Some(Self::Symbols),
-            "format" | "formatting" => Some(Self::Format),
-            _ => None,
-        }
-    }
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct LspDiagnostic {
-    pub path: String,
-    pub line: u32,
-    pub character: u32,
-    pub severity: String,
-    pub message: String,
-    pub source: Option<String>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct LspLocation {
-    pub path: String,
-    pub line: u32,
-    pub character: u32,
-    pub end_line: Option<u32>,
-    pub end_character: Option<u32>,
-    pub preview: Option<String>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct LspHoverResult {
-    pub content: String,
-    pub language: Option<String>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct LspCompletionItem {
-    pub label: String,
-    pub kind: Option<String>,
-    pub detail: Option<String>,
-    pub insert_text: Option<String>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct LspSymbol {
-    pub name: String,
-    pub kind: String,
-    pub path: String,
-    pub line: u32,
-    pub character: u32,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "snake_case")]
-pub enum LspServerStatus {
-    Connected,
-    Disconnected,
-    Starting,
-    Error,
-}
-
-impl std::fmt::Display for LspServerStatus {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::Connected => write!(f, "connected"),
-            Self::Disconnected => write!(f, "disconnected"),
-            Self::Starting => write!(f, "starting"),
-            Self::Error => write!(f, "error"),
-        }
-    }
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct LspServerState {
-    pub language: String,
-    pub status: LspServerStatus,
-    pub root_path: Option<String>,
-    pub capabilities: Vec<String>,
-    pub diagnostics: Vec<LspDiagnostic>,
-}
-
-#[derive(Debug, Clone, Default)]
-pub struct LspRegistry {
-    inner: Arc<Mutex<RegistryInner>>,
-}
-
-#[derive(Debug, Default)]
-struct RegistryInner {
-    servers: HashMap<String, LspServerState>,
-}
-
-impl LspRegistry {
-    #[must_use]
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    pub fn register(
-        &self,
-        language: &str,
-        status: LspServerStatus,
-        root_path: Option<&str>,
-        capabilities: Vec<String>,
-    ) {
-        let mut inner = self.inner.lock().expect("lsp registry lock poisoned");
-        inner.servers.insert(
-            language.to_owned(),
-            LspServerState {
-                language: language.to_owned(),
-                status,
-                root_path: root_path.map(str::to_owned),
-                capabilities,
-                diagnostics: Vec::new(),
-            },
-        );
-    }
-
-    pub fn get(&self, language: &str) -> Option<LspServerState> {
-        let inner = self.inner.lock().expect("lsp registry lock poisoned");
-        inner.servers.get(language).cloned()
-    }
-
-    /// Find the appropriate server for a file path based on extension.
-    pub fn find_server_for_path(&self, path: &str) -> Option<LspServerState> {
-        let ext = std::path::Path::new(path)
-            .extension()
-            .and_then(|e| e.to_str())
-            .unwrap_or("");
-
-        let language = match ext {
-            "rs" => "rust",
-            "ts" | "tsx" => "typescript",
-            "js" | "jsx" => "javascript",
-            "py" => "python",
-            "go" => "go",
-            "java" => "java",
-            "c" | "h" => "c",
-            "cpp" | "hpp" | "cc" => "cpp",
-            "rb" => "ruby",
-            "lua" => "lua",
-            _ => return None,
-        };
-
-        self.get(language)
-    }
-
-    /// List all registered servers.
-    pub fn list_servers(&self) -> Vec<LspServerState> {
-        let inner = self.inner.lock().expect("lsp registry lock poisoned");
-        inner.servers.values().cloned().collect()
-    }
-
-    /// Add diagnostics to a server.
-    pub fn add_diagnostics(
-        &self,
-        language: &str,
-        diagnostics: Vec<LspDiagnostic>,
-    ) -> Result<(), String> {
-        let mut inner = self.inner.lock().expect("lsp registry lock poisoned");
-        let server = inner
-            .servers
-            .get_mut(language)
-            .ok_or_else(|| format!("LSP server not found for language: {language}"))?;
-        server.diagnostics.extend(diagnostics);
-        Ok(())
-    }
-
-    /// Get diagnostics for a specific file path.
-    pub fn get_diagnostics(&self, path: &str) -> Vec<LspDiagnostic> {
-        let inner = self.inner.lock().expect("lsp registry lock poisoned");
-        inner
-            .servers
-            .values()
-            .flat_map(|s| &s.diagnostics)
-            .filter(|d| d.path == path)
-            .cloned()
-            .collect()
-    }
-
-    /// Clear diagnostics for a language server.
-    pub fn clear_diagnostics(&self, language: &str) -> Result<(), String> {
-        let mut inner = self.inner.lock().expect("lsp registry lock poisoned");
-        let server = inner
-            .servers
-            .get_mut(language)
-            .ok_or_else(|| format!("LSP server not found for language: {language}"))?;
-        server.diagnostics.clear();
-        Ok(())
-    }
-
-    /// Disconnect a server.
-    pub fn disconnect(&self, language: &str) -> Option<LspServerState> {
-        let mut inner = self.inner.lock().expect("lsp registry lock poisoned");
-        inner.servers.remove(language)
-    }
-
-    #[must_use]
-    pub fn len(&self) -> usize {
-        let inner = self.inner.lock().expect("lsp registry lock poisoned");
-        inner.servers.len()
-    }
-
-    #[must_use]
-    pub fn is_empty(&self) -> bool {
-        self.len() == 0
-    }
-
-    /// Dispatch an LSP action and return a structured result.
-    pub fn dispatch(
-        &self,
-        action: &str,
-        path: Option<&str>,
-        line: Option<u32>,
-        character: Option<u32>,
-        _query: Option<&str>,
-    ) -> Result<serde_json::Value, String> {
-        let lsp_action =
-            LspAction::from_str(action).ok_or_else(|| format!("unknown LSP action: {action}"))?;
-
-        // For diagnostics, we can check existing cached diagnostics
-        if lsp_action == LspAction::Diagnostics {
-            if let Some(path) = path {
-                let diags = self.get_diagnostics(path);
-                return Ok(serde_json::json!({
-                    "action": "diagnostics",
-                    "path": path,
-                    "diagnostics": diags,
-                    "count": diags.len()
-                }));
-            }
-            // All diagnostics across all servers
-            let inner = self.inner.lock().expect("lsp registry lock poisoned");
-            let all_diags: Vec<_> = inner
-                .servers
-                .values()
-                .flat_map(|s| &s.diagnostics)
-                .collect();
-            return Ok(serde_json::json!({
-                "action": "diagnostics",
-                "diagnostics": all_diags,
-                "count": all_diags.len()
-            }));
-        }
-
-        // For other actions, we need a connected server for the given file
-        let path = path.ok_or("path is required for this LSP action")?;
-        let server = self
-            .find_server_for_path(path)
-            .ok_or_else(|| format!("no LSP server available for path: {path}"))?;
-
-        if server.status != LspServerStatus::Connected {
-            return Err(format!(
-                "LSP server for '{}' is not connected (status: {})",
-                server.language, server.status
-            ));
-        }
-
-        // Return structured placeholder — actual LSP JSON-RPC calls would
-        // go through the real LSP process here.
-        Ok(serde_json::json!({
-            "action": action,
-            "path": path,
-            "line": line,
-            "character": character,
-            "language": server.language,
-            "status": "dispatched",
-            "message": format!("LSP {} dispatched to {} server", action, server.language)
-        }))
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn registers_and_retrieves_server() {
-        let registry = LspRegistry::new();
-        registry.register(
-            "rust",
-            LspServerStatus::Connected,
-            Some("/workspace"),
-            vec!["hover".into(), "completion".into()],
-        );
-
-        let server = registry.get("rust").expect("should exist");
-        assert_eq!(server.language, "rust");
-        assert_eq!(server.status, LspServerStatus::Connected);
-        assert_eq!(server.capabilities.len(), 2);
-    }
-
-    #[test]
-    fn finds_server_by_file_extension() {
-        let registry = LspRegistry::new();
-        registry.register("rust", LspServerStatus::Connected, None, vec![]);
-        registry.register("typescript", LspServerStatus::Connected, None, vec![]);
-
-        let rs_server = registry.find_server_for_path("src/main.rs").unwrap();
-        assert_eq!(rs_server.language, "rust");
-
-        let ts_server = registry.find_server_for_path("src/index.ts").unwrap();
-        assert_eq!(ts_server.language, "typescript");
-
-        assert!(registry.find_server_for_path("data.csv").is_none());
-    }
-
-    #[test]
-    fn manages_diagnostics() {
-        let registry = LspRegistry::new();
-        registry.register("rust", LspServerStatus::Connected, None, vec![]);
-
-        registry
-            .add_diagnostics(
-                "rust",
-                vec![LspDiagnostic {
-                    path: "src/main.rs".into(),
-                    line: 10,
-                    character: 5,
-                    severity: "error".into(),
-                    message: "mismatched types".into(),
-                    source: Some("rust-analyzer".into()),
-                }],
-            )
-            .unwrap();
-
-        let diags = registry.get_diagnostics("src/main.rs");
-        assert_eq!(diags.len(), 1);
-        assert_eq!(diags[0].message, "mismatched types");
-
-        registry.clear_diagnostics("rust").unwrap();
-        assert!(registry.get_diagnostics("src/main.rs").is_empty());
-    }
-
-    #[test]
-    fn dispatches_diagnostics_action() {
-        let registry = LspRegistry::new();
-        registry.register("rust", LspServerStatus::Connected, None, vec![]);
-        registry
-            .add_diagnostics(
-                "rust",
-                vec![LspDiagnostic {
-                    path: "src/lib.rs".into(),
-                    line: 1,
-                    character: 0,
-                    severity: "warning".into(),
-                    message: "unused import".into(),
-                    source: None,
-                }],
-            )
-            .unwrap();
-
-        let result = registry
-            .dispatch("diagnostics", Some("src/lib.rs"), None, None, None)
-            .unwrap();
-        assert_eq!(result["count"], 1);
-    }
-
-    #[test]
-    fn dispatches_hover_action() {
-        let registry = LspRegistry::new();
-        registry.register("rust", LspServerStatus::Connected, None, vec![]);
-
-        let result = registry
-            .dispatch("hover", Some("src/main.rs"), Some(10), Some(5), None)
-            .unwrap();
-        assert_eq!(result["action"], "hover");
-        assert_eq!(result["language"], "rust");
-    }
-
-    #[test]
-    fn rejects_action_on_disconnected_server() {
-        let registry = LspRegistry::new();
-        registry.register("rust", LspServerStatus::Disconnected, None, vec![]);
-
-        assert!(registry
-            .dispatch("hover", Some("src/main.rs"), Some(1), Some(0), None)
-            .is_err());
-    }
-
-    #[test]
-    fn rejects_unknown_action() {
-        let registry = LspRegistry::new();
-        assert!(registry
-            .dispatch("unknown_action", Some("file.rs"), None, None, None)
-            .is_err());
-    }
-
-    #[test]
-    fn disconnects_server() {
-        let registry = LspRegistry::new();
-        registry.register("rust", LspServerStatus::Connected, None, vec![]);
-        assert_eq!(registry.len(), 1);
-
-        let removed = registry.disconnect("rust");
-        assert!(removed.is_some());
-        assert!(registry.is_empty());
-    }
-
-    #[test]
-    fn lsp_action_from_str_all_aliases() {
-        // given
-        let cases = [
-            ("diagnostics", Some(LspAction::Diagnostics)),
-            ("hover", Some(LspAction::Hover)),
-            ("definition", Some(LspAction::Definition)),
-            ("goto_definition", Some(LspAction::Definition)),
-            ("references", Some(LspAction::References)),
-            ("find_references", Some(LspAction::References)),
-            ("completion", Some(LspAction::Completion)),
-            ("completions", Some(LspAction::Completion)),
-            ("symbols", Some(LspAction::Symbols)),
-            ("document_symbols", Some(LspAction::Symbols)),
-            ("format", Some(LspAction::Format)),
-            ("formatting", Some(LspAction::Format)),
-            ("unknown", None),
-        ];
-
-        // when
-        let resolved: Vec<_> = cases
-            .into_iter()
-            .map(|(input, expected)| (input, LspAction::from_str(input), expected))
-            .collect();
-
-        // then
-        for (input, actual, expected) in resolved {
-            assert_eq!(actual, expected, "unexpected action resolution for {input}");
-        }
-    }
-
-    #[test]
-    fn lsp_server_status_display_all_variants() {
-        // given
-        let cases = [
-            (LspServerStatus::Connected, "connected"),
-            (LspServerStatus::Disconnected, "disconnected"),
-            (LspServerStatus::Starting, "starting"),
-            (LspServerStatus::Error, "error"),
-        ];
-
-        // when
-        let rendered: Vec<_> = cases
-            .into_iter()
-            .map(|(status, expected)| (status.to_string(), expected))
-            .collect();
-
-        // then
-        assert_eq!(
-            rendered,
-            vec![
-                ("connected".to_string(), "connected"),
-                ("disconnected".to_string(), "disconnected"),
-                ("starting".to_string(), "starting"),
-                ("error".to_string(), "error"),
-            ]
-        );
-    }
-
-    #[test]
-    fn dispatch_diagnostics_without_path_aggregates() {
-        // given
-        let registry = LspRegistry::new();
-        registry.register("rust", LspServerStatus::Connected, None, vec![]);
-        registry.register("python", LspServerStatus::Connected, None, vec![]);
-        registry
-            .add_diagnostics(
-                "rust",
-                vec![LspDiagnostic {
-                    path: "src/lib.rs".into(),
-                    line: 1,
-                    character: 0,
-                    severity: "warning".into(),
-                    message: "unused import".into(),
-                    source: Some("rust-analyzer".into()),
-                }],
-            )
-            .expect("rust diagnostics should add");
-        registry
-            .add_diagnostics(
-                "python",
-                vec![LspDiagnostic {
-                    path: "script.py".into(),
-                    line: 2,
-                    character: 4,
-                    severity: "error".into(),
-                    message: "undefined name".into(),
-                    source: Some("pyright".into()),
-                }],
-            )
-            .expect("python diagnostics should add");
-
-        // when
-        let result = registry
-            .dispatch("diagnostics", None, None, None, None)
-            .expect("aggregate diagnostics should work");
-
-        // then
-        assert_eq!(result["action"], "diagnostics");
-        assert_eq!(result["count"], 2);
-        assert_eq!(result["diagnostics"].as_array().map(Vec::len), Some(2));
-    }
-
-    #[test]
-    fn dispatch_non_diagnostics_requires_path() {
-        // given
-        let registry = LspRegistry::new();
-
-        // when
-        let result = registry.dispatch("hover", None, Some(1), Some(0), None);
-
-        // then
-        assert_eq!(
-            result.expect_err("path should be required"),
-            "path is required for this LSP action"
-        );
-    }
-
-    #[test]
-    fn dispatch_no_server_for_path_errors() {
-        // given
-        let registry = LspRegistry::new();
-
-        // when
-        let result = registry.dispatch("hover", Some("notes.md"), Some(1), Some(0), None);
-
-        // then
-        let error = result.expect_err("missing server should fail");
-        assert!(error.contains("no LSP server available for path: notes.md"));
-    }
-
-    #[test]
-    fn dispatch_disconnected_server_error_payload() {
-        // given
-        let registry = LspRegistry::new();
-        registry.register("typescript", LspServerStatus::Disconnected, None, vec![]);
-
-        // when
-        let result = registry.dispatch("hover", Some("src/index.ts"), Some(3), Some(2), None);
-
-        // then
-        let error = result.expect_err("disconnected server should fail");
-        assert!(error.contains("typescript"));
-        assert!(error.contains("disconnected"));
-    }
-
-    #[test]
-    fn find_server_for_all_extensions() {
-        // given
-        let registry = LspRegistry::new();
-        for language in [
-            "rust",
-            "typescript",
-            "javascript",
-            "python",
-            "go",
-            "java",
-            "c",
-            "cpp",
-            "ruby",
-            "lua",
-        ] {
-            registry.register(language, LspServerStatus::Connected, None, vec![]);
-        }
-        let cases = [
-            ("src/main.rs", "rust"),
-            ("src/index.ts", "typescript"),
-            ("src/view.tsx", "typescript"),
-            ("src/app.js", "javascript"),
-            ("src/app.jsx", "javascript"),
-            ("script.py", "python"),
-            ("main.go", "go"),
-            ("Main.java", "java"),
-            ("native.c", "c"),
-            ("native.h", "c"),
-            ("native.cpp", "cpp"),
-            ("native.hpp", "cpp"),
-            ("native.cc", "cpp"),
-            ("script.rb", "ruby"),
-            ("script.lua", "lua"),
-        ];
-
-        // when
-        let resolved: Vec<_> = cases
-            .into_iter()
-            .map(|(path, expected)| {
-                (
-                    path,
-                    registry
-                        .find_server_for_path(path)
-                        .map(|server| server.language),
-                    expected,
-                )
-            })
-            .collect();
-
-        // then
-        for (path, actual, expected) in resolved {
-            assert_eq!(
-                actual.as_deref(),
-                Some(expected),
-                "unexpected mapping for {path}"
-            );
-        }
-    }
-
-    #[test]
-    fn find_server_for_path_no_extension() {
-        // given
-        let registry = LspRegistry::new();
-        registry.register("rust", LspServerStatus::Connected, None, vec![]);
-
-        // when
-        let result = registry.find_server_for_path("Makefile");
-
-        // then
-        assert!(result.is_none());
-    }
-
-    #[test]
-    fn list_servers_with_multiple() {
-        // given
-        let registry = LspRegistry::new();
-        registry.register("rust", LspServerStatus::Connected, None, vec![]);
-        registry.register("typescript", LspServerStatus::Starting, None, vec![]);
-        registry.register("python", LspServerStatus::Error, None, vec![]);
-
-        // when
-        let servers = registry.list_servers();
-
-        // then
-        assert_eq!(servers.len(), 3);
-        assert!(servers.iter().any(|server| server.language == "rust"));
-        assert!(servers.iter().any(|server| server.language == "typescript"));
-        assert!(servers.iter().any(|server| server.language == "python"));
-    }
-
-    #[test]
-    fn get_missing_server_returns_none() {
-        // given
-        let registry = LspRegistry::new();
-
-        // when
-        let server = registry.get("missing");
-
-        // then
-        assert!(server.is_none());
-    }
-
-    #[test]
-    fn add_diagnostics_missing_language_errors() {
-        // given
-        let registry = LspRegistry::new();
-
-        // when
-        let result = registry.add_diagnostics("missing", vec![]);
-
-        // then
-        let error = result.expect_err("missing language should fail");
-        assert!(error.contains("LSP server not found for language: missing"));
-    }
-
-    #[test]
-    fn get_diagnostics_across_servers() {
-        // given
-        let registry = LspRegistry::new();
-        let shared_path = "shared/file.txt";
-        registry.register("rust", LspServerStatus::Connected, None, vec![]);
-        registry.register("python", LspServerStatus::Connected, None, vec![]);
-        registry
-            .add_diagnostics(
-                "rust",
-                vec![LspDiagnostic {
-                    path: shared_path.into(),
-                    line: 4,
-                    character: 1,
-                    severity: "warning".into(),
-                    message: "warn".into(),
-                    source: None,
-                }],
-            )
-            .expect("rust diagnostics should add");
-        registry
-            .add_diagnostics(
-                "python",
-                vec![LspDiagnostic {
-                    path: shared_path.into(),
-                    line: 8,
-                    character: 3,
-                    severity: "error".into(),
-                    message: "err".into(),
-                    source: None,
-                }],
-            )
-            .expect("python diagnostics should add");
-
-        // when
-        let diagnostics = registry.get_diagnostics(shared_path);
-
-        // then
-        assert_eq!(diagnostics.len(), 2);
-        assert!(diagnostics
-            .iter()
-            .any(|diagnostic| diagnostic.message == "warn"));
-        assert!(diagnostics
-            .iter()
-            .any(|diagnostic| diagnostic.message == "err"));
-    }
-
-    #[test]
-    fn clear_diagnostics_missing_language_errors() {
-        // given
-        let registry = LspRegistry::new();
-
-        // when
-        let result = registry.clear_diagnostics("missing");
-
-        // then
-        let error = result.expect_err("missing language should fail");
-        assert!(error.contains("LSP server not found for language: missing"));
-    }
-}

rust/crates/runtime/src/mcp_lifecycle_hardened.rs

@@ -1,761 +0,0 @@
-use std::collections::{BTreeMap, BTreeSet};
-use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
-
-use serde::{Deserialize, Serialize};
-
-fn now_secs() -> u64 {
-    SystemTime::now()
-        .duration_since(UNIX_EPOCH)
-        .unwrap_or_default()
-        .as_secs()
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
-#[serde(rename_all = "snake_case")]
-pub enum McpLifecyclePhase {
-    ConfigLoad,
-    ServerRegistration,
-    SpawnConnect,
-    InitializeHandshake,
-    ToolDiscovery,
-    ResourceDiscovery,
-    Ready,
-    Invocation,
-    ErrorSurfacing,
-    Shutdown,
-    Cleanup,
-}
-
-impl McpLifecyclePhase {
-    #[must_use]
-    pub fn all() -> [Self; 11] {
-        [
-            Self::ConfigLoad,
-            Self::ServerRegistration,
-            Self::SpawnConnect,
-            Self::InitializeHandshake,
-            Self::ToolDiscovery,
-            Self::ResourceDiscovery,
-            Self::Ready,
-            Self::Invocation,
-            Self::ErrorSurfacing,
-            Self::Shutdown,
-            Self::Cleanup,
-        ]
-    }
-}
-
-impl std::fmt::Display for McpLifecyclePhase {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::ConfigLoad => write!(f, "config_load"),
-            Self::ServerRegistration => write!(f, "server_registration"),
-            Self::SpawnConnect => write!(f, "spawn_connect"),
-            Self::InitializeHandshake => write!(f, "initialize_handshake"),
-            Self::ToolDiscovery => write!(f, "tool_discovery"),
-            Self::ResourceDiscovery => write!(f, "resource_discovery"),
-            Self::Ready => write!(f, "ready"),
-            Self::Invocation => write!(f, "invocation"),
-            Self::ErrorSurfacing => write!(f, "error_surfacing"),
-            Self::Shutdown => write!(f, "shutdown"),
-            Self::Cleanup => write!(f, "cleanup"),
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub struct McpErrorSurface {
-    pub phase: McpLifecyclePhase,
-    pub server_name: Option<String>,
-    pub message: String,
-    pub context: BTreeMap<String, String>,
-    pub recoverable: bool,
-    pub timestamp: u64,
-}
-
-impl McpErrorSurface {
-    #[must_use]
-    pub fn new(
-        phase: McpLifecyclePhase,
-        server_name: Option<String>,
-        message: impl Into<String>,
-        context: BTreeMap<String, String>,
-        recoverable: bool,
-    ) -> Self {
-        Self {
-            phase,
-            server_name,
-            message: message.into(),
-            context,
-            recoverable,
-            timestamp: now_secs(),
-        }
-    }
-}
-
-impl std::fmt::Display for McpErrorSurface {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(
-            f,
-            "MCP lifecycle error during {}: {}",
-            self.phase, self.message
-        )?;
-        if let Some(server_name) = &self.server_name {
-            write!(f, " (server: {server_name})")?;
-        }
-        if !self.context.is_empty() {
-            write!(f, " with context {:?}", self.context)?;
-        }
-        if self.recoverable {
-            write!(f, " [recoverable]")?;
-        }
-        Ok(())
-    }
-}
-
-impl std::error::Error for McpErrorSurface {}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum McpPhaseResult {
-    Success {
-        phase: McpLifecyclePhase,
-        duration: Duration,
-    },
-    Failure {
-        phase: McpLifecyclePhase,
-        error: McpErrorSurface,
-        recoverable: bool,
-    },
-    Timeout {
-        phase: McpLifecyclePhase,
-        waited: Duration,
-    },
-}
-
-impl McpPhaseResult {
-    #[must_use]
-    pub fn phase(&self) -> McpLifecyclePhase {
-        match self {
-            Self::Success { phase, .. }
-            | Self::Failure { phase, .. }
-            | Self::Timeout { phase, .. } => *phase,
-        }
-    }
-}
-
-#[derive(Debug, Clone, Default)]
-pub struct McpLifecycleState {
-    current_phase: Option<McpLifecyclePhase>,
-    phase_errors: BTreeMap<McpLifecyclePhase, Vec<McpErrorSurface>>,
-    phase_timestamps: BTreeMap<McpLifecyclePhase, u64>,
-    phase_results: Vec<McpPhaseResult>,
-}
-
-impl McpLifecycleState {
-    #[must_use]
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    #[must_use]
-    pub fn current_phase(&self) -> Option<McpLifecyclePhase> {
-        self.current_phase
-    }
-
-    #[must_use]
-    pub fn errors_for_phase(&self, phase: McpLifecyclePhase) -> &[McpErrorSurface] {
-        self.phase_errors
-            .get(&phase)
-            .map(Vec::as_slice)
-            .unwrap_or(&[])
-    }
-
-    #[must_use]
-    pub fn results(&self) -> &[McpPhaseResult] {
-        &self.phase_results
-    }
-
-    #[must_use]
-    pub fn phase_timestamps(&self) -> &BTreeMap<McpLifecyclePhase, u64> {
-        &self.phase_timestamps
-    }
-
-    #[must_use]
-    pub fn phase_timestamp(&self, phase: McpLifecyclePhase) -> Option<u64> {
-        self.phase_timestamps.get(&phase).copied()
-    }
-
-    fn record_phase(&mut self, phase: McpLifecyclePhase) {
-        self.current_phase = Some(phase);
-        self.phase_timestamps.insert(phase, now_secs());
-    }
-
-    fn record_error(&mut self, error: McpErrorSurface) {
-        self.phase_errors
-            .entry(error.phase)
-            .or_default()
-            .push(error);
-    }
-
-    fn record_result(&mut self, result: McpPhaseResult) {
-        self.phase_results.push(result);
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub struct McpFailedServer {
-    pub server_name: String,
-    pub phase: McpLifecyclePhase,
-    pub error: McpErrorSurface,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub struct McpDegradedReport {
-    pub working_servers: Vec<String>,
-    pub failed_servers: Vec<McpFailedServer>,
-    pub available_tools: Vec<String>,
-    pub missing_tools: Vec<String>,
-}
-
-impl McpDegradedReport {
-    #[must_use]
-    pub fn new(
-        working_servers: Vec<String>,
-        failed_servers: Vec<McpFailedServer>,
-        available_tools: Vec<String>,
-        expected_tools: Vec<String>,
-    ) -> Self {
-        let working_servers = dedupe_sorted(working_servers);
-        let available_tools = dedupe_sorted(available_tools);
-        let available_tool_set: BTreeSet<_> = available_tools.iter().cloned().collect();
-        let expected_tools = dedupe_sorted(expected_tools);
-        let missing_tools = expected_tools
-            .into_iter()
-            .filter(|tool| !available_tool_set.contains(tool))
-            .collect();
-
-        Self {
-            working_servers,
-            failed_servers,
-            available_tools,
-            missing_tools,
-        }
-    }
-}
-
-#[derive(Debug, Clone, Default)]
-pub struct McpLifecycleValidator {
-    state: McpLifecycleState,
-}
-
-impl McpLifecycleValidator {
-    #[must_use]
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    #[must_use]
-    pub fn state(&self) -> &McpLifecycleState {
-        &self.state
-    }
-
-    #[must_use]
-    pub fn validate_phase_transition(from: McpLifecyclePhase, to: McpLifecyclePhase) -> bool {
-        match (from, to) {
-            (McpLifecyclePhase::ConfigLoad, McpLifecyclePhase::ServerRegistration)
-            | (McpLifecyclePhase::ServerRegistration, McpLifecyclePhase::SpawnConnect)
-            | (McpLifecyclePhase::SpawnConnect, McpLifecyclePhase::InitializeHandshake)
-            | (McpLifecyclePhase::InitializeHandshake, McpLifecyclePhase::ToolDiscovery)
-            | (McpLifecyclePhase::ToolDiscovery, McpLifecyclePhase::ResourceDiscovery)
-            | (McpLifecyclePhase::ToolDiscovery, McpLifecyclePhase::Ready)
-            | (McpLifecyclePhase::ResourceDiscovery, McpLifecyclePhase::Ready)
-            | (McpLifecyclePhase::Ready, McpLifecyclePhase::Invocation)
-            | (McpLifecyclePhase::Invocation, McpLifecyclePhase::Ready)
-            | (McpLifecyclePhase::ErrorSurfacing, McpLifecyclePhase::Ready)
-            | (McpLifecyclePhase::ErrorSurfacing, McpLifecyclePhase::Shutdown)
-            | (McpLifecyclePhase::Shutdown, McpLifecyclePhase::Cleanup) => true,
-            (_, McpLifecyclePhase::Shutdown) => from != McpLifecyclePhase::Cleanup,
-            (_, McpLifecyclePhase::ErrorSurfacing) => {
-                from != McpLifecyclePhase::Cleanup && from != McpLifecyclePhase::Shutdown
-            }
-            _ => false,
-        }
-    }
-
-    pub fn run_phase(&mut self, phase: McpLifecyclePhase) -> McpPhaseResult {
-        let started = Instant::now();
-
-        if let Some(current_phase) = self.state.current_phase() {
-            if !Self::validate_phase_transition(current_phase, phase) {
-                return self.record_failure(
-                    phase,
-                    McpErrorSurface::new(
-                        phase,
-                        None,
-                        format!("invalid MCP lifecycle transition from {current_phase} to {phase}"),
-                        BTreeMap::from([
-                            ("from".to_string(), current_phase.to_string()),
-                            ("to".to_string(), phase.to_string()),
-                        ]),
-                        false,
-                    ),
-                    false,
-                );
-            }
-        } else if phase != McpLifecyclePhase::ConfigLoad {
-            return self.record_failure(
-                phase,
-                McpErrorSurface::new(
-                    phase,
-                    None,
-                    format!("invalid initial MCP lifecycle phase {phase}"),
-                    BTreeMap::from([("phase".to_string(), phase.to_string())]),
-                    false,
-                ),
-                false,
-            );
-        }
-
-        self.state.record_phase(phase);
-        let result = McpPhaseResult::Success {
-            phase,
-            duration: started.elapsed(),
-        };
-        self.state.record_result(result.clone());
-        result
-    }
-
-    pub fn record_failure(
-        &mut self,
-        phase: McpLifecyclePhase,
-        error: McpErrorSurface,
-        recoverable: bool,
-    ) -> McpPhaseResult {
-        self.state.record_error(error.clone());
-        self.state.record_phase(McpLifecyclePhase::ErrorSurfacing);
-        let result = McpPhaseResult::Failure {
-            phase,
-            error,
-            recoverable,
-        };
-        self.state.record_result(result.clone());
-        result
-    }
-
-    pub fn record_timeout(
-        &mut self,
-        phase: McpLifecyclePhase,
-        waited: Duration,
-        server_name: Option<String>,
-        mut context: BTreeMap<String, String>,
-    ) -> McpPhaseResult {
-        context.insert("waited_ms".to_string(), waited.as_millis().to_string());
-        let error = McpErrorSurface::new(
-            phase,
-            server_name,
-            format!(
-                "MCP lifecycle phase {phase} timed out after {} ms",
-                waited.as_millis()
-            ),
-            context,
-            true,
-        );
-        self.state.record_error(error);
-        self.state.record_phase(McpLifecyclePhase::ErrorSurfacing);
-        let result = McpPhaseResult::Timeout { phase, waited };
-        self.state.record_result(result.clone());
-        result
-    }
-}
-
-fn dedupe_sorted(mut values: Vec<String>) -> Vec<String> {
-    values.sort();
-    values.dedup();
-    values
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    use serde_json::json;
-
-    #[test]
-    fn phase_display_matches_serde_name() {
-        // given
-        let phases = McpLifecyclePhase::all();
-
-        // when
-        let serialized = phases
-            .into_iter()
-            .map(|phase| {
-                (
-                    phase.to_string(),
-                    serde_json::to_value(phase).expect("serialize phase"),
-                )
-            })
-            .collect::<Vec<_>>();
-
-        // then
-        for (display, json_value) in serialized {
-            assert_eq!(json_value, json!(display));
-        }
-    }
-
-    #[test]
-    fn given_startup_path_when_running_to_cleanup_then_each_control_transition_succeeds() {
-        // given
-        let mut validator = McpLifecycleValidator::new();
-        let phases = [
-            McpLifecyclePhase::ConfigLoad,
-            McpLifecyclePhase::ServerRegistration,
-            McpLifecyclePhase::SpawnConnect,
-            McpLifecyclePhase::InitializeHandshake,
-            McpLifecyclePhase::ToolDiscovery,
-            McpLifecyclePhase::ResourceDiscovery,
-            McpLifecyclePhase::Ready,
-            McpLifecyclePhase::Invocation,
-            McpLifecyclePhase::Ready,
-            McpLifecyclePhase::Shutdown,
-            McpLifecyclePhase::Cleanup,
-        ];
-
-        // when
-        let results = phases
-            .into_iter()
-            .map(|phase| validator.run_phase(phase))
-            .collect::<Vec<_>>();
-
-        // then
-        assert!(results
-            .iter()
-            .all(|result| matches!(result, McpPhaseResult::Success { .. })));
-        assert_eq!(
-            validator.state().current_phase(),
-            Some(McpLifecyclePhase::Cleanup)
-        );
-        for phase in [
-            McpLifecyclePhase::ConfigLoad,
-            McpLifecyclePhase::ServerRegistration,
-            McpLifecyclePhase::SpawnConnect,
-            McpLifecyclePhase::InitializeHandshake,
-            McpLifecyclePhase::ToolDiscovery,
-            McpLifecyclePhase::ResourceDiscovery,
-            McpLifecyclePhase::Ready,
-            McpLifecyclePhase::Invocation,
-            McpLifecyclePhase::Shutdown,
-            McpLifecyclePhase::Cleanup,
-        ] {
-            assert!(validator.state().phase_timestamp(phase).is_some());
-        }
-    }
-
-    #[test]
-    fn given_tool_discovery_when_resource_discovery_is_skipped_then_ready_is_still_allowed() {
-        // given
-        let mut validator = McpLifecycleValidator::new();
-        for phase in [
-            McpLifecyclePhase::ConfigLoad,
-            McpLifecyclePhase::ServerRegistration,
-            McpLifecyclePhase::SpawnConnect,
-            McpLifecyclePhase::InitializeHandshake,
-            McpLifecyclePhase::ToolDiscovery,
-        ] {
-            let result = validator.run_phase(phase);
-            assert!(matches!(result, McpPhaseResult::Success { .. }));
-        }
-
-        // when
-        let result = validator.run_phase(McpLifecyclePhase::Ready);
-
-        // then
-        assert!(matches!(result, McpPhaseResult::Success { .. }));
-        assert_eq!(
-            validator.state().current_phase(),
-            Some(McpLifecyclePhase::Ready)
-        );
-    }
-
-    #[test]
-    fn validates_expected_phase_transitions() {
-        // given
-        let valid_transitions = [
-            (
-                McpLifecyclePhase::ConfigLoad,
-                McpLifecyclePhase::ServerRegistration,
-            ),
-            (
-                McpLifecyclePhase::ServerRegistration,
-                McpLifecyclePhase::SpawnConnect,
-            ),
-            (
-                McpLifecyclePhase::SpawnConnect,
-                McpLifecyclePhase::InitializeHandshake,
-            ),
-            (
-                McpLifecyclePhase::InitializeHandshake,
-                McpLifecyclePhase::ToolDiscovery,
-            ),
-            (
-                McpLifecyclePhase::ToolDiscovery,
-                McpLifecyclePhase::ResourceDiscovery,
-            ),
-            (McpLifecyclePhase::ToolDiscovery, McpLifecyclePhase::Ready),
-            (
-                McpLifecyclePhase::ResourceDiscovery,
-                McpLifecyclePhase::Ready,
-            ),
-            (McpLifecyclePhase::Ready, McpLifecyclePhase::Invocation),
-            (McpLifecyclePhase::Invocation, McpLifecyclePhase::Ready),
-            (McpLifecyclePhase::Ready, McpLifecyclePhase::Shutdown),
-            (
-                McpLifecyclePhase::Invocation,
-                McpLifecyclePhase::ErrorSurfacing,
-            ),
-            (
-                McpLifecyclePhase::ErrorSurfacing,
-                McpLifecyclePhase::Shutdown,
-            ),
-            (McpLifecyclePhase::Shutdown, McpLifecyclePhase::Cleanup),
-        ];
-
-        // when / then
-        for (from, to) in valid_transitions {
-            assert!(McpLifecycleValidator::validate_phase_transition(from, to));
-        }
-        assert!(!McpLifecycleValidator::validate_phase_transition(
-            McpLifecyclePhase::Ready,
-            McpLifecyclePhase::ConfigLoad,
-        ));
-        assert!(!McpLifecycleValidator::validate_phase_transition(
-            McpLifecyclePhase::Cleanup,
-            McpLifecyclePhase::Ready,
-        ));
-    }
-
-    #[test]
-    fn given_invalid_transition_when_running_phase_then_structured_failure_is_recorded() {
-        // given
-        let mut validator = McpLifecycleValidator::new();
-        let _ = validator.run_phase(McpLifecyclePhase::ConfigLoad);
-        let _ = validator.run_phase(McpLifecyclePhase::ServerRegistration);
-
-        // when
-        let result = validator.run_phase(McpLifecyclePhase::Ready);
-
-        // then
-        match result {
-            McpPhaseResult::Failure {
-                phase,
-                error,
-                recoverable,
-            } => {
-                assert_eq!(phase, McpLifecyclePhase::Ready);
-                assert!(!recoverable);
-                assert_eq!(error.phase, McpLifecyclePhase::Ready);
-                assert_eq!(
-                    error.context.get("from").map(String::as_str),
-                    Some("server_registration")
-                );
-                assert_eq!(error.context.get("to").map(String::as_str), Some("ready"));
-            }
-            other => panic!("expected failure result, got {other:?}"),
-        }
-        assert_eq!(
-            validator.state().current_phase(),
-            Some(McpLifecyclePhase::ErrorSurfacing)
-        );
-        assert_eq!(
-            validator
-                .state()
-                .errors_for_phase(McpLifecyclePhase::Ready)
-                .len(),
-            1
-        );
-    }
-
-    #[test]
-    fn given_each_phase_when_failure_is_recorded_then_error_is_tracked_per_phase() {
-        // given
-        let mut validator = McpLifecycleValidator::new();
-
-        // when / then
-        for phase in McpLifecyclePhase::all() {
-            let result = validator.record_failure(
-                phase,
-                McpErrorSurface::new(
-                    phase,
-                    Some("alpha".to_string()),
-                    format!("failure at {phase}"),
-                    BTreeMap::from([("server".to_string(), "alpha".to_string())]),
-                    phase == McpLifecyclePhase::ResourceDiscovery,
-                ),
-                phase == McpLifecyclePhase::ResourceDiscovery,
-            );
-
-            match result {
-                McpPhaseResult::Failure {
-                    phase: failed_phase,
-                    error,
-                    recoverable,
-                } => {
-                    assert_eq!(failed_phase, phase);
-                    assert_eq!(error.phase, phase);
-                    assert_eq!(recoverable, phase == McpLifecyclePhase::ResourceDiscovery);
-                }
-                other => panic!("expected failure result, got {other:?}"),
-            }
-            assert_eq!(validator.state().errors_for_phase(phase).len(), 1);
-        }
-    }
-
-    #[test]
-    fn given_spawn_connect_timeout_when_recorded_then_waited_duration_is_preserved() {
-        // given
-        let mut validator = McpLifecycleValidator::new();
-        let waited = Duration::from_millis(250);
-
-        // when
-        let result = validator.record_timeout(
-            McpLifecyclePhase::SpawnConnect,
-            waited,
-            Some("alpha".to_string()),
-            BTreeMap::from([("attempt".to_string(), "1".to_string())]),
-        );
-
-        // then
-        match result {
-            McpPhaseResult::Timeout {
-                phase,
-                waited: actual,
-            } => {
-                assert_eq!(phase, McpLifecyclePhase::SpawnConnect);
-                assert_eq!(actual, waited);
-            }
-            other => panic!("expected timeout result, got {other:?}"),
-        }
-        let errors = validator
-            .state()
-            .errors_for_phase(McpLifecyclePhase::SpawnConnect);
-        assert_eq!(errors.len(), 1);
-        assert_eq!(
-            errors[0].context.get("waited_ms").map(String::as_str),
-            Some("250")
-        );
-        assert_eq!(
-            validator.state().current_phase(),
-            Some(McpLifecyclePhase::ErrorSurfacing)
-        );
-    }
-
-    #[test]
-    fn given_partial_server_health_when_building_degraded_report_then_missing_tools_are_reported() {
-        // given
-        let failed = vec![McpFailedServer {
-            server_name: "broken".to_string(),
-            phase: McpLifecyclePhase::InitializeHandshake,
-            error: McpErrorSurface::new(
-                McpLifecyclePhase::InitializeHandshake,
-                Some("broken".to_string()),
-                "initialize failed",
-                BTreeMap::from([("reason".to_string(), "broken pipe".to_string())]),
-                false,
-            ),
-        }];
-
-        // when
-        let report = McpDegradedReport::new(
-            vec!["alpha".to_string(), "beta".to_string(), "alpha".to_string()],
-            failed,
-            vec![
-                "alpha.echo".to_string(),
-                "beta.search".to_string(),
-                "alpha.echo".to_string(),
-            ],
-            vec![
-                "alpha.echo".to_string(),
-                "beta.search".to_string(),
-                "broken.fetch".to_string(),
-            ],
-        );
-
-        // then
-        assert_eq!(
-            report.working_servers,
-            vec!["alpha".to_string(), "beta".to_string()]
-        );
-        assert_eq!(report.failed_servers.len(), 1);
-        assert_eq!(report.failed_servers[0].server_name, "broken");
-        assert_eq!(
-            report.available_tools,
-            vec!["alpha.echo".to_string(), "beta.search".to_string()]
-        );
-        assert_eq!(report.missing_tools, vec!["broken.fetch".to_string()]);
-    }
-
-    #[test]
-    fn given_failure_during_resource_discovery_when_shutting_down_then_cleanup_still_succeeds() {
-        // given
-        let mut validator = McpLifecycleValidator::new();
-        for phase in [
-            McpLifecyclePhase::ConfigLoad,
-            McpLifecyclePhase::ServerRegistration,
-            McpLifecyclePhase::SpawnConnect,
-            McpLifecyclePhase::InitializeHandshake,
-            McpLifecyclePhase::ToolDiscovery,
-        ] {
-            let result = validator.run_phase(phase);
-            assert!(matches!(result, McpPhaseResult::Success { .. }));
-        }
-        let _ = validator.record_failure(
-            McpLifecyclePhase::ResourceDiscovery,
-            McpErrorSurface::new(
-                McpLifecyclePhase::ResourceDiscovery,
-                Some("alpha".to_string()),
-                "resource listing failed",
-                BTreeMap::from([("reason".to_string(), "timeout".to_string())]),
-                true,
-            ),
-            true,
-        );
-
-        // when
-        let shutdown = validator.run_phase(McpLifecyclePhase::Shutdown);
-        let cleanup = validator.run_phase(McpLifecyclePhase::Cleanup);
-
-        // then
-        assert!(matches!(shutdown, McpPhaseResult::Success { .. }));
-        assert!(matches!(cleanup, McpPhaseResult::Success { .. }));
-        assert_eq!(
-            validator.state().current_phase(),
-            Some(McpLifecyclePhase::Cleanup)
-        );
-        assert!(validator
-            .state()
-            .phase_timestamp(McpLifecyclePhase::ErrorSurfacing)
-            .is_some());
-    }
-
-    #[test]
-    fn error_surface_display_includes_phase_server_and_recoverable_flag() {
-        // given
-        let error = McpErrorSurface::new(
-            McpLifecyclePhase::SpawnConnect,
-            Some("alpha".to_string()),
-            "process exited early",
-            BTreeMap::from([("exit_code".to_string(), "1".to_string())]),
-            true,
-        );
-
-        // when
-        let rendered = error.to_string();
-
-        // then
-        assert!(rendered.contains("spawn_connect"));
-        assert!(rendered.contains("process exited early"));
-        assert!(rendered.contains("server: alpha"));
-        assert!(rendered.contains("recoverable"));
-        let trait_object: &dyn std::error::Error = &error;
-        assert_eq!(trait_object.to_string(), rendered);
-    }
-}

rust/crates/runtime/src/mcp_stdio.rs

@@ -25,6 +25,11 @@ const MCP_LIST_TOOLS_TIMEOUT_MS: u64 = 300;
 #[cfg(not(test))]
 const MCP_LIST_TOOLS_TIMEOUT_MS: u64 = 30_000;
 
+#[cfg(test)]
+const MCP_LIST_RESOURCES_TIMEOUT_MS: u64 = 300;
+#[cfg(not(test))]
+const MCP_LIST_RESOURCES_TIMEOUT_MS: u64 = 30_000;
+
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 #[serde(untagged)]
 pub enum JsonRpcId {
@@ -223,6 +228,12 @@ pub struct ManagedMcpTool {
     pub tool: McpTool,
 }
 
+#[derive(Debug, Clone, PartialEq)]
+pub struct ManagedMcpResource {
+    pub server_name: String,
+    pub resource: McpResource,
+}
+
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct UnsupportedMcpServer {
     pub server_name: String,
@@ -230,19 +241,6 @@ pub struct UnsupportedMcpServer {
     pub reason: String,
 }
 
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct McpDiscoveryFailure {
-    pub server_name: String,
-    pub error: String,
-}
-
-#[derive(Debug, Clone, PartialEq)]
-pub struct McpToolDiscoveryReport {
-    pub tools: Vec<ManagedMcpTool>,
-    pub failed_servers: Vec<McpDiscoveryFailure>,
-    pub unsupported_servers: Vec<UnsupportedMcpServer>,
-}
-
 #[derive(Debug)]
 pub enum McpServerManagerError {
     Io(io::Error),
@@ -410,11 +408,6 @@ impl McpServerManager {
         &self.unsupported_servers
     }
 
-    #[must_use]
-    pub fn server_names(&self) -> Vec<String> {
-        self.servers.keys().cloned().collect()
-    }
-
     pub async fn discover_tools(&mut self) -> Result<Vec<ManagedMcpTool>, McpServerManagerError> {
         let server_names = self.servers.keys().cloned().collect::<Vec<_>>();
         let mut discovered_tools = Vec::new();
@@ -438,41 +431,63 @@ impl McpServerManager {
         Ok(discovered_tools)
     }
 
-    pub async fn discover_tools_best_effort(&mut self) -> McpToolDiscoveryReport {
-        let server_names = self.server_names();
-        let mut discovered_tools = Vec::new();
-        let mut failed_servers = Vec::new();
+    pub async fn list_resources(
+        &mut self,
+        server_name: Option<&str>,
+    ) -> Result<Vec<ManagedMcpResource>, McpServerManagerError> {
+        let server_names = match server_name {
+            Some(server_name) => vec![server_name.to_string()],
+            None => self.servers.keys().cloned().collect::<Vec<_>>(),
+        };
+        let mut resources = Vec::new();
 
         for server_name in server_names {
-            match self.discover_tools_for_server(&server_name).await {
-                Ok(server_tools) => {
-                    self.clear_routes_for_server(&server_name);
-                    for tool in server_tools {
-                        self.tool_index.insert(
-                            tool.qualified_name.clone(),
-                            ToolRoute {
-                                server_name: tool.server_name.clone(),
-                                raw_name: tool.raw_name.clone(),
-                            },
-                        );
-                        discovered_tools.push(tool);
+            resources.extend(self.list_resources_for_server(&server_name).await?);
+        }
+
+        Ok(resources)
+    }
+
+    pub async fn read_resource(
+        &mut self,
+        server_name: &str,
+        uri: &str,
+    ) -> Result<JsonRpcResponse<McpReadResourceResult>, McpServerManagerError> {
+        let timeout_ms = self.tool_call_timeout_ms(server_name)?;
+
+        self.ensure_server_ready(server_name).await?;
+        let request_id = self.take_request_id();
+        let response =
+            {
+                let server = self.server_mut(server_name)?;
+                let process = server.process.as_mut().ok_or_else(|| {
+                    McpServerManagerError::InvalidResponse {
+                        server_name: server_name.to_string(),
+                        method: "resources/read",
+                        details: "server process missing after initialization".to_string(),
                     }
-                }
-                Err(error) => {
-                    self.clear_routes_for_server(&server_name);
-                    failed_servers.push(McpDiscoveryFailure {
-                        server_name,
-                        error: error.to_string(),
-                    });
-                }
+                })?;
+                Self::run_process_request(
+                    server_name,
+                    "resources/read",
+                    timeout_ms,
+                    process.read_resource(
+                        request_id,
+                        McpReadResourceParams {
+                            uri: uri.to_string(),
+                        },
+                    ),
+                )
+                .await
+            };
+
+        if let Err(error) = &response {
+            if Self::should_reset_server(error) {
+                self.reset_server(server_name).await?;
             }
         }
 
-        McpToolDiscoveryReport {
-            tools: discovered_tools,
-            failed_servers,
-            unsupported_servers: self.unsupported_servers.clone(),
-        }
+        response
     }
 
     pub async fn call_tool(
@@ -527,53 +542,6 @@ impl McpServerManager {
         response
     }
 
-    pub async fn list_resources(
-        &mut self,
-        server_name: &str,
-    ) -> Result<McpListResourcesResult, McpServerManagerError> {
-        let mut attempts = 0;
-
-        loop {
-            match self.list_resources_once(server_name).await {
-                Ok(resources) => return Ok(resources),
-                Err(error) if attempts == 0 && Self::is_retryable_error(&error) => {
-                    self.reset_server(server_name).await?;
-                    attempts += 1;
-                }
-                Err(error) => {
-                    if Self::should_reset_server(&error) {
-                        self.reset_server(server_name).await?;
-                    }
-                    return Err(error);
-                }
-            }
-        }
-    }
-
-    pub async fn read_resource(
-        &mut self,
-        server_name: &str,
-        uri: &str,
-    ) -> Result<McpReadResourceResult, McpServerManagerError> {
-        let mut attempts = 0;
-
-        loop {
-            match self.read_resource_once(server_name, uri).await {
-                Ok(resource) => return Ok(resource),
-                Err(error) if attempts == 0 && Self::is_retryable_error(&error) => {
-                    self.reset_server(server_name).await?;
-                    attempts += 1;
-                }
-                Err(error) => {
-                    if Self::should_reset_server(&error) {
-                        self.reset_server(server_name).await?;
-                    }
-                    return Err(error);
-                }
-            }
-        }
-    }
-
     pub async fn shutdown(&mut self) -> Result<(), McpServerManagerError> {
         let server_names = self.servers.keys().cloned().collect::<Vec<_>>();
         for server_name in server_names {
@@ -725,13 +693,36 @@ impl McpServerManager {
         Ok(discovered_tools)
     }
 
-    async fn list_resources_once(
+    async fn list_resources_for_server(
         &mut self,
         server_name: &str,
-    ) -> Result<McpListResourcesResult, McpServerManagerError> {
+    ) -> Result<Vec<ManagedMcpResource>, McpServerManagerError> {
+        let mut attempts = 0;
+
+        loop {
+            match self.list_resources_for_server_once(server_name).await {
+                Ok(resources) => return Ok(resources),
+                Err(error) if attempts == 0 && Self::is_retryable_error(&error) => {
+                    self.reset_server(server_name).await?;
+                    attempts += 1;
+                }
+                Err(error) => {
+                    if Self::should_reset_server(&error) {
+                        self.reset_server(server_name).await?;
+                    }
+                    return Err(error);
+                }
+            }
+        }
+    }
+
+    async fn list_resources_for_server_once(
+        &mut self,
+        server_name: &str,
+    ) -> Result<Vec<ManagedMcpResource>, McpServerManagerError> {
         self.ensure_server_ready(server_name).await?;
 
-        let mut resources = Vec::new();
+        let mut discovered_resources = Vec::new();
         let mut cursor = None;
         loop {
             let request_id = self.take_request_id();
@@ -747,7 +738,7 @@ impl McpServerManager {
                 Self::run_process_request(
                     server_name,
                     "resources/list",
-                    MCP_LIST_TOOLS_TIMEOUT_MS,
+                    MCP_LIST_RESOURCES_TIMEOUT_MS,
                     process.list_resources(
                         request_id,
                         Some(McpListResourcesParams {
@@ -774,7 +765,12 @@ impl McpServerManager {
                     details: "missing result payload".to_string(),
                 })?;
 
-            resources.extend(result.resources);
+            for resource in result.resources {
+                discovered_resources.push(ManagedMcpResource {
+                    server_name: server_name.to_string(),
+                    resource,
+                });
+            }
 
             match result.next_cursor {
                 Some(next_cursor) => cursor = Some(next_cursor),
@@ -782,59 +778,7 @@ impl McpServerManager {
             }
         }
 
-        Ok(McpListResourcesResult {
-            resources,
-            next_cursor: None,
-        })
-    }
-
-    async fn read_resource_once(
-        &mut self,
-        server_name: &str,
-        uri: &str,
-    ) -> Result<McpReadResourceResult, McpServerManagerError> {
-        self.ensure_server_ready(server_name).await?;
-
-        let request_id = self.take_request_id();
-        let response =
-            {
-                let server = self.server_mut(server_name)?;
-                let process = server.process.as_mut().ok_or_else(|| {
-                    McpServerManagerError::InvalidResponse {
-                        server_name: server_name.to_string(),
-                        method: "resources/read",
-                        details: "server process missing after initialization".to_string(),
-                    }
-                })?;
-                Self::run_process_request(
-                    server_name,
-                    "resources/read",
-                    MCP_LIST_TOOLS_TIMEOUT_MS,
-                    process.read_resource(
-                        request_id,
-                        McpReadResourceParams {
-                            uri: uri.to_string(),
-                        },
-                    ),
-                )
-                .await?
-            };
-
-        if let Some(error) = response.error {
-            return Err(McpServerManagerError::JsonRpc {
-                server_name: server_name.to_string(),
-                method: "resources/read",
-                error,
-            });
-        }
-
-        response
-            .result
-            .ok_or_else(|| McpServerManagerError::InvalidResponse {
-                server_name: server_name.to_string(),
-                method: "resources/read",
-                details: "missing result payload".to_string(),
-            })
+        Ok(discovered_resources)
     }
 
     async fn reset_server(&mut self, server_name: &str) -> Result<(), McpServerManagerError> {
@@ -1600,6 +1544,36 @@ mod tests {
             "                'isError': False",
             "            }",
             "        })",
+            "    elif method == 'resources/list':",
+            "        send_message({",
+            "            'jsonrpc': '2.0',",
+            "            'id': request['id'],",
+            "            'result': {",
+            "                'resources': [",
+            "                    {",
+            "                        'uri': f'resource://{LABEL}/guide.txt',",
+            "                        'name': f'{LABEL}-guide',",
+            "                        'description': f'Guide for {LABEL}',",
+            "                        'mimeType': 'text/plain'",
+            "                    }",
+            "                ]",
+            "            }",
+            "        })",
+            "    elif method == 'resources/read':",
+            "        uri = request['params']['uri']",
+            "        send_message({",
+            "            'jsonrpc': '2.0',",
+            "            'id': request['id'],",
+            "            'result': {",
+            "                'contents': [",
+            "                    {",
+            "                        'uri': uri,",
+            "                        'mimeType': 'text/plain',",
+            "                        'text': f'{LABEL} contents for {uri}'",
+            "                    }",
+            "                ]",
+            "            }",
+            "        })",
             "    else:",
             "        send_message({",
             "            'jsonrpc': '2.0',",
@@ -2150,6 +2124,60 @@ mod tests {
         });
     }
 
+    #[test]
+    fn manager_lists_and_reads_resources_from_stdio_servers() {
+        let runtime = Builder::new_current_thread()
+            .enable_all()
+            .build()
+            .expect("runtime");
+        runtime.block_on(async {
+            let script_path = write_manager_mcp_server_script();
+            let root = script_path.parent().expect("script parent");
+            let log_path = root.join("resources.log");
+            let servers = BTreeMap::from([(
+                "alpha".to_string(),
+                manager_server_config(&script_path, "alpha", &log_path),
+            )]);
+            let mut manager = McpServerManager::from_servers(&servers);
+
+            let resources = manager
+                .list_resources(Some("alpha"))
+                .await
+                .expect("list resources");
+
+            assert_eq!(resources.len(), 1);
+            assert_eq!(resources[0].server_name, "alpha");
+            assert_eq!(resources[0].resource.uri, "resource://alpha/guide.txt");
+            assert_eq!(resources[0].resource.name.as_deref(), Some("alpha-guide"));
+
+            let read = manager
+                .read_resource("alpha", "resource://alpha/guide.txt")
+                .await
+                .expect("read resource");
+
+            assert_eq!(
+                read.result.as_ref().map(|result| result.contents.len()),
+                Some(1)
+            );
+            assert_eq!(
+                read.result
+                    .as_ref()
+                    .and_then(|result| result.contents.first())
+                    .and_then(|content| content.text.as_deref()),
+                Some("alpha contents for resource://alpha/guide.txt")
+            );
+
+            let log = fs::read_to_string(&log_path).expect("read log");
+            assert_eq!(
+                log.lines().collect::<Vec<_>>(),
+                vec!["initialize", "resources/list", "resources/read"]
+            );
+
+            manager.shutdown().await.expect("shutdown");
+            cleanup_script(&script_path);
+        });
+    }
+
     #[test]
     fn manager_times_out_slow_tool_calls() {
         let runtime = Builder::new_current_thread()
@@ -2467,103 +2495,6 @@ mod tests {
         });
     }
 
-    #[test]
-    fn manager_lists_and_reads_resources_from_stdio_servers() {
-        let runtime = Builder::new_current_thread()
-            .enable_all()
-            .build()
-            .expect("runtime");
-        runtime.block_on(async {
-            let script_path = write_mcp_server_script();
-            let root = script_path.parent().expect("script parent");
-            let log_path = root.join("resources.log");
-            let servers = BTreeMap::from([(
-                "alpha".to_string(),
-                manager_server_config(&script_path, "alpha", &log_path),
-            )]);
-            let mut manager = McpServerManager::from_servers(&servers);
-
-            let listed = manager
-                .list_resources("alpha")
-                .await
-                .expect("list resources");
-            assert_eq!(listed.resources.len(), 1);
-            assert_eq!(listed.resources[0].uri, "file://guide.txt");
-
-            let read = manager
-                .read_resource("alpha", "file://guide.txt")
-                .await
-                .expect("read resource");
-            assert_eq!(read.contents.len(), 1);
-            assert_eq!(
-                read.contents[0].text.as_deref(),
-                Some("contents for file://guide.txt")
-            );
-
-            manager.shutdown().await.expect("shutdown");
-            cleanup_script(&script_path);
-        });
-    }
-
-    #[test]
-    fn manager_discovery_report_keeps_healthy_servers_when_one_server_fails() {
-        let runtime = Builder::new_current_thread()
-            .enable_all()
-            .build()
-            .expect("runtime");
-        runtime.block_on(async {
-            let script_path = write_manager_mcp_server_script();
-            let root = script_path.parent().expect("script parent");
-            let alpha_log = root.join("alpha.log");
-            let servers = BTreeMap::from([
-                (
-                    "alpha".to_string(),
-                    manager_server_config(&script_path, "alpha", &alpha_log),
-                ),
-                (
-                    "broken".to_string(),
-                    ScopedMcpServerConfig {
-                        scope: ConfigSource::Local,
-                        config: McpServerConfig::Stdio(McpStdioServerConfig {
-                            command: "python3".to_string(),
-                            args: vec!["-c".to_string(), "import sys; sys.exit(0)".to_string()],
-                            env: BTreeMap::new(),
-                            tool_call_timeout_ms: None,
-                        }),
-                    },
-                ),
-            ]);
-            let mut manager = McpServerManager::from_servers(&servers);
-
-            let report = manager.discover_tools_best_effort().await;
-
-            assert_eq!(report.tools.len(), 1);
-            assert_eq!(
-                report.tools[0].qualified_name,
-                mcp_tool_name("alpha", "echo")
-            );
-            assert_eq!(report.failed_servers.len(), 1);
-            assert_eq!(report.failed_servers[0].server_name, "broken");
-            assert!(report.failed_servers[0].error.contains("initialize"));
-
-            let response = manager
-                .call_tool(&mcp_tool_name("alpha", "echo"), Some(json!({"text": "ok"})))
-                .await
-                .expect("healthy server should remain callable");
-            assert_eq!(
-                response
-                    .result
-                    .as_ref()
-                    .and_then(|result| result.structured_content.as_ref())
-                    .and_then(|value| value.get("echoed")),
-                Some(&json!("ok"))
-            );
-
-            manager.shutdown().await.expect("shutdown");
-            cleanup_script(&script_path);
-        });
-    }
-
     #[test]
     fn manager_records_unsupported_non_stdio_servers_without_panicking() {
         let servers = BTreeMap::from([

rust/crates/runtime/src/mcp_tool_bridge.rs

@@ -1,912 +0,0 @@
-//! Bridge between MCP tool surface (ListMcpResources, ReadMcpResource, McpAuth, MCP)
-//! and the existing McpServerManager runtime.
-//!
-//! Provides a stateful client registry that tool handlers can use to
-//! connect to MCP servers and invoke their capabilities.
-
-use std::collections::HashMap;
-use std::sync::{Arc, Mutex, OnceLock};
-
-use crate::mcp::mcp_tool_name;
-use crate::mcp_stdio::McpServerManager;
-use serde::{Deserialize, Serialize};
-
-/// Status of a managed MCP server connection.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "snake_case")]
-pub enum McpConnectionStatus {
-    Disconnected,
-    Connecting,
-    Connected,
-    AuthRequired,
-    Error,
-}
-
-impl std::fmt::Display for McpConnectionStatus {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::Disconnected => write!(f, "disconnected"),
-            Self::Connecting => write!(f, "connecting"),
-            Self::Connected => write!(f, "connected"),
-            Self::AuthRequired => write!(f, "auth_required"),
-            Self::Error => write!(f, "error"),
-        }
-    }
-}
-
-/// Metadata about an MCP resource.
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct McpResourceInfo {
-    pub uri: String,
-    pub name: String,
-    pub description: Option<String>,
-    pub mime_type: Option<String>,
-}
-
-/// Metadata about an MCP tool exposed by a server.
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct McpToolInfo {
-    pub name: String,
-    pub description: Option<String>,
-    pub input_schema: Option<serde_json::Value>,
-}
-
-/// Tracked state of an MCP server connection.
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct McpServerState {
-    pub server_name: String,
-    pub status: McpConnectionStatus,
-    pub tools: Vec<McpToolInfo>,
-    pub resources: Vec<McpResourceInfo>,
-    pub server_info: Option<String>,
-    pub error_message: Option<String>,
-}
-
-#[derive(Debug, Clone, Default)]
-pub struct McpToolRegistry {
-    inner: Arc<Mutex<HashMap<String, McpServerState>>>,
-    manager: Arc<OnceLock<Arc<Mutex<McpServerManager>>>>,
-}
-
-impl McpToolRegistry {
-    #[must_use]
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    pub fn set_manager(
-        &self,
-        manager: Arc<Mutex<McpServerManager>>,
-    ) -> Result<(), Arc<Mutex<McpServerManager>>> {
-        self.manager.set(manager)
-    }
-
-    pub fn register_server(
-        &self,
-        server_name: &str,
-        status: McpConnectionStatus,
-        tools: Vec<McpToolInfo>,
-        resources: Vec<McpResourceInfo>,
-        server_info: Option<String>,
-    ) {
-        let mut inner = self.inner.lock().expect("mcp registry lock poisoned");
-        inner.insert(
-            server_name.to_owned(),
-            McpServerState {
-                server_name: server_name.to_owned(),
-                status,
-                tools,
-                resources,
-                server_info,
-                error_message: None,
-            },
-        );
-    }
-
-    pub fn get_server(&self, server_name: &str) -> Option<McpServerState> {
-        let inner = self.inner.lock().expect("mcp registry lock poisoned");
-        inner.get(server_name).cloned()
-    }
-
-    pub fn list_servers(&self) -> Vec<McpServerState> {
-        let inner = self.inner.lock().expect("mcp registry lock poisoned");
-        inner.values().cloned().collect()
-    }
-
-    pub fn list_resources(&self, server_name: &str) -> Result<Vec<McpResourceInfo>, String> {
-        let inner = self.inner.lock().expect("mcp registry lock poisoned");
-        match inner.get(server_name) {
-            Some(state) => {
-                if state.status != McpConnectionStatus::Connected {
-                    return Err(format!(
-                        "server '{}' is not connected (status: {})",
-                        server_name, state.status
-                    ));
-                }
-                Ok(state.resources.clone())
-            }
-            None => Err(format!("server '{}' not found", server_name)),
-        }
-    }
-
-    pub fn read_resource(&self, server_name: &str, uri: &str) -> Result<McpResourceInfo, String> {
-        let inner = self.inner.lock().expect("mcp registry lock poisoned");
-        let state = inner
-            .get(server_name)
-            .ok_or_else(|| format!("server '{}' not found", server_name))?;
-
-        if state.status != McpConnectionStatus::Connected {
-            return Err(format!(
-                "server '{}' is not connected (status: {})",
-                server_name, state.status
-            ));
-        }
-
-        state
-            .resources
-            .iter()
-            .find(|r| r.uri == uri)
-            .cloned()
-            .ok_or_else(|| format!("resource '{}' not found on server '{}'", uri, server_name))
-    }
-
-    pub fn list_tools(&self, server_name: &str) -> Result<Vec<McpToolInfo>, String> {
-        let inner = self.inner.lock().expect("mcp registry lock poisoned");
-        match inner.get(server_name) {
-            Some(state) => {
-                if state.status != McpConnectionStatus::Connected {
-                    return Err(format!(
-                        "server '{}' is not connected (status: {})",
-                        server_name, state.status
-                    ));
-                }
-                Ok(state.tools.clone())
-            }
-            None => Err(format!("server '{}' not found", server_name)),
-        }
-    }
-
-    fn spawn_tool_call(
-        manager: Arc<Mutex<McpServerManager>>,
-        qualified_tool_name: String,
-        arguments: Option<serde_json::Value>,
-    ) -> Result<serde_json::Value, String> {
-        let join_handle = std::thread::Builder::new()
-            .name(format!("mcp-tool-call-{qualified_tool_name}"))
-            .spawn(move || {
-                let runtime = tokio::runtime::Builder::new_current_thread()
-                    .enable_all()
-                    .build()
-                    .map_err(|error| format!("failed to create MCP tool runtime: {error}"))?;
-
-                runtime.block_on(async move {
-                    let response = {
-                        let mut manager = manager
-                            .lock()
-                            .map_err(|_| "mcp server manager lock poisoned".to_string())?;
-                        manager
-                            .discover_tools()
-                            .await
-                            .map_err(|error| error.to_string())?;
-                        let response = manager
-                            .call_tool(&qualified_tool_name, arguments)
-                            .await
-                            .map_err(|error| error.to_string());
-                        let shutdown = manager.shutdown().await.map_err(|error| error.to_string());
-
-                        match (response, shutdown) {
-                            (Ok(response), Ok(())) => Ok(response),
-                            (Err(error), Ok(())) | (Err(error), Err(_)) => Err(error),
-                            (Ok(_), Err(error)) => Err(error),
-                        }
-                    }?;
-
-                    if let Some(error) = response.error {
-                        return Err(format!(
-                            "MCP server returned JSON-RPC error for tools/call: {} ({})",
-                            error.message, error.code
-                        ));
-                    }
-
-                    let result = response.result.ok_or_else(|| {
-                        "MCP server returned no result for tools/call".to_string()
-                    })?;
-
-                    serde_json::to_value(result)
-                        .map_err(|error| format!("failed to serialize MCP tool result: {error}"))
-                })
-            })
-            .map_err(|error| format!("failed to spawn MCP tool call thread: {error}"))?;
-
-        join_handle.join().map_err(|panic_payload| {
-            if let Some(message) = panic_payload.downcast_ref::<&str>() {
-                format!("MCP tool call thread panicked: {message}")
-            } else if let Some(message) = panic_payload.downcast_ref::<String>() {
-                format!("MCP tool call thread panicked: {message}")
-            } else {
-                "MCP tool call thread panicked".to_string()
-            }
-        })?
-    }
-
-    pub fn call_tool(
-        &self,
-        server_name: &str,
-        tool_name: &str,
-        arguments: &serde_json::Value,
-    ) -> Result<serde_json::Value, String> {
-        let inner = self.inner.lock().expect("mcp registry lock poisoned");
-        let state = inner
-            .get(server_name)
-            .ok_or_else(|| format!("server '{}' not found", server_name))?;
-
-        if state.status != McpConnectionStatus::Connected {
-            return Err(format!(
-                "server '{}' is not connected (status: {})",
-                server_name, state.status
-            ));
-        }
-
-        if !state.tools.iter().any(|t| t.name == tool_name) {
-            return Err(format!(
-                "tool '{}' not found on server '{}'",
-                tool_name, server_name
-            ));
-        }
-
-        drop(inner);
-
-        let manager = self
-            .manager
-            .get()
-            .cloned()
-            .ok_or_else(|| "MCP server manager is not configured".to_string())?;
-
-        Self::spawn_tool_call(
-            manager,
-            mcp_tool_name(server_name, tool_name),
-            (!arguments.is_null()).then(|| arguments.clone()),
-        )
-    }
-
-    /// Set auth status for a server.
-    pub fn set_auth_status(
-        &self,
-        server_name: &str,
-        status: McpConnectionStatus,
-    ) -> Result<(), String> {
-        let mut inner = self.inner.lock().expect("mcp registry lock poisoned");
-        let state = inner
-            .get_mut(server_name)
-            .ok_or_else(|| format!("server '{}' not found", server_name))?;
-        state.status = status;
-        Ok(())
-    }
-
-    /// Disconnect / remove a server.
-    pub fn disconnect(&self, server_name: &str) -> Option<McpServerState> {
-        let mut inner = self.inner.lock().expect("mcp registry lock poisoned");
-        inner.remove(server_name)
-    }
-
-    /// Number of registered servers.
-    #[must_use]
-    pub fn len(&self) -> usize {
-        let inner = self.inner.lock().expect("mcp registry lock poisoned");
-        inner.len()
-    }
-
-    #[must_use]
-    pub fn is_empty(&self) -> bool {
-        self.len() == 0
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::collections::BTreeMap;
-    use std::fs;
-    use std::os::unix::fs::PermissionsExt;
-    use std::path::{Path, PathBuf};
-    use std::sync::atomic::{AtomicU64, Ordering};
-    use std::time::{SystemTime, UNIX_EPOCH};
-
-    use super::*;
-    use crate::config::{
-        ConfigSource, McpServerConfig, McpStdioServerConfig, ScopedMcpServerConfig,
-    };
-
-    fn temp_dir() -> PathBuf {
-        static NEXT_TEMP_DIR_ID: AtomicU64 = AtomicU64::new(0);
-        let nanos = SystemTime::now()
-            .duration_since(UNIX_EPOCH)
-            .expect("time should be after epoch")
-            .as_nanos();
-        let unique_id = NEXT_TEMP_DIR_ID.fetch_add(1, Ordering::Relaxed);
-        std::env::temp_dir().join(format!("runtime-mcp-tool-bridge-{nanos}-{unique_id}"))
-    }
-
-    fn cleanup_script(script_path: &Path) {
-        if let Some(root) = script_path.parent() {
-            let _ = fs::remove_dir_all(root);
-        }
-    }
-
-    fn write_bridge_mcp_server_script() -> PathBuf {
-        let root = temp_dir();
-        fs::create_dir_all(&root).expect("temp dir");
-        let script_path = root.join("bridge-mcp-server.py");
-        let script = [
-            "#!/usr/bin/env python3",
-            "import json, os, sys",
-            "LABEL = os.environ.get('MCP_SERVER_LABEL', 'server')",
-            "LOG_PATH = os.environ.get('MCP_LOG_PATH')",
-            "",
-            "def log(method):",
-            "    if LOG_PATH:",
-            "        with open(LOG_PATH, 'a', encoding='utf-8') as handle:",
-            "            handle.write(f'{method}\\n')",
-            "",
-            "def read_message():",
-            "    header = b''",
-            r"    while not header.endswith(b'\r\n\r\n'):",
-            "        chunk = sys.stdin.buffer.read(1)",
-            "        if not chunk:",
-            "            return None",
-            "        header += chunk",
-            "    length = 0",
-            r"    for line in header.decode().split('\r\n'):",
-            r"        if line.lower().startswith('content-length:'):",
-            r"            length = int(line.split(':', 1)[1].strip())",
-            "    payload = sys.stdin.buffer.read(length)",
-            "    return json.loads(payload.decode())",
-            "",
-            "def send_message(message):",
-            "    payload = json.dumps(message).encode()",
-            r"    sys.stdout.buffer.write(f'Content-Length: {len(payload)}\r\n\r\n'.encode() + payload)",
-            "    sys.stdout.buffer.flush()",
-            "",
-            "while True:",
-            "    request = read_message()",
-            "    if request is None:",
-            "        break",
-            "    method = request['method']",
-            "    log(method)",
-            "    if method == 'initialize':",
-            "        send_message({",
-            "            'jsonrpc': '2.0',",
-            "            'id': request['id'],",
-            "            'result': {",
-            "                'protocolVersion': request['params']['protocolVersion'],",
-            "                'capabilities': {'tools': {}},",
-            "                'serverInfo': {'name': LABEL, 'version': '1.0.0'}",
-            "            }",
-            "        })",
-            "    elif method == 'tools/list':",
-            "        send_message({",
-            "            'jsonrpc': '2.0',",
-            "            'id': request['id'],",
-            "            'result': {",
-            "                'tools': [",
-            "                    {",
-            "                        'name': 'echo',",
-            "                        'description': f'Echo tool for {LABEL}',",
-            "                        'inputSchema': {",
-            "                            'type': 'object',",
-            "                            'properties': {'text': {'type': 'string'}},",
-            "                            'required': ['text']",
-            "                        }",
-            "                    }",
-            "                ]",
-            "            }",
-            "        })",
-            "    elif method == 'tools/call':",
-            "        args = request['params'].get('arguments') or {}",
-            "        text = args.get('text', '')",
-            "        send_message({",
-            "            'jsonrpc': '2.0',",
-            "            'id': request['id'],",
-            "            'result': {",
-            "                'content': [{'type': 'text', 'text': f'{LABEL}:{text}'}],",
-            "                'structuredContent': {'server': LABEL, 'echoed': text},",
-            "                'isError': False",
-            "            }",
-            "        })",
-            "    else:",
-            "        send_message({",
-            "            'jsonrpc': '2.0',",
-            "            'id': request['id'],",
-            "            'error': {'code': -32601, 'message': f'unknown method: {method}'},",
-            "        })",
-            "",
-        ]
-        .join("\n");
-        fs::write(&script_path, script).expect("write script");
-        let mut permissions = fs::metadata(&script_path).expect("metadata").permissions();
-        permissions.set_mode(0o755);
-        fs::set_permissions(&script_path, permissions).expect("chmod");
-        script_path
-    }
-
-    fn manager_server_config(
-        script_path: &Path,
-        server_name: &str,
-        log_path: &Path,
-    ) -> ScopedMcpServerConfig {
-        ScopedMcpServerConfig {
-            scope: ConfigSource::Local,
-            config: McpServerConfig::Stdio(McpStdioServerConfig {
-                command: "python3".to_string(),
-                args: vec![script_path.to_string_lossy().into_owned()],
-                env: BTreeMap::from([
-                    ("MCP_SERVER_LABEL".to_string(), server_name.to_string()),
-                    (
-                        "MCP_LOG_PATH".to_string(),
-                        log_path.to_string_lossy().into_owned(),
-                    ),
-                ]),
-                tool_call_timeout_ms: Some(1_000),
-            }),
-        }
-    }
-
-    #[test]
-    fn registers_and_retrieves_server() {
-        let registry = McpToolRegistry::new();
-        registry.register_server(
-            "test-server",
-            McpConnectionStatus::Connected,
-            vec![McpToolInfo {
-                name: "greet".into(),
-                description: Some("Greet someone".into()),
-                input_schema: None,
-            }],
-            vec![McpResourceInfo {
-                uri: "res://data".into(),
-                name: "Data".into(),
-                description: None,
-                mime_type: Some("application/json".into()),
-            }],
-            Some("TestServer v1.0".into()),
-        );
-
-        let server = registry.get_server("test-server").expect("should exist");
-        assert_eq!(server.status, McpConnectionStatus::Connected);
-        assert_eq!(server.tools.len(), 1);
-        assert_eq!(server.resources.len(), 1);
-    }
-
-    #[test]
-    fn lists_resources_from_connected_server() {
-        let registry = McpToolRegistry::new();
-        registry.register_server(
-            "srv",
-            McpConnectionStatus::Connected,
-            vec![],
-            vec![McpResourceInfo {
-                uri: "res://alpha".into(),
-                name: "Alpha".into(),
-                description: None,
-                mime_type: None,
-            }],
-            None,
-        );
-
-        let resources = registry.list_resources("srv").expect("should succeed");
-        assert_eq!(resources.len(), 1);
-        assert_eq!(resources[0].uri, "res://alpha");
-    }
-
-    #[test]
-    fn rejects_resource_listing_for_disconnected_server() {
-        let registry = McpToolRegistry::new();
-        registry.register_server(
-            "srv",
-            McpConnectionStatus::Disconnected,
-            vec![],
-            vec![],
-            None,
-        );
-        assert!(registry.list_resources("srv").is_err());
-    }
-
-    #[test]
-    fn reads_specific_resource() {
-        let registry = McpToolRegistry::new();
-        registry.register_server(
-            "srv",
-            McpConnectionStatus::Connected,
-            vec![],
-            vec![McpResourceInfo {
-                uri: "res://data".into(),
-                name: "Data".into(),
-                description: Some("Test data".into()),
-                mime_type: Some("text/plain".into()),
-            }],
-            None,
-        );
-
-        let resource = registry
-            .read_resource("srv", "res://data")
-            .expect("should find");
-        assert_eq!(resource.name, "Data");
-
-        assert!(registry.read_resource("srv", "res://missing").is_err());
-    }
-
-    #[test]
-    fn given_connected_server_without_manager_when_calling_tool_then_it_errors() {
-        let registry = McpToolRegistry::new();
-        registry.register_server(
-            "srv",
-            McpConnectionStatus::Connected,
-            vec![McpToolInfo {
-                name: "greet".into(),
-                description: None,
-                input_schema: None,
-            }],
-            vec![],
-            None,
-        );
-
-        let error = registry
-            .call_tool("srv", "greet", &serde_json::json!({"name": "world"}))
-            .expect_err("should require a configured manager");
-        assert!(error.contains("MCP server manager is not configured"));
-
-        // Unknown tool should fail
-        assert!(registry
-            .call_tool("srv", "missing", &serde_json::json!({}))
-            .is_err());
-    }
-
-    #[test]
-    fn given_connected_server_with_manager_when_calling_tool_then_it_returns_live_result() {
-        let script_path = write_bridge_mcp_server_script();
-        let root = script_path.parent().expect("script parent");
-        let log_path = root.join("bridge.log");
-        let servers = BTreeMap::from([(
-            "alpha".to_string(),
-            manager_server_config(&script_path, "alpha", &log_path),
-        )]);
-        let manager = Arc::new(Mutex::new(McpServerManager::from_servers(&servers)));
-
-        let registry = McpToolRegistry::new();
-        registry.register_server(
-            "alpha",
-            McpConnectionStatus::Connected,
-            vec![McpToolInfo {
-                name: "echo".into(),
-                description: Some("Echo tool for alpha".into()),
-                input_schema: Some(serde_json::json!({
-                    "type": "object",
-                    "properties": {"text": {"type": "string"}},
-                    "required": ["text"]
-                })),
-            }],
-            vec![],
-            Some("bridge test server".into()),
-        );
-        registry
-            .set_manager(Arc::clone(&manager))
-            .expect("manager should only be set once");
-
-        let result = registry
-            .call_tool("alpha", "echo", &serde_json::json!({"text": "hello"}))
-            .expect("should return live MCP result");
-
-        assert_eq!(
-            result["structuredContent"]["server"],
-            serde_json::json!("alpha")
-        );
-        assert_eq!(
-            result["structuredContent"]["echoed"],
-            serde_json::json!("hello")
-        );
-        assert_eq!(
-            result["content"][0]["text"],
-            serde_json::json!("alpha:hello")
-        );
-
-        let log = fs::read_to_string(&log_path).expect("read log");
-        assert_eq!(
-            log.lines().collect::<Vec<_>>(),
-            vec!["initialize", "tools/list", "tools/call"]
-        );
-
-        cleanup_script(&script_path);
-    }
-
-    #[test]
-    fn rejects_tool_call_on_disconnected_server() {
-        let registry = McpToolRegistry::new();
-        registry.register_server(
-            "srv",
-            McpConnectionStatus::AuthRequired,
-            vec![McpToolInfo {
-                name: "greet".into(),
-                description: None,
-                input_schema: None,
-            }],
-            vec![],
-            None,
-        );
-
-        assert!(registry
-            .call_tool("srv", "greet", &serde_json::json!({}))
-            .is_err());
-    }
-
-    #[test]
-    fn sets_auth_and_disconnects() {
-        let registry = McpToolRegistry::new();
-        registry.register_server(
-            "srv",
-            McpConnectionStatus::AuthRequired,
-            vec![],
-            vec![],
-            None,
-        );
-
-        registry
-            .set_auth_status("srv", McpConnectionStatus::Connected)
-            .expect("should succeed");
-        let state = registry.get_server("srv").unwrap();
-        assert_eq!(state.status, McpConnectionStatus::Connected);
-
-        let removed = registry.disconnect("srv");
-        assert!(removed.is_some());
-        assert!(registry.is_empty());
-    }
-
-    #[test]
-    fn rejects_operations_on_missing_server() {
-        let registry = McpToolRegistry::new();
-        assert!(registry.list_resources("missing").is_err());
-        assert!(registry.read_resource("missing", "uri").is_err());
-        assert!(registry.list_tools("missing").is_err());
-        assert!(registry
-            .call_tool("missing", "tool", &serde_json::json!({}))
-            .is_err());
-        assert!(registry
-            .set_auth_status("missing", McpConnectionStatus::Connected)
-            .is_err());
-    }
-
-    #[test]
-    fn mcp_connection_status_display_all_variants() {
-        // given
-        let cases = [
-            (McpConnectionStatus::Disconnected, "disconnected"),
-            (McpConnectionStatus::Connecting, "connecting"),
-            (McpConnectionStatus::Connected, "connected"),
-            (McpConnectionStatus::AuthRequired, "auth_required"),
-            (McpConnectionStatus::Error, "error"),
-        ];
-
-        // when
-        let rendered: Vec<_> = cases
-            .into_iter()
-            .map(|(status, expected)| (status.to_string(), expected))
-            .collect();
-
-        // then
-        assert_eq!(
-            rendered,
-            vec![
-                ("disconnected".to_string(), "disconnected"),
-                ("connecting".to_string(), "connecting"),
-                ("connected".to_string(), "connected"),
-                ("auth_required".to_string(), "auth_required"),
-                ("error".to_string(), "error"),
-            ]
-        );
-    }
-
-    #[test]
-    fn list_servers_returns_all_registered() {
-        // given
-        let registry = McpToolRegistry::new();
-        registry.register_server(
-            "alpha",
-            McpConnectionStatus::Connected,
-            vec![],
-            vec![],
-            None,
-        );
-        registry.register_server(
-            "beta",
-            McpConnectionStatus::Connecting,
-            vec![],
-            vec![],
-            None,
-        );
-
-        // when
-        let servers = registry.list_servers();
-
-        // then
-        assert_eq!(servers.len(), 2);
-        assert!(servers.iter().any(|server| server.server_name == "alpha"));
-        assert!(servers.iter().any(|server| server.server_name == "beta"));
-    }
-
-    #[test]
-    fn list_tools_from_connected_server() {
-        // given
-        let registry = McpToolRegistry::new();
-        registry.register_server(
-            "srv",
-            McpConnectionStatus::Connected,
-            vec![McpToolInfo {
-                name: "inspect".into(),
-                description: Some("Inspect data".into()),
-                input_schema: Some(serde_json::json!({"type": "object"})),
-            }],
-            vec![],
-            None,
-        );
-
-        // when
-        let tools = registry.list_tools("srv").expect("tools should list");
-
-        // then
-        assert_eq!(tools.len(), 1);
-        assert_eq!(tools[0].name, "inspect");
-    }
-
-    #[test]
-    fn list_tools_rejects_disconnected_server() {
-        // given
-        let registry = McpToolRegistry::new();
-        registry.register_server(
-            "srv",
-            McpConnectionStatus::AuthRequired,
-            vec![],
-            vec![],
-            None,
-        );
-
-        // when
-        let result = registry.list_tools("srv");
-
-        // then
-        let error = result.expect_err("non-connected server should fail");
-        assert!(error.contains("not connected"));
-        assert!(error.contains("auth_required"));
-    }
-
-    #[test]
-    fn list_tools_rejects_missing_server() {
-        // given
-        let registry = McpToolRegistry::new();
-
-        // when
-        let result = registry.list_tools("missing");
-
-        // then
-        assert_eq!(
-            result.expect_err("missing server should fail"),
-            "server 'missing' not found"
-        );
-    }
-
-    #[test]
-    fn get_server_returns_none_for_missing() {
-        // given
-        let registry = McpToolRegistry::new();
-
-        // when
-        let server = registry.get_server("missing");
-
-        // then
-        assert!(server.is_none());
-    }
-
-    #[test]
-    fn call_tool_payload_structure() {
-        let script_path = write_bridge_mcp_server_script();
-        let root = script_path.parent().expect("script parent");
-        let log_path = root.join("payload.log");
-        let servers = BTreeMap::from([(
-            "srv".to_string(),
-            manager_server_config(&script_path, "srv", &log_path),
-        )]);
-        let registry = McpToolRegistry::new();
-        let arguments = serde_json::json!({"text": "world"});
-        registry.register_server(
-            "srv",
-            McpConnectionStatus::Connected,
-            vec![McpToolInfo {
-                name: "echo".into(),
-                description: Some("Echo tool for srv".into()),
-                input_schema: Some(serde_json::json!({
-                    "type": "object",
-                    "properties": {"text": {"type": "string"}},
-                    "required": ["text"]
-                })),
-            }],
-            vec![],
-            None,
-        );
-        registry
-            .set_manager(Arc::new(Mutex::new(McpServerManager::from_servers(
-                &servers,
-            ))))
-            .expect("manager should only be set once");
-
-        let result = registry
-            .call_tool("srv", "echo", &arguments)
-            .expect("tool should return live payload");
-
-        assert_eq!(result["structuredContent"]["server"], "srv");
-        assert_eq!(result["structuredContent"]["echoed"], "world");
-        assert_eq!(result["content"][0]["text"], "srv:world");
-
-        cleanup_script(&script_path);
-    }
-
-    #[test]
-    fn upsert_overwrites_existing_server() {
-        // given
-        let registry = McpToolRegistry::new();
-        registry.register_server("srv", McpConnectionStatus::Connecting, vec![], vec![], None);
-
-        // when
-        registry.register_server(
-            "srv",
-            McpConnectionStatus::Connected,
-            vec![McpToolInfo {
-                name: "inspect".into(),
-                description: None,
-                input_schema: None,
-            }],
-            vec![],
-            Some("Inspector".into()),
-        );
-        let state = registry.get_server("srv").expect("server should exist");
-
-        // then
-        assert_eq!(state.status, McpConnectionStatus::Connected);
-        assert_eq!(state.tools.len(), 1);
-        assert_eq!(state.server_info.as_deref(), Some("Inspector"));
-    }
-
-    #[test]
-    fn disconnect_missing_returns_none() {
-        // given
-        let registry = McpToolRegistry::new();
-
-        // when
-        let removed = registry.disconnect("missing");
-
-        // then
-        assert!(removed.is_none());
-    }
-
-    #[test]
-    fn len_and_is_empty_transitions() {
-        // given
-        let registry = McpToolRegistry::new();
-
-        // when
-        registry.register_server(
-            "alpha",
-            McpConnectionStatus::Connected,
-            vec![],
-            vec![],
-            None,
-        );
-        registry.register_server("beta", McpConnectionStatus::Connected, vec![], vec![], None);
-        let after_create = registry.len();
-        registry.disconnect("alpha");
-        let after_first_remove = registry.len();
-        registry.disconnect("beta");
-
-        // then
-        assert_eq!(after_create, 2);
-        assert_eq!(after_first_remove, 1);
-        assert_eq!(registry.len(), 0);
-        assert!(registry.is_empty());
-    }
-}

rust/crates/runtime/src/oauth.rs

@@ -442,7 +442,7 @@ fn decode_hex(byte: u8) -> Result<u8, String> {
         b'0'..=b'9' => Ok(byte - b'0'),
         b'a'..=b'f' => Ok(byte - b'a' + 10),
         b'A'..=b'F' => Ok(byte - b'A' + 10),
-        _ => Err(format!("invalid percent byte: {byte}")),
+        _ => Err(format!("invalid percent-encoding byte: {byte}")),
     }
 }
 

rust/crates/runtime/src/permission_enforcer.rs

@@ -1,546 +0,0 @@
-//! Permission enforcement layer that gates tool execution based on the
-//! active `PermissionPolicy`.
-
-use crate::permissions::{PermissionMode, PermissionOutcome, PermissionPolicy};
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(tag = "outcome")]
-pub enum EnforcementResult {
-    /// Tool execution is allowed.
-    Allowed,
-    /// Tool execution was denied due to insufficient permissions.
-    Denied {
-        tool: String,
-        active_mode: String,
-        required_mode: String,
-        reason: String,
-    },
-}
-
-#[derive(Debug, Clone, PartialEq)]
-pub struct PermissionEnforcer {
-    policy: PermissionPolicy,
-}
-
-impl PermissionEnforcer {
-    #[must_use]
-    pub fn new(policy: PermissionPolicy) -> Self {
-        Self { policy }
-    }
-
-    /// Check whether a tool can be executed under the current permission policy.
-    /// Auto-denies when prompting is required but no prompter is provided.
-    pub fn check(&self, tool_name: &str, input: &str) -> EnforcementResult {
-        // When the active mode is Prompt, defer to the caller's interactive
-        // prompt flow rather than hard-denying (the enforcer has no prompter).
-        if self.policy.active_mode() == PermissionMode::Prompt {
-            return EnforcementResult::Allowed;
-        }
-
-        let outcome = self.policy.authorize(tool_name, input, None);
-
-        match outcome {
-            PermissionOutcome::Allow => EnforcementResult::Allowed,
-            PermissionOutcome::Deny { reason } => {
-                let active_mode = self.policy.active_mode();
-                let required_mode = self.policy.required_mode_for(tool_name);
-                EnforcementResult::Denied {
-                    tool: tool_name.to_owned(),
-                    active_mode: active_mode.as_str().to_owned(),
-                    required_mode: required_mode.as_str().to_owned(),
-                    reason,
-                }
-            }
-        }
-    }
-
-    #[must_use]
-    pub fn is_allowed(&self, tool_name: &str, input: &str) -> bool {
-        matches!(self.check(tool_name, input), EnforcementResult::Allowed)
-    }
-
-    #[must_use]
-    pub fn active_mode(&self) -> PermissionMode {
-        self.policy.active_mode()
-    }
-
-    /// Classify a file operation against workspace boundaries.
-    pub fn check_file_write(&self, path: &str, workspace_root: &str) -> EnforcementResult {
-        let mode = self.policy.active_mode();
-
-        match mode {
-            PermissionMode::ReadOnly => EnforcementResult::Denied {
-                tool: "write_file".to_owned(),
-                active_mode: mode.as_str().to_owned(),
-                required_mode: PermissionMode::WorkspaceWrite.as_str().to_owned(),
-                reason: format!("file writes are not allowed in '{}' mode", mode.as_str()),
-            },
-            PermissionMode::WorkspaceWrite => {
-                if is_within_workspace(path, workspace_root) {
-                    EnforcementResult::Allowed
-                } else {
-                    EnforcementResult::Denied {
-                        tool: "write_file".to_owned(),
-                        active_mode: mode.as_str().to_owned(),
-                        required_mode: PermissionMode::DangerFullAccess.as_str().to_owned(),
-                        reason: format!(
-                            "path '{}' is outside workspace root '{}'",
-                            path, workspace_root
-                        ),
-                    }
-                }
-            }
-            // Allow and DangerFullAccess permit all writes
-            PermissionMode::Allow | PermissionMode::DangerFullAccess => EnforcementResult::Allowed,
-            PermissionMode::Prompt => EnforcementResult::Denied {
-                tool: "write_file".to_owned(),
-                active_mode: mode.as_str().to_owned(),
-                required_mode: PermissionMode::WorkspaceWrite.as_str().to_owned(),
-                reason: "file write requires confirmation in prompt mode".to_owned(),
-            },
-        }
-    }
-
-    /// Check if a bash command should be allowed based on current mode.
-    pub fn check_bash(&self, command: &str) -> EnforcementResult {
-        let mode = self.policy.active_mode();
-
-        match mode {
-            PermissionMode::ReadOnly => {
-                if is_read_only_command(command) {
-                    EnforcementResult::Allowed
-                } else {
-                    EnforcementResult::Denied {
-                        tool: "bash".to_owned(),
-                        active_mode: mode.as_str().to_owned(),
-                        required_mode: PermissionMode::WorkspaceWrite.as_str().to_owned(),
-                        reason: format!(
-                            "command may modify state; not allowed in '{}' mode",
-                            mode.as_str()
-                        ),
-                    }
-                }
-            }
-            PermissionMode::Prompt => EnforcementResult::Denied {
-                tool: "bash".to_owned(),
-                active_mode: mode.as_str().to_owned(),
-                required_mode: PermissionMode::DangerFullAccess.as_str().to_owned(),
-                reason: "bash requires confirmation in prompt mode".to_owned(),
-            },
-            // WorkspaceWrite, Allow, DangerFullAccess: permit bash
-            _ => EnforcementResult::Allowed,
-        }
-    }
-}
-
-/// Simple workspace boundary check via string prefix.
-fn is_within_workspace(path: &str, workspace_root: &str) -> bool {
-    let normalized = if path.starts_with('/') {
-        path.to_owned()
-    } else {
-        format!("{workspace_root}/{path}")
-    };
-
-    let root = if workspace_root.ends_with('/') {
-        workspace_root.to_owned()
-    } else {
-        format!("{workspace_root}/")
-    };
-
-    normalized.starts_with(&root) || normalized == workspace_root.trim_end_matches('/')
-}
-
-/// Conservative heuristic: is this bash command read-only?
-fn is_read_only_command(command: &str) -> bool {
-    let first_token = command
-        .split_whitespace()
-        .next()
-        .unwrap_or("")
-        .rsplit('/')
-        .next()
-        .unwrap_or("");
-
-    matches!(
-        first_token,
-        "cat"
-            | "head"
-            | "tail"
-            | "less"
-            | "more"
-            | "wc"
-            | "ls"
-            | "find"
-            | "grep"
-            | "rg"
-            | "awk"
-            | "sed"
-            | "echo"
-            | "printf"
-            | "which"
-            | "where"
-            | "whoami"
-            | "pwd"
-            | "env"
-            | "printenv"
-            | "date"
-            | "cal"
-            | "df"
-            | "du"
-            | "free"
-            | "uptime"
-            | "uname"
-            | "file"
-            | "stat"
-            | "diff"
-            | "sort"
-            | "uniq"
-            | "tr"
-            | "cut"
-            | "paste"
-            | "tee"
-            | "xargs"
-            | "test"
-            | "true"
-            | "false"
-            | "type"
-            | "readlink"
-            | "realpath"
-            | "basename"
-            | "dirname"
-            | "sha256sum"
-            | "md5sum"
-            | "b3sum"
-            | "xxd"
-            | "hexdump"
-            | "od"
-            | "strings"
-            | "tree"
-            | "jq"
-            | "yq"
-            | "python3"
-            | "python"
-            | "node"
-            | "ruby"
-            | "cargo"
-            | "rustc"
-            | "git"
-            | "gh"
-    ) && !command.contains("-i ")
-        && !command.contains("--in-place")
-        && !command.contains(" > ")
-        && !command.contains(" >> ")
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn make_enforcer(mode: PermissionMode) -> PermissionEnforcer {
-        let policy = PermissionPolicy::new(mode);
-        PermissionEnforcer::new(policy)
-    }
-
-    #[test]
-    fn allow_mode_permits_everything() {
-        let enforcer = make_enforcer(PermissionMode::Allow);
-        assert!(enforcer.is_allowed("bash", ""));
-        assert!(enforcer.is_allowed("write_file", ""));
-        assert!(enforcer.is_allowed("edit_file", ""));
-        assert_eq!(
-            enforcer.check_file_write("/outside/path", "/workspace"),
-            EnforcementResult::Allowed
-        );
-        assert_eq!(enforcer.check_bash("rm -rf /"), EnforcementResult::Allowed);
-    }
-
-    #[test]
-    fn read_only_denies_writes() {
-        let policy = PermissionPolicy::new(PermissionMode::ReadOnly)
-            .with_tool_requirement("read_file", PermissionMode::ReadOnly)
-            .with_tool_requirement("grep_search", PermissionMode::ReadOnly)
-            .with_tool_requirement("write_file", PermissionMode::WorkspaceWrite);
-
-        let enforcer = PermissionEnforcer::new(policy);
-        assert!(enforcer.is_allowed("read_file", ""));
-        assert!(enforcer.is_allowed("grep_search", ""));
-
-        // write_file requires WorkspaceWrite but we're in ReadOnly
-        let result = enforcer.check("write_file", "");
-        assert!(matches!(result, EnforcementResult::Denied { .. }));
-
-        let result = enforcer.check_file_write("/workspace/file.rs", "/workspace");
-        assert!(matches!(result, EnforcementResult::Denied { .. }));
-    }
-
-    #[test]
-    fn read_only_allows_read_commands() {
-        let enforcer = make_enforcer(PermissionMode::ReadOnly);
-        assert_eq!(
-            enforcer.check_bash("cat src/main.rs"),
-            EnforcementResult::Allowed
-        );
-        assert_eq!(
-            enforcer.check_bash("grep -r 'pattern' ."),
-            EnforcementResult::Allowed
-        );
-        assert_eq!(enforcer.check_bash("ls -la"), EnforcementResult::Allowed);
-    }
-
-    #[test]
-    fn read_only_denies_write_commands() {
-        let enforcer = make_enforcer(PermissionMode::ReadOnly);
-        let result = enforcer.check_bash("rm file.txt");
-        assert!(matches!(result, EnforcementResult::Denied { .. }));
-    }
-
-    #[test]
-    fn workspace_write_allows_within_workspace() {
-        let enforcer = make_enforcer(PermissionMode::WorkspaceWrite);
-        let result = enforcer.check_file_write("/workspace/src/main.rs", "/workspace");
-        assert_eq!(result, EnforcementResult::Allowed);
-    }
-
-    #[test]
-    fn workspace_write_denies_outside_workspace() {
-        let enforcer = make_enforcer(PermissionMode::WorkspaceWrite);
-        let result = enforcer.check_file_write("/etc/passwd", "/workspace");
-        assert!(matches!(result, EnforcementResult::Denied { .. }));
-    }
-
-    #[test]
-    fn prompt_mode_denies_without_prompter() {
-        let enforcer = make_enforcer(PermissionMode::Prompt);
-        let result = enforcer.check_bash("echo test");
-        assert!(matches!(result, EnforcementResult::Denied { .. }));
-
-        let result = enforcer.check_file_write("/workspace/file.rs", "/workspace");
-        assert!(matches!(result, EnforcementResult::Denied { .. }));
-    }
-
-    #[test]
-    fn workspace_boundary_check() {
-        assert!(is_within_workspace("/workspace/src/main.rs", "/workspace"));
-        assert!(is_within_workspace("/workspace", "/workspace"));
-        assert!(!is_within_workspace("/etc/passwd", "/workspace"));
-        assert!(!is_within_workspace("/workspacex/hack", "/workspace"));
-    }
-
-    #[test]
-    fn read_only_command_heuristic() {
-        assert!(is_read_only_command("cat file.txt"));
-        assert!(is_read_only_command("grep pattern file"));
-        assert!(is_read_only_command("git log --oneline"));
-        assert!(!is_read_only_command("rm file.txt"));
-        assert!(!is_read_only_command("echo test > file.txt"));
-        assert!(!is_read_only_command("sed -i 's/a/b/' file"));
-    }
-
-    #[test]
-    fn active_mode_returns_policy_mode() {
-        // given
-        let modes = [
-            PermissionMode::ReadOnly,
-            PermissionMode::WorkspaceWrite,
-            PermissionMode::DangerFullAccess,
-            PermissionMode::Prompt,
-            PermissionMode::Allow,
-        ];
-
-        // when
-        let active_modes: Vec<_> = modes
-            .into_iter()
-            .map(|mode| make_enforcer(mode).active_mode())
-            .collect();
-
-        // then
-        assert_eq!(active_modes, modes);
-    }
-
-    #[test]
-    fn danger_full_access_permits_file_writes_and_bash() {
-        // given
-        let enforcer = make_enforcer(PermissionMode::DangerFullAccess);
-
-        // when
-        let file_result = enforcer.check_file_write("/outside/workspace/file.txt", "/workspace");
-        let bash_result = enforcer.check_bash("rm -rf /tmp/scratch");
-
-        // then
-        assert_eq!(file_result, EnforcementResult::Allowed);
-        assert_eq!(bash_result, EnforcementResult::Allowed);
-    }
-
-    #[test]
-    fn check_denied_payload_contains_tool_and_modes() {
-        // given
-        let policy = PermissionPolicy::new(PermissionMode::ReadOnly)
-            .with_tool_requirement("write_file", PermissionMode::WorkspaceWrite);
-        let enforcer = PermissionEnforcer::new(policy);
-
-        // when
-        let result = enforcer.check("write_file", "{}");
-
-        // then
-        match result {
-            EnforcementResult::Denied {
-                tool,
-                active_mode,
-                required_mode,
-                reason,
-            } => {
-                assert_eq!(tool, "write_file");
-                assert_eq!(active_mode, "read-only");
-                assert_eq!(required_mode, "workspace-write");
-                assert!(reason.contains("requires workspace-write permission"));
-            }
-            other => panic!("expected denied result, got {other:?}"),
-        }
-    }
-
-    #[test]
-    fn workspace_write_relative_path_resolved() {
-        // given
-        let enforcer = make_enforcer(PermissionMode::WorkspaceWrite);
-
-        // when
-        let result = enforcer.check_file_write("src/main.rs", "/workspace");
-
-        // then
-        assert_eq!(result, EnforcementResult::Allowed);
-    }
-
-    #[test]
-    fn workspace_root_with_trailing_slash() {
-        // given
-        let enforcer = make_enforcer(PermissionMode::WorkspaceWrite);
-
-        // when
-        let result = enforcer.check_file_write("/workspace/src/main.rs", "/workspace/");
-
-        // then
-        assert_eq!(result, EnforcementResult::Allowed);
-    }
-
-    #[test]
-    fn workspace_root_equality() {
-        // given
-        let root = "/workspace/";
-
-        // when
-        let equal_to_root = is_within_workspace("/workspace", root);
-
-        // then
-        assert!(equal_to_root);
-    }
-
-    #[test]
-    fn bash_heuristic_full_path_prefix() {
-        // given
-        let full_path_command = "/usr/bin/cat Cargo.toml";
-        let git_path_command = "/usr/local/bin/git status";
-
-        // when
-        let cat_result = is_read_only_command(full_path_command);
-        let git_result = is_read_only_command(git_path_command);
-
-        // then
-        assert!(cat_result);
-        assert!(git_result);
-    }
-
-    #[test]
-    fn bash_heuristic_redirects_block_read_only_commands() {
-        // given
-        let overwrite = "cat Cargo.toml > out.txt";
-        let append = "echo test >> out.txt";
-
-        // when
-        let overwrite_result = is_read_only_command(overwrite);
-        let append_result = is_read_only_command(append);
-
-        // then
-        assert!(!overwrite_result);
-        assert!(!append_result);
-    }
-
-    #[test]
-    fn bash_heuristic_in_place_flag_blocks() {
-        // given
-        let interactive_python = "python -i script.py";
-        let in_place_sed = "sed --in-place 's/a/b/' file.txt";
-
-        // when
-        let interactive_result = is_read_only_command(interactive_python);
-        let in_place_result = is_read_only_command(in_place_sed);
-
-        // then
-        assert!(!interactive_result);
-        assert!(!in_place_result);
-    }
-
-    #[test]
-    fn bash_heuristic_empty_command() {
-        // given
-        let empty = "";
-        let whitespace = "   ";
-
-        // when
-        let empty_result = is_read_only_command(empty);
-        let whitespace_result = is_read_only_command(whitespace);
-
-        // then
-        assert!(!empty_result);
-        assert!(!whitespace_result);
-    }
-
-    #[test]
-    fn prompt_mode_check_bash_denied_payload_fields() {
-        // given
-        let enforcer = make_enforcer(PermissionMode::Prompt);
-
-        // when
-        let result = enforcer.check_bash("git status");
-
-        // then
-        match result {
-            EnforcementResult::Denied {
-                tool,
-                active_mode,
-                required_mode,
-                reason,
-            } => {
-                assert_eq!(tool, "bash");
-                assert_eq!(active_mode, "prompt");
-                assert_eq!(required_mode, "danger-full-access");
-                assert_eq!(reason, "bash requires confirmation in prompt mode");
-            }
-            other => panic!("expected denied result, got {other:?}"),
-        }
-    }
-
-    #[test]
-    fn read_only_check_file_write_denied_payload() {
-        // given
-        let enforcer = make_enforcer(PermissionMode::ReadOnly);
-
-        // when
-        let result = enforcer.check_file_write("/workspace/file.txt", "/workspace");
-
-        // then
-        match result {
-            EnforcementResult::Denied {
-                tool,
-                active_mode,
-                required_mode,
-                reason,
-            } => {
-                assert_eq!(tool, "write_file");
-                assert_eq!(active_mode, "read-only");
-                assert_eq!(required_mode, "workspace-write");
-                assert!(reason.contains("file writes are not allowed"));
-            }
-            other => panic!("expected denied result, got {other:?}"),
-        }
-    }
-}

rust/crates/runtime/src/plugin_lifecycle.rs

@@ -1,532 +0,0 @@
-use std::time::{SystemTime, UNIX_EPOCH};
-
-use serde::{Deserialize, Serialize};
-
-use crate::config::RuntimePluginConfig;
-use crate::mcp_tool_bridge::{McpResourceInfo, McpToolInfo};
-
-fn now_secs() -> u64 {
-    SystemTime::now()
-        .duration_since(UNIX_EPOCH)
-        .unwrap_or_default()
-        .as_secs()
-}
-
-pub type ToolInfo = McpToolInfo;
-pub type ResourceInfo = McpResourceInfo;
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "snake_case")]
-pub enum ServerStatus {
-    Healthy,
-    Degraded,
-    Failed,
-}
-
-impl std::fmt::Display for ServerStatus {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::Healthy => write!(f, "healthy"),
-            Self::Degraded => write!(f, "degraded"),
-            Self::Failed => write!(f, "failed"),
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub struct ServerHealth {
-    pub server_name: String,
-    pub status: ServerStatus,
-    pub capabilities: Vec<String>,
-    pub last_error: Option<String>,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "snake_case", tag = "state")]
-pub enum PluginState {
-    Unconfigured,
-    Validated,
-    Starting,
-    Healthy,
-    Degraded {
-        healthy_servers: Vec<String>,
-        failed_servers: Vec<ServerHealth>,
-    },
-    Failed {
-        reason: String,
-    },
-    ShuttingDown,
-    Stopped,
-}
-
-impl PluginState {
-    #[must_use]
-    pub fn from_servers(servers: &[ServerHealth]) -> Self {
-        if servers.is_empty() {
-            return Self::Failed {
-                reason: "no servers available".to_string(),
-            };
-        }
-
-        let healthy_servers = servers
-            .iter()
-            .filter(|server| server.status != ServerStatus::Failed)
-            .map(|server| server.server_name.clone())
-            .collect::<Vec<_>>();
-        let failed_servers = servers
-            .iter()
-            .filter(|server| server.status == ServerStatus::Failed)
-            .cloned()
-            .collect::<Vec<_>>();
-        let has_degraded_server = servers
-            .iter()
-            .any(|server| server.status == ServerStatus::Degraded);
-
-        if failed_servers.is_empty() && !has_degraded_server {
-            Self::Healthy
-        } else if healthy_servers.is_empty() {
-            Self::Failed {
-                reason: format!("all {} servers failed", failed_servers.len()),
-            }
-        } else {
-            Self::Degraded {
-                healthy_servers,
-                failed_servers,
-            }
-        }
-    }
-}
-
-impl std::fmt::Display for PluginState {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::Unconfigured => write!(f, "unconfigured"),
-            Self::Validated => write!(f, "validated"),
-            Self::Starting => write!(f, "starting"),
-            Self::Healthy => write!(f, "healthy"),
-            Self::Degraded { .. } => write!(f, "degraded"),
-            Self::Failed { .. } => write!(f, "failed"),
-            Self::ShuttingDown => write!(f, "shutting_down"),
-            Self::Stopped => write!(f, "stopped"),
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub struct PluginHealthcheck {
-    pub plugin_name: String,
-    pub state: PluginState,
-    pub servers: Vec<ServerHealth>,
-    pub last_check: u64,
-}
-
-impl PluginHealthcheck {
-    #[must_use]
-    pub fn new(plugin_name: impl Into<String>, servers: Vec<ServerHealth>) -> Self {
-        let state = PluginState::from_servers(&servers);
-        Self {
-            plugin_name: plugin_name.into(),
-            state,
-            servers,
-            last_check: now_secs(),
-        }
-    }
-
-    #[must_use]
-    pub fn degraded_mode(&self, discovery: &DiscoveryResult) -> Option<DegradedMode> {
-        match &self.state {
-            PluginState::Degraded {
-                healthy_servers,
-                failed_servers,
-            } => Some(DegradedMode {
-                available_tools: discovery
-                    .tools
-                    .iter()
-                    .map(|tool| tool.name.clone())
-                    .collect(),
-                unavailable_tools: failed_servers
-                    .iter()
-                    .flat_map(|server| server.capabilities.iter().cloned())
-                    .collect(),
-                reason: format!(
-                    "{} servers healthy, {} servers failed",
-                    healthy_servers.len(),
-                    failed_servers.len()
-                ),
-            }),
-            _ => None,
-        }
-    }
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct DiscoveryResult {
-    pub tools: Vec<ToolInfo>,
-    pub resources: Vec<ResourceInfo>,
-    pub partial: bool,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub struct DegradedMode {
-    pub available_tools: Vec<String>,
-    pub unavailable_tools: Vec<String>,
-    pub reason: String,
-}
-
-impl DegradedMode {
-    #[must_use]
-    pub fn new(
-        available_tools: Vec<String>,
-        unavailable_tools: Vec<String>,
-        reason: impl Into<String>,
-    ) -> Self {
-        Self {
-            available_tools,
-            unavailable_tools,
-            reason: reason.into(),
-        }
-    }
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "snake_case")]
-pub enum PluginLifecycleEvent {
-    ConfigValidated,
-    StartupHealthy,
-    StartupDegraded,
-    StartupFailed,
-    Shutdown,
-}
-
-impl std::fmt::Display for PluginLifecycleEvent {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::ConfigValidated => write!(f, "config_validated"),
-            Self::StartupHealthy => write!(f, "startup_healthy"),
-            Self::StartupDegraded => write!(f, "startup_degraded"),
-            Self::StartupFailed => write!(f, "startup_failed"),
-            Self::Shutdown => write!(f, "shutdown"),
-        }
-    }
-}
-
-pub trait PluginLifecycle {
-    fn validate_config(&self, config: &RuntimePluginConfig) -> Result<(), String>;
-    fn healthcheck(&self) -> PluginHealthcheck;
-    fn discover(&self) -> DiscoveryResult;
-    fn shutdown(&mut self) -> Result<(), String>;
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[derive(Debug, Clone)]
-    struct MockPluginLifecycle {
-        plugin_name: String,
-        valid_config: bool,
-        healthcheck: PluginHealthcheck,
-        discovery: DiscoveryResult,
-        shutdown_error: Option<String>,
-        shutdown_called: bool,
-    }
-
-    impl MockPluginLifecycle {
-        fn new(
-            plugin_name: &str,
-            valid_config: bool,
-            servers: Vec<ServerHealth>,
-            discovery: DiscoveryResult,
-            shutdown_error: Option<String>,
-        ) -> Self {
-            Self {
-                plugin_name: plugin_name.to_string(),
-                valid_config,
-                healthcheck: PluginHealthcheck::new(plugin_name, servers),
-                discovery,
-                shutdown_error,
-                shutdown_called: false,
-            }
-        }
-    }
-
-    impl PluginLifecycle for MockPluginLifecycle {
-        fn validate_config(&self, _config: &RuntimePluginConfig) -> Result<(), String> {
-            if self.valid_config {
-                Ok(())
-            } else {
-                Err(format!(
-                    "plugin `{}` failed configuration validation",
-                    self.plugin_name
-                ))
-            }
-        }
-
-        fn healthcheck(&self) -> PluginHealthcheck {
-            if self.shutdown_called {
-                PluginHealthcheck {
-                    plugin_name: self.plugin_name.clone(),
-                    state: PluginState::Stopped,
-                    servers: self.healthcheck.servers.clone(),
-                    last_check: now_secs(),
-                }
-            } else {
-                self.healthcheck.clone()
-            }
-        }
-
-        fn discover(&self) -> DiscoveryResult {
-            self.discovery.clone()
-        }
-
-        fn shutdown(&mut self) -> Result<(), String> {
-            if let Some(error) = &self.shutdown_error {
-                return Err(error.clone());
-            }
-
-            self.shutdown_called = true;
-            Ok(())
-        }
-    }
-
-    fn healthy_server(name: &str, capabilities: &[&str]) -> ServerHealth {
-        ServerHealth {
-            server_name: name.to_string(),
-            status: ServerStatus::Healthy,
-            capabilities: capabilities
-                .iter()
-                .map(|capability| capability.to_string())
-                .collect(),
-            last_error: None,
-        }
-    }
-
-    fn failed_server(name: &str, capabilities: &[&str], error: &str) -> ServerHealth {
-        ServerHealth {
-            server_name: name.to_string(),
-            status: ServerStatus::Failed,
-            capabilities: capabilities
-                .iter()
-                .map(|capability| capability.to_string())
-                .collect(),
-            last_error: Some(error.to_string()),
-        }
-    }
-
-    fn degraded_server(name: &str, capabilities: &[&str], error: &str) -> ServerHealth {
-        ServerHealth {
-            server_name: name.to_string(),
-            status: ServerStatus::Degraded,
-            capabilities: capabilities
-                .iter()
-                .map(|capability| capability.to_string())
-                .collect(),
-            last_error: Some(error.to_string()),
-        }
-    }
-
-    fn tool(name: &str) -> ToolInfo {
-        ToolInfo {
-            name: name.to_string(),
-            description: Some(format!("{name} tool")),
-            input_schema: None,
-        }
-    }
-
-    fn resource(name: &str, uri: &str) -> ResourceInfo {
-        ResourceInfo {
-            uri: uri.to_string(),
-            name: name.to_string(),
-            description: Some(format!("{name} resource")),
-            mime_type: Some("application/json".to_string()),
-        }
-    }
-
-    #[test]
-    fn full_lifecycle_happy_path() {
-        // given
-        let mut lifecycle = MockPluginLifecycle::new(
-            "healthy-plugin",
-            true,
-            vec![
-                healthy_server("alpha", &["search", "read"]),
-                healthy_server("beta", &["write"]),
-            ],
-            DiscoveryResult {
-                tools: vec![tool("search"), tool("read"), tool("write")],
-                resources: vec![resource("docs", "file:///docs")],
-                partial: false,
-            },
-            None,
-        );
-        let config = RuntimePluginConfig::default();
-
-        // when
-        let validation = lifecycle.validate_config(&config);
-        let healthcheck = lifecycle.healthcheck();
-        let discovery = lifecycle.discover();
-        let shutdown = lifecycle.shutdown();
-        let post_shutdown = lifecycle.healthcheck();
-
-        // then
-        assert_eq!(validation, Ok(()));
-        assert_eq!(healthcheck.state, PluginState::Healthy);
-        assert_eq!(healthcheck.plugin_name, "healthy-plugin");
-        assert_eq!(discovery.tools.len(), 3);
-        assert_eq!(discovery.resources.len(), 1);
-        assert!(!discovery.partial);
-        assert_eq!(shutdown, Ok(()));
-        assert_eq!(post_shutdown.state, PluginState::Stopped);
-    }
-
-    #[test]
-    fn degraded_startup_when_one_of_three_servers_fails() {
-        // given
-        let lifecycle = MockPluginLifecycle::new(
-            "degraded-plugin",
-            true,
-            vec![
-                healthy_server("alpha", &["search"]),
-                failed_server("beta", &["write"], "connection refused"),
-                healthy_server("gamma", &["read"]),
-            ],
-            DiscoveryResult {
-                tools: vec![tool("search"), tool("read")],
-                resources: vec![resource("alpha-docs", "file:///alpha")],
-                partial: true,
-            },
-            None,
-        );
-
-        // when
-        let healthcheck = lifecycle.healthcheck();
-        let discovery = lifecycle.discover();
-        let degraded_mode = healthcheck
-            .degraded_mode(&discovery)
-            .expect("degraded startup should expose degraded mode");
-
-        // then
-        match healthcheck.state {
-            PluginState::Degraded {
-                healthy_servers,
-                failed_servers,
-            } => {
-                assert_eq!(
-                    healthy_servers,
-                    vec!["alpha".to_string(), "gamma".to_string()]
-                );
-                assert_eq!(failed_servers.len(), 1);
-                assert_eq!(failed_servers[0].server_name, "beta");
-                assert_eq!(
-                    failed_servers[0].last_error.as_deref(),
-                    Some("connection refused")
-                );
-            }
-            other => panic!("expected degraded state, got {other:?}"),
-        }
-        assert!(discovery.partial);
-        assert_eq!(
-            degraded_mode.available_tools,
-            vec!["search".to_string(), "read".to_string()]
-        );
-        assert_eq!(degraded_mode.unavailable_tools, vec!["write".to_string()]);
-        assert_eq!(degraded_mode.reason, "2 servers healthy, 1 servers failed");
-    }
-
-    #[test]
-    fn degraded_server_status_keeps_server_usable() {
-        // given
-        let lifecycle = MockPluginLifecycle::new(
-            "soft-degraded-plugin",
-            true,
-            vec![
-                healthy_server("alpha", &["search"]),
-                degraded_server("beta", &["write"], "high latency"),
-            ],
-            DiscoveryResult {
-                tools: vec![tool("search"), tool("write")],
-                resources: Vec::new(),
-                partial: true,
-            },
-            None,
-        );
-
-        // when
-        let healthcheck = lifecycle.healthcheck();
-
-        // then
-        match healthcheck.state {
-            PluginState::Degraded {
-                healthy_servers,
-                failed_servers,
-            } => {
-                assert_eq!(
-                    healthy_servers,
-                    vec!["alpha".to_string(), "beta".to_string()]
-                );
-                assert!(failed_servers.is_empty());
-            }
-            other => panic!("expected degraded state, got {other:?}"),
-        }
-    }
-
-    #[test]
-    fn complete_failure_when_all_servers_fail() {
-        // given
-        let lifecycle = MockPluginLifecycle::new(
-            "failed-plugin",
-            true,
-            vec![
-                failed_server("alpha", &["search"], "timeout"),
-                failed_server("beta", &["read"], "handshake failed"),
-            ],
-            DiscoveryResult {
-                tools: Vec::new(),
-                resources: Vec::new(),
-                partial: false,
-            },
-            None,
-        );
-
-        // when
-        let healthcheck = lifecycle.healthcheck();
-        let discovery = lifecycle.discover();
-
-        // then
-        match &healthcheck.state {
-            PluginState::Failed { reason } => {
-                assert_eq!(reason, "all 2 servers failed");
-            }
-            other => panic!("expected failed state, got {other:?}"),
-        }
-        assert!(!discovery.partial);
-        assert!(discovery.tools.is_empty());
-        assert!(discovery.resources.is_empty());
-        assert!(healthcheck.degraded_mode(&discovery).is_none());
-    }
-
-    #[test]
-    fn graceful_shutdown() {
-        // given
-        let mut lifecycle = MockPluginLifecycle::new(
-            "shutdown-plugin",
-            true,
-            vec![healthy_server("alpha", &["search"])],
-            DiscoveryResult {
-                tools: vec![tool("search")],
-                resources: Vec::new(),
-                partial: false,
-            },
-            None,
-        );
-
-        // when
-        let shutdown = lifecycle.shutdown();
-        let post_shutdown = lifecycle.healthcheck();
-
-        // then
-        assert_eq!(shutdown, Ok(()));
-        assert_eq!(PluginLifecycleEvent::Shutdown.to_string(), "shutdown");
-        assert_eq!(post_shutdown.state, PluginState::Stopped);
-    }
-}

rust/crates/runtime/src/policy_engine.rs

@@ -1,458 +0,0 @@
-use std::time::Duration;
-
-pub type GreenLevel = u8;
-
-const STALE_BRANCH_THRESHOLD: Duration = Duration::from_secs(60 * 60);
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct PolicyRule {
-    pub name: String,
-    pub condition: PolicyCondition,
-    pub action: PolicyAction,
-    pub priority: u32,
-}
-
-impl PolicyRule {
-    #[must_use]
-    pub fn new(
-        name: impl Into<String>,
-        condition: PolicyCondition,
-        action: PolicyAction,
-        priority: u32,
-    ) -> Self {
-        Self {
-            name: name.into(),
-            condition,
-            action,
-            priority,
-        }
-    }
-
-    #[must_use]
-    pub fn matches(&self, context: &LaneContext) -> bool {
-        self.condition.matches(context)
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum PolicyCondition {
-    And(Vec<PolicyCondition>),
-    Or(Vec<PolicyCondition>),
-    GreenAt { level: GreenLevel },
-    StaleBranch,
-    StartupBlocked,
-    LaneCompleted,
-    ReviewPassed,
-    ScopedDiff,
-    TimedOut { duration: Duration },
-}
-
-impl PolicyCondition {
-    #[must_use]
-    pub fn matches(&self, context: &LaneContext) -> bool {
-        match self {
-            Self::And(conditions) => conditions
-                .iter()
-                .all(|condition| condition.matches(context)),
-            Self::Or(conditions) => conditions
-                .iter()
-                .any(|condition| condition.matches(context)),
-            Self::GreenAt { level } => context.green_level >= *level,
-            Self::StaleBranch => context.branch_freshness >= STALE_BRANCH_THRESHOLD,
-            Self::StartupBlocked => context.blocker == LaneBlocker::Startup,
-            Self::LaneCompleted => context.completed,
-            Self::ReviewPassed => context.review_status == ReviewStatus::Approved,
-            Self::ScopedDiff => context.diff_scope == DiffScope::Scoped,
-            Self::TimedOut { duration } => context.branch_freshness >= *duration,
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum PolicyAction {
-    MergeToDev,
-    MergeForward,
-    RecoverOnce,
-    Escalate { reason: String },
-    CloseoutLane,
-    CleanupSession,
-    Notify { channel: String },
-    Block { reason: String },
-    Chain(Vec<PolicyAction>),
-}
-
-impl PolicyAction {
-    fn flatten_into(&self, actions: &mut Vec<PolicyAction>) {
-        match self {
-            Self::Chain(chained) => {
-                for action in chained {
-                    action.flatten_into(actions);
-                }
-            }
-            _ => actions.push(self.clone()),
-        }
-    }
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum LaneBlocker {
-    None,
-    Startup,
-    External,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum ReviewStatus {
-    Pending,
-    Approved,
-    Rejected,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum DiffScope {
-    Full,
-    Scoped,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct LaneContext {
-    pub lane_id: String,
-    pub green_level: GreenLevel,
-    pub branch_freshness: Duration,
-    pub blocker: LaneBlocker,
-    pub review_status: ReviewStatus,
-    pub diff_scope: DiffScope,
-    pub completed: bool,
-}
-
-impl LaneContext {
-    #[must_use]
-    pub fn new(
-        lane_id: impl Into<String>,
-        green_level: GreenLevel,
-        branch_freshness: Duration,
-        blocker: LaneBlocker,
-        review_status: ReviewStatus,
-        diff_scope: DiffScope,
-        completed: bool,
-    ) -> Self {
-        Self {
-            lane_id: lane_id.into(),
-            green_level,
-            branch_freshness,
-            blocker,
-            review_status,
-            diff_scope,
-            completed,
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct PolicyEngine {
-    rules: Vec<PolicyRule>,
-}
-
-impl PolicyEngine {
-    #[must_use]
-    pub fn new(mut rules: Vec<PolicyRule>) -> Self {
-        rules.sort_by_key(|rule| rule.priority);
-        Self { rules }
-    }
-
-    #[must_use]
-    pub fn rules(&self) -> &[PolicyRule] {
-        &self.rules
-    }
-
-    #[must_use]
-    pub fn evaluate(&self, context: &LaneContext) -> Vec<PolicyAction> {
-        evaluate(self, context)
-    }
-}
-
-#[must_use]
-pub fn evaluate(engine: &PolicyEngine, context: &LaneContext) -> Vec<PolicyAction> {
-    let mut actions = Vec::new();
-    for rule in &engine.rules {
-        if rule.matches(context) {
-            rule.action.flatten_into(&mut actions);
-        }
-    }
-    actions
-}
-
-#[cfg(test)]
-mod tests {
-    use std::time::Duration;
-
-    use super::{
-        evaluate, DiffScope, LaneBlocker, LaneContext, PolicyAction, PolicyCondition, PolicyEngine,
-        PolicyRule, ReviewStatus, STALE_BRANCH_THRESHOLD,
-    };
-
-    fn default_context() -> LaneContext {
-        LaneContext::new(
-            "lane-7",
-            0,
-            Duration::from_secs(0),
-            LaneBlocker::None,
-            ReviewStatus::Pending,
-            DiffScope::Full,
-            false,
-        )
-    }
-
-    #[test]
-    fn merge_to_dev_rule_fires_for_green_scoped_reviewed_lane() {
-        // given
-        let engine = PolicyEngine::new(vec![PolicyRule::new(
-            "merge-to-dev",
-            PolicyCondition::And(vec![
-                PolicyCondition::GreenAt { level: 2 },
-                PolicyCondition::ScopedDiff,
-                PolicyCondition::ReviewPassed,
-            ]),
-            PolicyAction::MergeToDev,
-            20,
-        )]);
-        let context = LaneContext::new(
-            "lane-7",
-            3,
-            Duration::from_secs(5),
-            LaneBlocker::None,
-            ReviewStatus::Approved,
-            DiffScope::Scoped,
-            false,
-        );
-
-        // when
-        let actions = engine.evaluate(&context);
-
-        // then
-        assert_eq!(actions, vec![PolicyAction::MergeToDev]);
-    }
-
-    #[test]
-    fn stale_branch_rule_fires_at_threshold() {
-        // given
-        let engine = PolicyEngine::new(vec![PolicyRule::new(
-            "merge-forward",
-            PolicyCondition::StaleBranch,
-            PolicyAction::MergeForward,
-            10,
-        )]);
-        let context = LaneContext::new(
-            "lane-7",
-            1,
-            STALE_BRANCH_THRESHOLD,
-            LaneBlocker::None,
-            ReviewStatus::Pending,
-            DiffScope::Full,
-            false,
-        );
-
-        // when
-        let actions = engine.evaluate(&context);
-
-        // then
-        assert_eq!(actions, vec![PolicyAction::MergeForward]);
-    }
-
-    #[test]
-    fn startup_blocked_rule_recovers_then_escalates() {
-        // given
-        let engine = PolicyEngine::new(vec![PolicyRule::new(
-            "startup-recovery",
-            PolicyCondition::StartupBlocked,
-            PolicyAction::Chain(vec![
-                PolicyAction::RecoverOnce,
-                PolicyAction::Escalate {
-                    reason: "startup remained blocked".to_string(),
-                },
-            ]),
-            15,
-        )]);
-        let context = LaneContext::new(
-            "lane-7",
-            0,
-            Duration::from_secs(0),
-            LaneBlocker::Startup,
-            ReviewStatus::Pending,
-            DiffScope::Full,
-            false,
-        );
-
-        // when
-        let actions = engine.evaluate(&context);
-
-        // then
-        assert_eq!(
-            actions,
-            vec![
-                PolicyAction::RecoverOnce,
-                PolicyAction::Escalate {
-                    reason: "startup remained blocked".to_string(),
-                },
-            ]
-        );
-    }
-
-    #[test]
-    fn completed_lane_rule_closes_out_and_cleans_up() {
-        // given
-        let engine = PolicyEngine::new(vec![PolicyRule::new(
-            "lane-closeout",
-            PolicyCondition::LaneCompleted,
-            PolicyAction::Chain(vec![
-                PolicyAction::CloseoutLane,
-                PolicyAction::CleanupSession,
-            ]),
-            30,
-        )]);
-        let context = LaneContext::new(
-            "lane-7",
-            0,
-            Duration::from_secs(0),
-            LaneBlocker::None,
-            ReviewStatus::Pending,
-            DiffScope::Full,
-            true,
-        );
-
-        // when
-        let actions = engine.evaluate(&context);
-
-        // then
-        assert_eq!(
-            actions,
-            vec![PolicyAction::CloseoutLane, PolicyAction::CleanupSession]
-        );
-    }
-
-    #[test]
-    fn matching_rules_are_returned_in_priority_order_with_stable_ties() {
-        // given
-        let engine = PolicyEngine::new(vec![
-            PolicyRule::new(
-                "late-cleanup",
-                PolicyCondition::And(vec![]),
-                PolicyAction::CleanupSession,
-                30,
-            ),
-            PolicyRule::new(
-                "first-notify",
-                PolicyCondition::And(vec![]),
-                PolicyAction::Notify {
-                    channel: "ops".to_string(),
-                },
-                10,
-            ),
-            PolicyRule::new(
-                "second-notify",
-                PolicyCondition::And(vec![]),
-                PolicyAction::Notify {
-                    channel: "review".to_string(),
-                },
-                10,
-            ),
-            PolicyRule::new(
-                "merge",
-                PolicyCondition::And(vec![]),
-                PolicyAction::MergeToDev,
-                20,
-            ),
-        ]);
-        let context = default_context();
-
-        // when
-        let actions = evaluate(&engine, &context);
-
-        // then
-        assert_eq!(
-            actions,
-            vec![
-                PolicyAction::Notify {
-                    channel: "ops".to_string(),
-                },
-                PolicyAction::Notify {
-                    channel: "review".to_string(),
-                },
-                PolicyAction::MergeToDev,
-                PolicyAction::CleanupSession,
-            ]
-        );
-    }
-
-    #[test]
-    fn combinators_handle_empty_cases_and_nested_chains() {
-        // given
-        let engine = PolicyEngine::new(vec![
-            PolicyRule::new(
-                "empty-and",
-                PolicyCondition::And(vec![]),
-                PolicyAction::Notify {
-                    channel: "orchestrator".to_string(),
-                },
-                5,
-            ),
-            PolicyRule::new(
-                "empty-or",
-                PolicyCondition::Or(vec![]),
-                PolicyAction::Block {
-                    reason: "should not fire".to_string(),
-                },
-                10,
-            ),
-            PolicyRule::new(
-                "nested",
-                PolicyCondition::Or(vec![
-                    PolicyCondition::StartupBlocked,
-                    PolicyCondition::And(vec![
-                        PolicyCondition::GreenAt { level: 2 },
-                        PolicyCondition::TimedOut {
-                            duration: Duration::from_secs(5),
-                        },
-                    ]),
-                ]),
-                PolicyAction::Chain(vec![
-                    PolicyAction::Notify {
-                        channel: "alerts".to_string(),
-                    },
-                    PolicyAction::Chain(vec![
-                        PolicyAction::MergeForward,
-                        PolicyAction::CleanupSession,
-                    ]),
-                ]),
-                15,
-            ),
-        ]);
-        let context = LaneContext::new(
-            "lane-7",
-            2,
-            Duration::from_secs(10),
-            LaneBlocker::External,
-            ReviewStatus::Pending,
-            DiffScope::Full,
-            false,
-        );
-
-        // when
-        let actions = engine.evaluate(&context);
-
-        // then
-        assert_eq!(
-            actions,
-            vec![
-                PolicyAction::Notify {
-                    channel: "orchestrator".to_string(),
-                },
-                PolicyAction::Notify {
-                    channel: "alerts".to_string(),
-                },
-                PolicyAction::MergeForward,
-                PolicyAction::CleanupSession,
-            ]
-        );
-    }
-}

rust/crates/runtime/src/recovery_recipes.rs

@@ -1,554 +0,0 @@
-//! Recovery recipes for common failure scenarios.
-//!
-//! Encodes known automatic recoveries for the six failure scenarios
-//! listed in ROADMAP item 8, and enforces one automatic recovery
-//! attempt before escalation. Each attempt is emitted as a structured
-//! recovery event.
-
-use std::collections::HashMap;
-
-use serde::{Deserialize, Serialize};
-
-/// The six failure scenarios that have known recovery recipes.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
-#[serde(rename_all = "snake_case")]
-pub enum FailureScenario {
-    TrustPromptUnresolved,
-    PromptMisdelivery,
-    StaleBranch,
-    CompileRedCrossCrate,
-    McpHandshakeFailure,
-    PartialPluginStartup,
-}
-
-impl FailureScenario {
-    /// Returns all known failure scenarios.
-    #[must_use]
-    pub fn all() -> &'static [FailureScenario] {
-        &[
-            Self::TrustPromptUnresolved,
-            Self::PromptMisdelivery,
-            Self::StaleBranch,
-            Self::CompileRedCrossCrate,
-            Self::McpHandshakeFailure,
-            Self::PartialPluginStartup,
-        ]
-    }
-}
-
-impl std::fmt::Display for FailureScenario {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::TrustPromptUnresolved => write!(f, "trust_prompt_unresolved"),
-            Self::PromptMisdelivery => write!(f, "prompt_misdelivery"),
-            Self::StaleBranch => write!(f, "stale_branch"),
-            Self::CompileRedCrossCrate => write!(f, "compile_red_cross_crate"),
-            Self::McpHandshakeFailure => write!(f, "mcp_handshake_failure"),
-            Self::PartialPluginStartup => write!(f, "partial_plugin_startup"),
-        }
-    }
-}
-
-/// Individual step that can be executed as part of a recovery recipe.
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "snake_case")]
-pub enum RecoveryStep {
-    AcceptTrustPrompt,
-    RedirectPromptToAgent,
-    RebaseBranch,
-    CleanBuild,
-    RetryMcpHandshake { timeout: u64 },
-    RestartPlugin { name: String },
-    EscalateToHuman { reason: String },
-}
-
-/// Policy governing what happens when automatic recovery is exhausted.
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "snake_case")]
-pub enum EscalationPolicy {
-    AlertHuman,
-    LogAndContinue,
-    Abort,
-}
-
-/// A recovery recipe encodes the sequence of steps to attempt for a
-/// given failure scenario, along with the maximum number of automatic
-/// attempts and the escalation policy.
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub struct RecoveryRecipe {
-    pub scenario: FailureScenario,
-    pub steps: Vec<RecoveryStep>,
-    pub max_attempts: u32,
-    pub escalation_policy: EscalationPolicy,
-}
-
-/// Outcome of a recovery attempt.
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "snake_case")]
-pub enum RecoveryResult {
-    Recovered {
-        steps_taken: u32,
-    },
-    PartialRecovery {
-        recovered: Vec<RecoveryStep>,
-        remaining: Vec<RecoveryStep>,
-    },
-    EscalationRequired {
-        reason: String,
-    },
-}
-
-/// Structured event emitted during recovery.
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "snake_case")]
-pub enum RecoveryEvent {
-    RecoveryAttempted {
-        scenario: FailureScenario,
-        recipe: RecoveryRecipe,
-        result: RecoveryResult,
-    },
-    RecoverySucceeded,
-    RecoveryFailed,
-    Escalated,
-}
-
-/// Minimal context for tracking recovery state and emitting events.
-///
-/// Holds per-scenario attempt counts, a structured event log, and an
-/// optional simulation knob for controlling step outcomes during tests.
-#[derive(Debug, Clone, Default)]
-pub struct RecoveryContext {
-    attempts: HashMap<FailureScenario, u32>,
-    events: Vec<RecoveryEvent>,
-    /// Optional step index at which simulated execution fails.
-    /// `None` means all steps succeed.
-    fail_at_step: Option<usize>,
-}
-
-impl RecoveryContext {
-    #[must_use]
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    /// Configure a step index at which simulated execution will fail.
-    #[must_use]
-    pub fn with_fail_at_step(mut self, index: usize) -> Self {
-        self.fail_at_step = Some(index);
-        self
-    }
-
-    /// Returns the structured event log populated during recovery.
-    #[must_use]
-    pub fn events(&self) -> &[RecoveryEvent] {
-        &self.events
-    }
-
-    /// Returns the number of recovery attempts made for a scenario.
-    #[must_use]
-    pub fn attempt_count(&self, scenario: &FailureScenario) -> u32 {
-        self.attempts.get(scenario).copied().unwrap_or(0)
-    }
-}
-
-/// Returns the known recovery recipe for the given failure scenario.
-#[must_use]
-pub fn recipe_for(scenario: &FailureScenario) -> RecoveryRecipe {
-    match scenario {
-        FailureScenario::TrustPromptUnresolved => RecoveryRecipe {
-            scenario: *scenario,
-            steps: vec![RecoveryStep::AcceptTrustPrompt],
-            max_attempts: 1,
-            escalation_policy: EscalationPolicy::AlertHuman,
-        },
-        FailureScenario::PromptMisdelivery => RecoveryRecipe {
-            scenario: *scenario,
-            steps: vec![RecoveryStep::RedirectPromptToAgent],
-            max_attempts: 1,
-            escalation_policy: EscalationPolicy::AlertHuman,
-        },
-        FailureScenario::StaleBranch => RecoveryRecipe {
-            scenario: *scenario,
-            steps: vec![RecoveryStep::RebaseBranch, RecoveryStep::CleanBuild],
-            max_attempts: 1,
-            escalation_policy: EscalationPolicy::AlertHuman,
-        },
-        FailureScenario::CompileRedCrossCrate => RecoveryRecipe {
-            scenario: *scenario,
-            steps: vec![RecoveryStep::CleanBuild],
-            max_attempts: 1,
-            escalation_policy: EscalationPolicy::AlertHuman,
-        },
-        FailureScenario::McpHandshakeFailure => RecoveryRecipe {
-            scenario: *scenario,
-            steps: vec![RecoveryStep::RetryMcpHandshake { timeout: 5000 }],
-            max_attempts: 1,
-            escalation_policy: EscalationPolicy::Abort,
-        },
-        FailureScenario::PartialPluginStartup => RecoveryRecipe {
-            scenario: *scenario,
-            steps: vec![
-                RecoveryStep::RestartPlugin {
-                    name: "stalled".to_string(),
-                },
-                RecoveryStep::RetryMcpHandshake { timeout: 3000 },
-            ],
-            max_attempts: 1,
-            escalation_policy: EscalationPolicy::LogAndContinue,
-        },
-    }
-}
-
-/// Attempts automatic recovery for the given failure scenario.
-///
-/// Looks up the recipe, enforces the one-attempt-before-escalation
-/// policy, simulates step execution (controlled by the context), and
-/// emits structured [`RecoveryEvent`]s for every attempt.
-pub fn attempt_recovery(scenario: &FailureScenario, ctx: &mut RecoveryContext) -> RecoveryResult {
-    let recipe = recipe_for(scenario);
-    let attempt_count = ctx.attempts.entry(*scenario).or_insert(0);
-
-    // Enforce one automatic recovery attempt before escalation.
-    if *attempt_count >= recipe.max_attempts {
-        let result = RecoveryResult::EscalationRequired {
-            reason: format!(
-                "max recovery attempts ({}) exceeded for {}",
-                recipe.max_attempts, scenario
-            ),
-        };
-        ctx.events.push(RecoveryEvent::RecoveryAttempted {
-            scenario: *scenario,
-            recipe,
-            result: result.clone(),
-        });
-        ctx.events.push(RecoveryEvent::Escalated);
-        return result;
-    }
-
-    *attempt_count += 1;
-
-    // Execute steps, honoring the optional fail_at_step simulation.
-    let fail_index = ctx.fail_at_step;
-    let mut executed = Vec::new();
-    let mut failed = false;
-
-    for (i, step) in recipe.steps.iter().enumerate() {
-        if fail_index == Some(i) {
-            failed = true;
-            break;
-        }
-        executed.push(step.clone());
-    }
-
-    let result = if failed {
-        let remaining: Vec<RecoveryStep> = recipe.steps[executed.len()..].to_vec();
-        if executed.is_empty() {
-            RecoveryResult::EscalationRequired {
-                reason: format!("recovery failed at first step for {}", scenario),
-            }
-        } else {
-            RecoveryResult::PartialRecovery {
-                recovered: executed,
-                remaining,
-            }
-        }
-    } else {
-        RecoveryResult::Recovered {
-            steps_taken: recipe.steps.len() as u32,
-        }
-    };
-
-    // Emit the attempt as structured event data.
-    ctx.events.push(RecoveryEvent::RecoveryAttempted {
-        scenario: *scenario,
-        recipe,
-        result: result.clone(),
-    });
-
-    match &result {
-        RecoveryResult::Recovered { .. } => {
-            ctx.events.push(RecoveryEvent::RecoverySucceeded);
-        }
-        RecoveryResult::PartialRecovery { .. } => {
-            ctx.events.push(RecoveryEvent::RecoveryFailed);
-        }
-        RecoveryResult::EscalationRequired { .. } => {
-            ctx.events.push(RecoveryEvent::Escalated);
-        }
-    }
-
-    result
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn each_scenario_has_a_matching_recipe() {
-        // given
-        let scenarios = FailureScenario::all();
-
-        // when / then
-        for scenario in scenarios {
-            let recipe = recipe_for(scenario);
-            assert_eq!(
-                recipe.scenario, *scenario,
-                "recipe scenario should match requested scenario"
-            );
-            assert!(
-                !recipe.steps.is_empty(),
-                "recipe for {} should have at least one step",
-                scenario
-            );
-            assert!(
-                recipe.max_attempts >= 1,
-                "recipe for {} should allow at least one attempt",
-                scenario
-            );
-        }
-    }
-
-    #[test]
-    fn successful_recovery_returns_recovered_and_emits_events() {
-        // given
-        let mut ctx = RecoveryContext::new();
-        let scenario = FailureScenario::TrustPromptUnresolved;
-
-        // when
-        let result = attempt_recovery(&scenario, &mut ctx);
-
-        // then
-        assert_eq!(result, RecoveryResult::Recovered { steps_taken: 1 });
-        assert_eq!(ctx.events().len(), 2);
-        assert!(matches!(
-            &ctx.events()[0],
-            RecoveryEvent::RecoveryAttempted {
-                scenario: s,
-                result: r,
-                ..
-            } if *s == FailureScenario::TrustPromptUnresolved
-              && matches!(r, RecoveryResult::Recovered { steps_taken: 1 })
-        ));
-        assert_eq!(ctx.events()[1], RecoveryEvent::RecoverySucceeded);
-    }
-
-    #[test]
-    fn escalation_after_max_attempts_exceeded() {
-        // given
-        let mut ctx = RecoveryContext::new();
-        let scenario = FailureScenario::PromptMisdelivery;
-
-        // when — first attempt succeeds
-        let first = attempt_recovery(&scenario, &mut ctx);
-        assert!(matches!(first, RecoveryResult::Recovered { .. }));
-
-        // when — second attempt should escalate
-        let second = attempt_recovery(&scenario, &mut ctx);
-
-        // then
-        assert!(
-            matches!(
-                &second,
-                RecoveryResult::EscalationRequired { reason }
-                    if reason.contains("max recovery attempts")
-            ),
-            "second attempt should require escalation, got: {second:?}"
-        );
-        assert_eq!(ctx.attempt_count(&scenario), 1);
-        assert!(ctx
-            .events()
-            .iter()
-            .any(|e| matches!(e, RecoveryEvent::Escalated)));
-    }
-
-    #[test]
-    fn partial_recovery_when_step_fails_midway() {
-        // given — PartialPluginStartup has two steps; fail at step index 1
-        let mut ctx = RecoveryContext::new().with_fail_at_step(1);
-        let scenario = FailureScenario::PartialPluginStartup;
-
-        // when
-        let result = attempt_recovery(&scenario, &mut ctx);
-
-        // then
-        match &result {
-            RecoveryResult::PartialRecovery {
-                recovered,
-                remaining,
-            } => {
-                assert_eq!(recovered.len(), 1, "one step should have succeeded");
-                assert_eq!(remaining.len(), 1, "one step should remain");
-                assert!(matches!(recovered[0], RecoveryStep::RestartPlugin { .. }));
-                assert!(matches!(
-                    remaining[0],
-                    RecoveryStep::RetryMcpHandshake { .. }
-                ));
-            }
-            other => panic!("expected PartialRecovery, got {other:?}"),
-        }
-        assert!(ctx
-            .events()
-            .iter()
-            .any(|e| matches!(e, RecoveryEvent::RecoveryFailed)));
-    }
-
-    #[test]
-    fn first_step_failure_escalates_immediately() {
-        // given — fail at step index 0
-        let mut ctx = RecoveryContext::new().with_fail_at_step(0);
-        let scenario = FailureScenario::CompileRedCrossCrate;
-
-        // when
-        let result = attempt_recovery(&scenario, &mut ctx);
-
-        // then
-        assert!(
-            matches!(
-                &result,
-                RecoveryResult::EscalationRequired { reason }
-                    if reason.contains("failed at first step")
-            ),
-            "zero-step failure should escalate, got: {result:?}"
-        );
-        assert!(ctx
-            .events()
-            .iter()
-            .any(|e| matches!(e, RecoveryEvent::Escalated)));
-    }
-
-    #[test]
-    fn emitted_events_include_structured_attempt_data() {
-        // given
-        let mut ctx = RecoveryContext::new();
-        let scenario = FailureScenario::McpHandshakeFailure;
-
-        // when
-        let _ = attempt_recovery(&scenario, &mut ctx);
-
-        // then — verify the RecoveryAttempted event carries full context
-        let attempted = ctx
-            .events()
-            .iter()
-            .find(|e| matches!(e, RecoveryEvent::RecoveryAttempted { .. }))
-            .expect("should have emitted RecoveryAttempted event");
-
-        match attempted {
-            RecoveryEvent::RecoveryAttempted {
-                scenario: s,
-                recipe,
-                result,
-            } => {
-                assert_eq!(*s, scenario);
-                assert_eq!(recipe.scenario, scenario);
-                assert!(!recipe.steps.is_empty());
-                assert!(matches!(result, RecoveryResult::Recovered { .. }));
-            }
-            _ => unreachable!(),
-        }
-
-        // Verify the event is serializable as structured JSON
-        let json = serde_json::to_string(&ctx.events()[0])
-            .expect("recovery event should be serializable to JSON");
-        assert!(
-            json.contains("mcp_handshake_failure"),
-            "serialized event should contain scenario name"
-        );
-    }
-
-    #[test]
-    fn recovery_context_tracks_attempts_per_scenario() {
-        // given
-        let mut ctx = RecoveryContext::new();
-
-        // when
-        assert_eq!(ctx.attempt_count(&FailureScenario::StaleBranch), 0);
-        attempt_recovery(&FailureScenario::StaleBranch, &mut ctx);
-
-        // then
-        assert_eq!(ctx.attempt_count(&FailureScenario::StaleBranch), 1);
-        assert_eq!(ctx.attempt_count(&FailureScenario::PromptMisdelivery), 0);
-    }
-
-    #[test]
-    fn stale_branch_recipe_has_rebase_then_clean_build() {
-        // given
-        let recipe = recipe_for(&FailureScenario::StaleBranch);
-
-        // then
-        assert_eq!(recipe.steps.len(), 2);
-        assert_eq!(recipe.steps[0], RecoveryStep::RebaseBranch);
-        assert_eq!(recipe.steps[1], RecoveryStep::CleanBuild);
-    }
-
-    #[test]
-    fn partial_plugin_startup_recipe_has_restart_then_handshake() {
-        // given
-        let recipe = recipe_for(&FailureScenario::PartialPluginStartup);
-
-        // then
-        assert_eq!(recipe.steps.len(), 2);
-        assert!(matches!(
-            recipe.steps[0],
-            RecoveryStep::RestartPlugin { .. }
-        ));
-        assert!(matches!(
-            recipe.steps[1],
-            RecoveryStep::RetryMcpHandshake { timeout: 3000 }
-        ));
-        assert_eq!(recipe.escalation_policy, EscalationPolicy::LogAndContinue);
-    }
-
-    #[test]
-    fn failure_scenario_display_all_variants() {
-        // given
-        let cases = [
-            (
-                FailureScenario::TrustPromptUnresolved,
-                "trust_prompt_unresolved",
-            ),
-            (FailureScenario::PromptMisdelivery, "prompt_misdelivery"),
-            (FailureScenario::StaleBranch, "stale_branch"),
-            (
-                FailureScenario::CompileRedCrossCrate,
-                "compile_red_cross_crate",
-            ),
-            (
-                FailureScenario::McpHandshakeFailure,
-                "mcp_handshake_failure",
-            ),
-            (
-                FailureScenario::PartialPluginStartup,
-                "partial_plugin_startup",
-            ),
-        ];
-
-        // when / then
-        for (scenario, expected) in &cases {
-            assert_eq!(scenario.to_string(), *expected);
-        }
-    }
-
-    #[test]
-    fn multi_step_success_reports_correct_steps_taken() {
-        // given — StaleBranch has 2 steps, no simulated failure
-        let mut ctx = RecoveryContext::new();
-        let scenario = FailureScenario::StaleBranch;
-
-        // when
-        let result = attempt_recovery(&scenario, &mut ctx);
-
-        // then
-        assert_eq!(result, RecoveryResult::Recovered { steps_taken: 2 });
-    }
-
-    #[test]
-    fn mcp_handshake_recipe_uses_abort_escalation_policy() {
-        // given
-        let recipe = recipe_for(&FailureScenario::McpHandshakeFailure);
-
-        // then
-        assert_eq!(recipe.escalation_policy, EscalationPolicy::Abort);
-        assert_eq!(recipe.max_attempts, 1);
-    }
-}

rust/crates/runtime/src/session_control.rs

@@ -1,461 +0,0 @@
-use std::env;
-use std::fmt::{Display, Formatter};
-use std::fs;
-use std::path::{Path, PathBuf};
-use std::time::UNIX_EPOCH;
-
-use serde::{Deserialize, Serialize};
-
-use crate::session::{Session, SessionError};
-use crate::worker_boot::{Worker, WorkerReadySnapshot, WorkerRegistry, WorkerStatus};
-
-pub const PRIMARY_SESSION_EXTENSION: &str = "jsonl";
-pub const LEGACY_SESSION_EXTENSION: &str = "json";
-pub const LATEST_SESSION_REFERENCE: &str = "latest";
-
-const SESSION_REFERENCE_ALIASES: &[&str] = &[LATEST_SESSION_REFERENCE, "last", "recent"];
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct SessionHandle {
-    pub id: String,
-    pub path: PathBuf,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct ManagedSessionSummary {
-    pub id: String,
-    pub path: PathBuf,
-    pub modified_epoch_millis: u128,
-    pub message_count: usize,
-    pub parent_session_id: Option<String>,
-    pub branch_name: Option<String>,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct LoadedManagedSession {
-    pub handle: SessionHandle,
-    pub session: Session,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct ForkedManagedSession {
-    pub parent_session_id: String,
-    pub handle: SessionHandle,
-    pub session: Session,
-    pub branch_name: Option<String>,
-}
-
-#[derive(Debug)]
-pub enum SessionControlError {
-    Io(std::io::Error),
-    Session(SessionError),
-    Format(String),
-}
-
-impl Display for SessionControlError {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::Io(error) => write!(f, "{error}"),
-            Self::Session(error) => write!(f, "{error}"),
-            Self::Format(error) => write!(f, "{error}"),
-        }
-    }
-}
-
-impl std::error::Error for SessionControlError {}
-
-impl From<std::io::Error> for SessionControlError {
-    fn from(value: std::io::Error) -> Self {
-        Self::Io(value)
-    }
-}
-
-impl From<SessionError> for SessionControlError {
-    fn from(value: SessionError) -> Self {
-        Self::Session(value)
-    }
-}
-
-pub fn sessions_dir() -> Result<PathBuf, SessionControlError> {
-    managed_sessions_dir_for(env::current_dir()?)
-}
-
-pub fn managed_sessions_dir_for(
-    base_dir: impl AsRef<Path>,
-) -> Result<PathBuf, SessionControlError> {
-    let path = base_dir.as_ref().join(".claw").join("sessions");
-    fs::create_dir_all(&path)?;
-    Ok(path)
-}
-
-pub fn create_managed_session_handle(
-    session_id: &str,
-) -> Result<SessionHandle, SessionControlError> {
-    create_managed_session_handle_for(env::current_dir()?, session_id)
-}
-
-pub fn create_managed_session_handle_for(
-    base_dir: impl AsRef<Path>,
-    session_id: &str,
-) -> Result<SessionHandle, SessionControlError> {
-    let id = session_id.to_string();
-    let path =
-        managed_sessions_dir_for(base_dir)?.join(format!("{id}.{PRIMARY_SESSION_EXTENSION}"));
-    Ok(SessionHandle { id, path })
-}
-
-pub fn resolve_session_reference(reference: &str) -> Result<SessionHandle, SessionControlError> {
-    resolve_session_reference_for(env::current_dir()?, reference)
-}
-
-pub fn resolve_session_reference_for(
-    base_dir: impl AsRef<Path>,
-    reference: &str,
-) -> Result<SessionHandle, SessionControlError> {
-    let base_dir = base_dir.as_ref();
-    if is_session_reference_alias(reference) {
-        let latest = latest_managed_session_for(base_dir)?;
-        return Ok(SessionHandle {
-            id: latest.id,
-            path: latest.path,
-        });
-    }
-
-    let direct = PathBuf::from(reference);
-    let candidate = if direct.is_absolute() {
-        direct.clone()
-    } else {
-        base_dir.join(&direct)
-    };
-    let looks_like_path = direct.extension().is_some() || direct.components().count() > 1;
-    let path = if candidate.exists() {
-        candidate
-    } else if looks_like_path {
-        return Err(SessionControlError::Format(
-            format_missing_session_reference(reference),
-        ));
-    } else {
-        resolve_managed_session_path_for(base_dir, reference)?
-    };
-
-    Ok(SessionHandle {
-        id: session_id_from_path(&path).unwrap_or_else(|| reference.to_string()),
-        path,
-    })
-}
-
-pub fn resolve_managed_session_path(session_id: &str) -> Result<PathBuf, SessionControlError> {
-    resolve_managed_session_path_for(env::current_dir()?, session_id)
-}
-
-pub fn resolve_managed_session_path_for(
-    base_dir: impl AsRef<Path>,
-    session_id: &str,
-) -> Result<PathBuf, SessionControlError> {
-    let directory = managed_sessions_dir_for(base_dir)?;
-    for extension in [PRIMARY_SESSION_EXTENSION, LEGACY_SESSION_EXTENSION] {
-        let path = directory.join(format!("{session_id}.{extension}"));
-        if path.exists() {
-            return Ok(path);
-        }
-    }
-    Err(SessionControlError::Format(
-        format_missing_session_reference(session_id),
-    ))
-}
-
-#[must_use]
-pub fn is_managed_session_file(path: &Path) -> bool {
-    path.extension()
-        .and_then(|ext| ext.to_str())
-        .is_some_and(|extension| {
-            extension == PRIMARY_SESSION_EXTENSION || extension == LEGACY_SESSION_EXTENSION
-        })
-}
-
-pub fn list_managed_sessions() -> Result<Vec<ManagedSessionSummary>, SessionControlError> {
-    list_managed_sessions_for(env::current_dir()?)
-}
-
-pub fn list_managed_sessions_for(
-    base_dir: impl AsRef<Path>,
-) -> Result<Vec<ManagedSessionSummary>, SessionControlError> {
-    let mut sessions = Vec::new();
-    for entry in fs::read_dir(managed_sessions_dir_for(base_dir)?)? {
-        let entry = entry?;
-        let path = entry.path();
-        if !is_managed_session_file(&path) {
-            continue;
-        }
-        let metadata = entry.metadata()?;
-        let modified_epoch_millis = metadata
-            .modified()
-            .ok()
-            .and_then(|time| time.duration_since(UNIX_EPOCH).ok())
-            .map(|duration| duration.as_millis())
-            .unwrap_or_default();
-        let (id, message_count, parent_session_id, branch_name) =
-            match Session::load_from_path(&path) {
-                Ok(session) => {
-                    let parent_session_id = session
-                        .fork
-                        .as_ref()
-                        .map(|fork| fork.parent_session_id.clone());
-                    let branch_name = session
-                        .fork
-                        .as_ref()
-                        .and_then(|fork| fork.branch_name.clone());
-                    (
-                        session.session_id,
-                        session.messages.len(),
-                        parent_session_id,
-                        branch_name,
-                    )
-                }
-                Err(_) => (
-                    path.file_stem()
-                        .and_then(|value| value.to_str())
-                        .unwrap_or("unknown")
-                        .to_string(),
-                    0,
-                    None,
-                    None,
-                ),
-            };
-        sessions.push(ManagedSessionSummary {
-            id,
-            path,
-            modified_epoch_millis,
-            message_count,
-            parent_session_id,
-            branch_name,
-        });
-    }
-    sessions.sort_by(|left, right| {
-        right
-            .modified_epoch_millis
-            .cmp(&left.modified_epoch_millis)
-            .then_with(|| right.id.cmp(&left.id))
-    });
-    Ok(sessions)
-}
-
-pub fn latest_managed_session() -> Result<ManagedSessionSummary, SessionControlError> {
-    latest_managed_session_for(env::current_dir()?)
-}
-
-pub fn latest_managed_session_for(
-    base_dir: impl AsRef<Path>,
-) -> Result<ManagedSessionSummary, SessionControlError> {
-    list_managed_sessions_for(base_dir)?
-        .into_iter()
-        .next()
-        .ok_or_else(|| SessionControlError::Format(format_no_managed_sessions()))
-}
-
-pub fn load_managed_session(reference: &str) -> Result<LoadedManagedSession, SessionControlError> {
-    load_managed_session_for(env::current_dir()?, reference)
-}
-
-pub fn load_managed_session_for(
-    base_dir: impl AsRef<Path>,
-    reference: &str,
-) -> Result<LoadedManagedSession, SessionControlError> {
-    let handle = resolve_session_reference_for(base_dir, reference)?;
-    let session = Session::load_from_path(&handle.path)?;
-    Ok(LoadedManagedSession {
-        handle: SessionHandle {
-            id: session.session_id.clone(),
-            path: handle.path,
-        },
-        session,
-    })
-}
-
-pub fn fork_managed_session(
-    session: &Session,
-    branch_name: Option<String>,
-) -> Result<ForkedManagedSession, SessionControlError> {
-    fork_managed_session_for(env::current_dir()?, session, branch_name)
-}
-
-pub fn fork_managed_session_for(
-    base_dir: impl AsRef<Path>,
-    session: &Session,
-    branch_name: Option<String>,
-) -> Result<ForkedManagedSession, SessionControlError> {
-    let parent_session_id = session.session_id.clone();
-    let forked = session.fork(branch_name);
-    let handle = create_managed_session_handle_for(base_dir, &forked.session_id)?;
-    let branch_name = forked
-        .fork
-        .as_ref()
-        .and_then(|fork| fork.branch_name.clone());
-    let forked = forked.with_persistence_path(handle.path.clone());
-    forked.save_to_path(&handle.path)?;
-    Ok(ForkedManagedSession {
-        parent_session_id,
-        handle,
-        session: forked,
-        branch_name,
-    })
-}
-
-#[must_use]
-pub fn is_session_reference_alias(reference: &str) -> bool {
-    SESSION_REFERENCE_ALIASES
-        .iter()
-        .any(|alias| reference.eq_ignore_ascii_case(alias))
-}
-
-fn session_id_from_path(path: &Path) -> Option<String> {
-    path.file_name()
-        .and_then(|value| value.to_str())
-        .and_then(|name| {
-            name.strip_suffix(&format!(".{PRIMARY_SESSION_EXTENSION}"))
-                .or_else(|| name.strip_suffix(&format!(".{LEGACY_SESSION_EXTENSION}")))
-        })
-        .map(ToOwned::to_owned)
-}
-
-fn format_missing_session_reference(reference: &str) -> String {
-    format!(
-        "session not found: {reference}\nHint: managed sessions live in .claw/sessions/. Try `{LATEST_SESSION_REFERENCE}` for the most recent session or `/session list` in the REPL."
-    )
-}
-
-fn format_no_managed_sessions() -> String {
-    format!(
-        "no managed sessions found in .claw/sessions/\nStart `claw` to create a session, then rerun with `--resume {LATEST_SESSION_REFERENCE}`."
-    )
-}
-
-#[cfg(test)]
-mod tests {
-    use super::{
-        create_managed_session_handle_for, fork_managed_session_for, is_session_reference_alias,
-        list_managed_sessions_for, load_managed_session_for, resolve_session_reference_for,
-        ManagedSessionSummary, LATEST_SESSION_REFERENCE,
-    };
-    use crate::session::Session;
-    use std::fs;
-    use std::path::{Path, PathBuf};
-    use std::time::{SystemTime, UNIX_EPOCH};
-
-    fn temp_dir() -> PathBuf {
-        let nanos = SystemTime::now()
-            .duration_since(UNIX_EPOCH)
-            .expect("time should be after epoch")
-            .as_nanos();
-        std::env::temp_dir().join(format!("runtime-session-control-{nanos}"))
-    }
-
-    fn persist_session(root: &Path, text: &str) -> Session {
-        let mut session = Session::new();
-        session
-            .push_user_text(text)
-            .expect("session message should save");
-        let handle = create_managed_session_handle_for(root, &session.session_id)
-            .expect("managed session handle should build");
-        let session = session.with_persistence_path(handle.path.clone());
-        session
-            .save_to_path(&handle.path)
-            .expect("session should persist");
-        session
-    }
-
-    fn wait_for_next_millisecond() {
-        let start = SystemTime::now()
-            .duration_since(UNIX_EPOCH)
-            .expect("time should be after epoch")
-            .as_millis();
-        while SystemTime::now()
-            .duration_since(UNIX_EPOCH)
-            .expect("time should be after epoch")
-            .as_millis()
-            <= start
-        {}
-    }
-
-    fn summary_by_id<'a>(
-        summaries: &'a [ManagedSessionSummary],
-        id: &str,
-    ) -> &'a ManagedSessionSummary {
-        summaries
-            .iter()
-            .find(|summary| summary.id == id)
-            .expect("session summary should exist")
-    }
-
-    #[test]
-    fn creates_and_lists_managed_sessions() {
-        // given
-        let root = temp_dir();
-        fs::create_dir_all(&root).expect("root dir should exist");
-        let older = persist_session(&root, "older session");
-        wait_for_next_millisecond();
-        let newer = persist_session(&root, "newer session");
-
-        // when
-        let sessions = list_managed_sessions_for(&root).expect("managed sessions should list");
-
-        // then
-        assert_eq!(sessions.len(), 2);
-        assert_eq!(sessions[0].id, newer.session_id);
-        assert_eq!(summary_by_id(&sessions, &older.session_id).message_count, 1);
-        assert_eq!(summary_by_id(&sessions, &newer.session_id).message_count, 1);
-        fs::remove_dir_all(root).expect("temp dir should clean up");
-    }
-
-    #[test]
-    fn resolves_latest_alias_and_loads_session_from_workspace_root() {
-        // given
-        let root = temp_dir();
-        fs::create_dir_all(&root).expect("root dir should exist");
-        let older = persist_session(&root, "older session");
-        wait_for_next_millisecond();
-        let newer = persist_session(&root, "newer session");
-
-        // when
-        let handle = resolve_session_reference_for(&root, LATEST_SESSION_REFERENCE)
-            .expect("latest alias should resolve");
-        let loaded = load_managed_session_for(&root, "recent")
-            .expect("recent alias should load the latest session");
-
-        // then
-        assert_eq!(handle.id, newer.session_id);
-        assert_eq!(loaded.handle.id, newer.session_id);
-        assert_eq!(loaded.session.messages.len(), 1);
-        assert_ne!(loaded.handle.id, older.session_id);
-        assert!(is_session_reference_alias("last"));
-        fs::remove_dir_all(root).expect("temp dir should clean up");
-    }
-
-    #[test]
-    fn forks_session_into_managed_storage_with_lineage() {
-        // given
-        let root = temp_dir();
-        fs::create_dir_all(&root).expect("root dir should exist");
-        let source = persist_session(&root, "parent session");
-
-        // when
-        let forked = fork_managed_session_for(&root, &source, Some("incident-review".to_string()))
-            .expect("session should fork");
-        let sessions = list_managed_sessions_for(&root).expect("managed sessions should list");
-        let summary = summary_by_id(&sessions, &forked.handle.id);
-
-        // then
-        assert_eq!(forked.parent_session_id, source.session_id);
-        assert_eq!(forked.branch_name.as_deref(), Some("incident-review"));
-        assert_eq!(
-            summary.parent_session_id.as_deref(),
-            Some(source.session_id.as_str())
-        );
-        assert_eq!(summary.branch_name.as_deref(), Some("incident-review"));
-        assert_eq!(
-            forked.session.persistence_path(),
-            Some(forked.handle.path.as_path())
-        );
-        fs::remove_dir_all(root).expect("temp dir should clean up");
-    }
-}

rust/crates/runtime/src/stale_branch.rs

@@ -1,389 +0,0 @@
-use std::path::Path;
-use std::process::Command;
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum BranchFreshness {
-    Fresh,
-    Stale {
-        commits_behind: usize,
-        missing_fixes: Vec<String>,
-    },
-    Diverged {
-        ahead: usize,
-        behind: usize,
-    },
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum StaleBranchPolicy {
-    AutoRebase,
-    AutoMergeForward,
-    WarnOnly,
-    Block,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum StaleBranchEvent {
-    BranchStaleAgainstMain {
-        branch: String,
-        commits_behind: usize,
-        missing_fixes: Vec<String>,
-    },
-    RebaseAttempted {
-        branch: String,
-        result: String,
-    },
-    MergeForwardAttempted {
-        branch: String,
-        result: String,
-    },
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum StaleBranchAction {
-    Noop,
-    Warn { message: String },
-    Block { message: String },
-    Rebase,
-    MergeForward,
-}
-
-pub fn check_freshness(branch: &str, main_ref: &str) -> BranchFreshness {
-    check_freshness_in(branch, main_ref, Path::new("."))
-}
-
-pub fn apply_policy(freshness: &BranchFreshness, policy: StaleBranchPolicy) -> StaleBranchAction {
-    match freshness {
-        BranchFreshness::Fresh => StaleBranchAction::Noop,
-        BranchFreshness::Stale {
-            commits_behind,
-            missing_fixes,
-        } => match policy {
-            StaleBranchPolicy::WarnOnly => StaleBranchAction::Warn {
-                message: format!(
-                    "Branch is {commits_behind} commit(s) behind main. Missing fixes: {}",
-                    if missing_fixes.is_empty() {
-                        "(none)".to_string()
-                    } else {
-                        missing_fixes.join("; ")
-                    }
-                ),
-            },
-            StaleBranchPolicy::Block => StaleBranchAction::Block {
-                message: format!(
-                    "Branch is {commits_behind} commit(s) behind main and must be updated before proceeding."
-                ),
-            },
-            StaleBranchPolicy::AutoRebase => StaleBranchAction::Rebase,
-            StaleBranchPolicy::AutoMergeForward => StaleBranchAction::MergeForward,
-        },
-        BranchFreshness::Diverged { ahead, behind } => match policy {
-            StaleBranchPolicy::WarnOnly => StaleBranchAction::Warn {
-                message: format!(
-                    "Branch has diverged: {ahead} commit(s) ahead, {behind} commit(s) behind main."
-                ),
-            },
-            StaleBranchPolicy::Block => StaleBranchAction::Block {
-                message: format!(
-                    "Branch has diverged ({ahead} ahead, {behind} behind) and must be reconciled before proceeding."
-                ),
-            },
-            StaleBranchPolicy::AutoRebase => StaleBranchAction::Rebase,
-            StaleBranchPolicy::AutoMergeForward => StaleBranchAction::MergeForward,
-        },
-    }
-}
-
-pub(crate) fn check_freshness_in(
-    branch: &str,
-    main_ref: &str,
-    repo_path: &Path,
-) -> BranchFreshness {
-    let behind = rev_list_count(main_ref, branch, repo_path);
-    let ahead = rev_list_count(branch, main_ref, repo_path);
-
-    if behind == 0 {
-        return BranchFreshness::Fresh;
-    }
-
-    if ahead > 0 {
-        return BranchFreshness::Diverged { ahead, behind };
-    }
-
-    let missing_fixes = missing_fix_subjects(main_ref, branch, repo_path);
-    BranchFreshness::Stale {
-        commits_behind: behind,
-        missing_fixes,
-    }
-}
-
-fn rev_list_count(a: &str, b: &str, repo_path: &Path) -> usize {
-    let output = Command::new("git")
-        .args(["rev-list", "--count", &format!("{b}..{a}")])
-        .current_dir(repo_path)
-        .output();
-    match output {
-        Ok(o) if o.status.success() => String::from_utf8_lossy(&o.stdout)
-            .trim()
-            .parse::<usize>()
-            .unwrap_or(0),
-        _ => 0,
-    }
-}
-
-fn missing_fix_subjects(a: &str, b: &str, repo_path: &Path) -> Vec<String> {
-    let output = Command::new("git")
-        .args(["log", "--format=%s", &format!("{b}..{a}")])
-        .current_dir(repo_path)
-        .output();
-    match output {
-        Ok(o) if o.status.success() => String::from_utf8_lossy(&o.stdout)
-            .lines()
-            .filter(|l| !l.is_empty())
-            .map(String::from)
-            .collect(),
-        _ => Vec::new(),
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use std::fs;
-    use std::time::{SystemTime, UNIX_EPOCH};
-
-    fn temp_dir() -> std::path::PathBuf {
-        let nanos = SystemTime::now()
-            .duration_since(UNIX_EPOCH)
-            .expect("time should be after epoch")
-            .as_nanos();
-        std::env::temp_dir().join(format!("runtime-stale-branch-{nanos}"))
-    }
-
-    fn init_repo(path: &Path) {
-        fs::create_dir_all(path).expect("create repo dir");
-        run(path, &["init", "--quiet", "-b", "main"]);
-        run(path, &["config", "user.email", "tests@example.com"]);
-        run(path, &["config", "user.name", "Stale Branch Tests"]);
-        fs::write(path.join("init.txt"), "initial\n").expect("write init file");
-        run(path, &["add", "."]);
-        run(path, &["commit", "-m", "initial commit", "--quiet"]);
-    }
-
-    fn run(cwd: &Path, args: &[&str]) {
-        let status = Command::new("git")
-            .args(args)
-            .current_dir(cwd)
-            .status()
-            .unwrap_or_else(|e| panic!("git {} failed to execute: {e}", args.join(" ")));
-        assert!(
-            status.success(),
-            "git {} exited with {status}",
-            args.join(" ")
-        );
-    }
-
-    fn commit_file(repo: &Path, name: &str, msg: &str) {
-        fs::write(repo.join(name), format!("{msg}\n")).expect("write file");
-        run(repo, &["add", name]);
-        run(repo, &["commit", "-m", msg, "--quiet"]);
-    }
-
-    #[test]
-    fn fresh_branch_passes() {
-        let root = temp_dir();
-        init_repo(&root);
-
-        // given
-        run(&root, &["checkout", "-b", "topic"]);
-
-        // when
-        let freshness = check_freshness_in("topic", "main", &root);
-
-        // then
-        assert_eq!(freshness, BranchFreshness::Fresh);
-
-        fs::remove_dir_all(&root).expect("cleanup");
-    }
-
-    #[test]
-    fn fresh_branch_ahead_of_main_still_fresh() {
-        let root = temp_dir();
-        init_repo(&root);
-
-        // given
-        run(&root, &["checkout", "-b", "topic"]);
-        commit_file(&root, "feature.txt", "add feature");
-
-        // when
-        let freshness = check_freshness_in("topic", "main", &root);
-
-        // then
-        assert_eq!(freshness, BranchFreshness::Fresh);
-
-        fs::remove_dir_all(&root).expect("cleanup");
-    }
-
-    #[test]
-    fn stale_branch_detected_with_correct_behind_count_and_missing_fixes() {
-        let root = temp_dir();
-        init_repo(&root);
-
-        // given
-        run(&root, &["checkout", "-b", "topic"]);
-        run(&root, &["checkout", "main"]);
-        commit_file(&root, "fix1.txt", "fix: resolve timeout");
-        commit_file(&root, "fix2.txt", "fix: handle null pointer");
-
-        // when
-        let freshness = check_freshness_in("topic", "main", &root);
-
-        // then
-        match freshness {
-            BranchFreshness::Stale {
-                commits_behind,
-                missing_fixes,
-            } => {
-                assert_eq!(commits_behind, 2);
-                assert_eq!(missing_fixes.len(), 2);
-                assert_eq!(missing_fixes[0], "fix: handle null pointer");
-                assert_eq!(missing_fixes[1], "fix: resolve timeout");
-            }
-            other => panic!("expected Stale, got {other:?}"),
-        }
-
-        fs::remove_dir_all(&root).expect("cleanup");
-    }
-
-    #[test]
-    fn diverged_branch_detection() {
-        let root = temp_dir();
-        init_repo(&root);
-
-        // given
-        run(&root, &["checkout", "-b", "topic"]);
-        commit_file(&root, "topic_work.txt", "topic work");
-        run(&root, &["checkout", "main"]);
-        commit_file(&root, "main_fix.txt", "main fix");
-
-        // when
-        let freshness = check_freshness_in("topic", "main", &root);
-
-        // then
-        match freshness {
-            BranchFreshness::Diverged { ahead, behind } => {
-                assert_eq!(ahead, 1);
-                assert_eq!(behind, 1);
-            }
-            other => panic!("expected Diverged, got {other:?}"),
-        }
-
-        fs::remove_dir_all(&root).expect("cleanup");
-    }
-
-    #[test]
-    fn policy_noop_for_fresh_branch() {
-        // given
-        let freshness = BranchFreshness::Fresh;
-
-        // when
-        let action = apply_policy(&freshness, StaleBranchPolicy::WarnOnly);
-
-        // then
-        assert_eq!(action, StaleBranchAction::Noop);
-    }
-
-    #[test]
-    fn policy_warn_for_stale_branch() {
-        // given
-        let freshness = BranchFreshness::Stale {
-            commits_behind: 3,
-            missing_fixes: vec!["fix: timeout".into(), "fix: null ptr".into()],
-        };
-
-        // when
-        let action = apply_policy(&freshness, StaleBranchPolicy::WarnOnly);
-
-        // then
-        match action {
-            StaleBranchAction::Warn { message } => {
-                assert!(message.contains("3 commit(s) behind"));
-                assert!(message.contains("fix: timeout"));
-                assert!(message.contains("fix: null ptr"));
-            }
-            other => panic!("expected Warn, got {other:?}"),
-        }
-    }
-
-    #[test]
-    fn policy_block_for_stale_branch() {
-        // given
-        let freshness = BranchFreshness::Stale {
-            commits_behind: 1,
-            missing_fixes: vec!["hotfix".into()],
-        };
-
-        // when
-        let action = apply_policy(&freshness, StaleBranchPolicy::Block);
-
-        // then
-        match action {
-            StaleBranchAction::Block { message } => {
-                assert!(message.contains("1 commit(s) behind"));
-            }
-            other => panic!("expected Block, got {other:?}"),
-        }
-    }
-
-    #[test]
-    fn policy_auto_rebase_for_stale_branch() {
-        // given
-        let freshness = BranchFreshness::Stale {
-            commits_behind: 2,
-            missing_fixes: vec![],
-        };
-
-        // when
-        let action = apply_policy(&freshness, StaleBranchPolicy::AutoRebase);
-
-        // then
-        assert_eq!(action, StaleBranchAction::Rebase);
-    }
-
-    #[test]
-    fn policy_auto_merge_forward_for_diverged_branch() {
-        // given
-        let freshness = BranchFreshness::Diverged {
-            ahead: 5,
-            behind: 2,
-        };
-
-        // when
-        let action = apply_policy(&freshness, StaleBranchPolicy::AutoMergeForward);
-
-        // then
-        assert_eq!(action, StaleBranchAction::MergeForward);
-    }
-
-    #[test]
-    fn policy_warn_for_diverged_branch() {
-        // given
-        let freshness = BranchFreshness::Diverged {
-            ahead: 3,
-            behind: 1,
-        };
-
-        // when
-        let action = apply_policy(&freshness, StaleBranchPolicy::WarnOnly);
-
-        // then
-        match action {
-            StaleBranchAction::Warn { message } => {
-                assert!(message.contains("diverged"));
-                assert!(message.contains("3 commit(s) ahead"));
-                assert!(message.contains("1 commit(s) behind"));
-            }
-            other => panic!("expected Warn, got {other:?}"),
-        }
-    }
-}

rust/crates/runtime/src/summary_compression.rs

@@ -1,300 +0,0 @@
-use std::collections::BTreeSet;
-
-const DEFAULT_MAX_CHARS: usize = 1_200;
-const DEFAULT_MAX_LINES: usize = 24;
-const DEFAULT_MAX_LINE_CHARS: usize = 160;
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub struct SummaryCompressionBudget {
-    pub max_chars: usize,
-    pub max_lines: usize,
-    pub max_line_chars: usize,
-}
-
-impl Default for SummaryCompressionBudget {
-    fn default() -> Self {
-        Self {
-            max_chars: DEFAULT_MAX_CHARS,
-            max_lines: DEFAULT_MAX_LINES,
-            max_line_chars: DEFAULT_MAX_LINE_CHARS,
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct SummaryCompressionResult {
-    pub summary: String,
-    pub original_chars: usize,
-    pub compressed_chars: usize,
-    pub original_lines: usize,
-    pub compressed_lines: usize,
-    pub removed_duplicate_lines: usize,
-    pub omitted_lines: usize,
-    pub truncated: bool,
-}
-
-#[must_use]
-pub fn compress_summary(
-    summary: &str,
-    budget: SummaryCompressionBudget,
-) -> SummaryCompressionResult {
-    let original_chars = summary.chars().count();
-    let original_lines = summary.lines().count();
-
-    let normalized = normalize_lines(summary, budget.max_line_chars);
-    if normalized.lines.is_empty() || budget.max_chars == 0 || budget.max_lines == 0 {
-        return SummaryCompressionResult {
-            summary: String::new(),
-            original_chars,
-            compressed_chars: 0,
-            original_lines,
-            compressed_lines: 0,
-            removed_duplicate_lines: normalized.removed_duplicate_lines,
-            omitted_lines: normalized.lines.len(),
-            truncated: original_chars > 0,
-        };
-    }
-
-    let selected = select_line_indexes(&normalized.lines, budget);
-    let mut compressed_lines = selected
-        .iter()
-        .map(|index| normalized.lines[*index].clone())
-        .collect::<Vec<_>>();
-    if compressed_lines.is_empty() {
-        compressed_lines.push(truncate_line(&normalized.lines[0], budget.max_chars));
-    }
-    let omitted_lines = normalized
-        .lines
-        .len()
-        .saturating_sub(compressed_lines.len());
-
-    if omitted_lines > 0 {
-        let omission_notice = omission_notice(omitted_lines);
-        push_line_with_budget(&mut compressed_lines, omission_notice, budget);
-    }
-
-    let compressed_summary = compressed_lines.join("\n");
-
-    SummaryCompressionResult {
-        compressed_chars: compressed_summary.chars().count(),
-        compressed_lines: compressed_lines.len(),
-        removed_duplicate_lines: normalized.removed_duplicate_lines,
-        omitted_lines,
-        truncated: compressed_summary != summary.trim(),
-        summary: compressed_summary,
-        original_chars,
-        original_lines,
-    }
-}
-
-#[must_use]
-pub fn compress_summary_text(summary: &str) -> String {
-    compress_summary(summary, SummaryCompressionBudget::default()).summary
-}
-
-#[derive(Debug, Default)]
-struct NormalizedSummary {
-    lines: Vec<String>,
-    removed_duplicate_lines: usize,
-}
-
-fn normalize_lines(summary: &str, max_line_chars: usize) -> NormalizedSummary {
-    let mut seen = BTreeSet::new();
-    let mut lines = Vec::new();
-    let mut removed_duplicate_lines = 0;
-
-    for raw_line in summary.lines() {
-        let normalized = collapse_inline_whitespace(raw_line);
-        if normalized.is_empty() {
-            continue;
-        }
-
-        let truncated = truncate_line(&normalized, max_line_chars);
-        let dedupe_key = dedupe_key(&truncated);
-        if !seen.insert(dedupe_key) {
-            removed_duplicate_lines += 1;
-            continue;
-        }
-
-        lines.push(truncated);
-    }
-
-    NormalizedSummary {
-        lines,
-        removed_duplicate_lines,
-    }
-}
-
-fn select_line_indexes(lines: &[String], budget: SummaryCompressionBudget) -> Vec<usize> {
-    let mut selected = BTreeSet::<usize>::new();
-
-    for priority in 0..=3 {
-        for (index, line) in lines.iter().enumerate() {
-            if selected.contains(&index) || line_priority(line) != priority {
-                continue;
-            }
-
-            let candidate = selected
-                .iter()
-                .map(|selected_index| lines[*selected_index].as_str())
-                .chain(std::iter::once(line.as_str()))
-                .collect::<Vec<_>>();
-
-            if candidate.len() > budget.max_lines {
-                continue;
-            }
-
-            if joined_char_count(&candidate) > budget.max_chars {
-                continue;
-            }
-
-            selected.insert(index);
-        }
-    }
-
-    selected.into_iter().collect()
-}
-
-fn push_line_with_budget(lines: &mut Vec<String>, line: String, budget: SummaryCompressionBudget) {
-    let candidate = lines
-        .iter()
-        .map(String::as_str)
-        .chain(std::iter::once(line.as_str()))
-        .collect::<Vec<_>>();
-
-    if candidate.len() <= budget.max_lines && joined_char_count(&candidate) <= budget.max_chars {
-        lines.push(line);
-    }
-}
-
-fn joined_char_count(lines: &[&str]) -> usize {
-    lines.iter().map(|line| line.chars().count()).sum::<usize>() + lines.len().saturating_sub(1)
-}
-
-fn line_priority(line: &str) -> usize {
-    if line == "Summary:" || line == "Conversation summary:" || is_core_detail(line) {
-        0
-    } else if is_section_header(line) {
-        1
-    } else if line.starts_with("- ") || line.starts_with("  - ") {
-        2
-    } else {
-        3
-    }
-}
-
-fn is_core_detail(line: &str) -> bool {
-    [
-        "- Scope:",
-        "- Current work:",
-        "- Pending work:",
-        "- Key files referenced:",
-        "- Tools mentioned:",
-        "- Recent user requests:",
-        "- Previously compacted context:",
-        "- Newly compacted context:",
-    ]
-    .iter()
-    .any(|prefix| line.starts_with(prefix))
-}
-
-fn is_section_header(line: &str) -> bool {
-    line.ends_with(':')
-}
-
-fn omission_notice(omitted_lines: usize) -> String {
-    format!("- … {omitted_lines} additional line(s) omitted.")
-}
-
-fn collapse_inline_whitespace(line: &str) -> String {
-    line.split_whitespace().collect::<Vec<_>>().join(" ")
-}
-
-fn truncate_line(line: &str, max_chars: usize) -> String {
-    if max_chars == 0 || line.chars().count() <= max_chars {
-        return line.to_string();
-    }
-
-    if max_chars == 1 {
-        return "…".to_string();
-    }
-
-    let mut truncated = line
-        .chars()
-        .take(max_chars.saturating_sub(1))
-        .collect::<String>();
-    truncated.push('…');
-    truncated
-}
-
-fn dedupe_key(line: &str) -> String {
-    line.to_ascii_lowercase()
-}
-
-#[cfg(test)]
-mod tests {
-    use super::{compress_summary, compress_summary_text, SummaryCompressionBudget};
-
-    #[test]
-    fn collapses_whitespace_and_duplicate_lines() {
-        // given
-        let summary = "Conversation summary:\n\n- Scope:   compact   earlier   messages.\n- Scope: compact earlier messages.\n- Current work: update runtime module.\n";
-
-        // when
-        let result = compress_summary(summary, SummaryCompressionBudget::default());
-
-        // then
-        assert_eq!(result.removed_duplicate_lines, 1);
-        assert!(result
-            .summary
-            .contains("- Scope: compact earlier messages."));
-        assert!(!result.summary.contains("  compact   earlier"));
-    }
-
-    #[test]
-    fn keeps_core_lines_when_budget_is_tight() {
-        // given
-        let summary = [
-            "Conversation summary:",
-            "- Scope: 18 earlier messages compacted.",
-            "- Current work: finish summary compression.",
-            "- Key timeline:",
-            "  - user: asked for a working implementation.",
-            "  - assistant: inspected runtime compaction flow.",
-            "  - tool: cargo check succeeded.",
-        ]
-        .join("\n");
-
-        // when
-        let result = compress_summary(
-            &summary,
-            SummaryCompressionBudget {
-                max_chars: 120,
-                max_lines: 3,
-                max_line_chars: 80,
-            },
-        );
-
-        // then
-        assert!(result.summary.contains("Conversation summary:"));
-        assert!(result
-            .summary
-            .contains("- Scope: 18 earlier messages compacted."));
-        assert!(result
-            .summary
-            .contains("- Current work: finish summary compression."));
-        assert!(result.omitted_lines > 0);
-    }
-
-    #[test]
-    fn provides_a_default_text_only_helper() {
-        // given
-        let summary = "Summary:\n\nA short line.";
-
-        // when
-        let compressed = compress_summary_text(summary);
-
-        // then
-        assert_eq!(compressed, "Summary:\nA short line.");
-    }
-}

rust/crates/runtime/src/task_packet.rs

@@ -1,591 +0,0 @@
-use serde::{Deserialize, Serialize};
-use serde_json::Value as JsonValue;
-use std::collections::BTreeMap;
-use std::fmt::{Display, Formatter};
-use std::path::{Path, PathBuf};
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub struct RepoConfig {
-    pub repo_root: PathBuf,
-    pub worktree_root: Option<PathBuf>,
-}
-
-impl RepoConfig {
-    #[must_use]
-    pub fn dispatch_root(&self) -> &Path {
-        self.worktree_root
-            .as_deref()
-            .unwrap_or(self.repo_root.as_path())
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "snake_case")]
-pub enum TaskScope {
-    SingleFile { path: PathBuf },
-    Module { crate_name: String },
-    Workspace,
-    Custom { paths: Vec<PathBuf> },
-}
-
-impl TaskScope {
-    #[must_use]
-    pub fn resolve_paths(&self, repo_config: &RepoConfig) -> Vec<PathBuf> {
-        let dispatch_root = repo_config.dispatch_root();
-        match self {
-            Self::SingleFile { path } => vec![resolve_path(dispatch_root, path)],
-            Self::Module { crate_name } => vec![dispatch_root.join("crates").join(crate_name)],
-            Self::Workspace => vec![dispatch_root.to_path_buf()],
-            Self::Custom { paths } => paths
-                .iter()
-                .map(|path| resolve_path(dispatch_root, path))
-                .collect(),
-        }
-    }
-}
-
-impl Display for TaskScope {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::SingleFile { .. } => write!(f, "single_file"),
-            Self::Module { .. } => write!(f, "module"),
-            Self::Workspace => write!(f, "workspace"),
-            Self::Custom { .. } => write!(f, "custom"),
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "snake_case")]
-pub enum BranchPolicy {
-    CreateNew { prefix: String },
-    UseExisting { name: String },
-    WorktreeIsolated,
-}
-
-impl Display for BranchPolicy {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::CreateNew { .. } => write!(f, "create_new"),
-            Self::UseExisting { .. } => write!(f, "use_existing"),
-            Self::WorktreeIsolated => write!(f, "worktree_isolated"),
-        }
-    }
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "snake_case")]
-pub enum CommitPolicy {
-    CommitPerTask,
-    SquashOnMerge,
-    NoAutoCommit,
-}
-
-impl Display for CommitPolicy {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::CommitPerTask => write!(f, "commit_per_task"),
-            Self::SquashOnMerge => write!(f, "squash_on_merge"),
-            Self::NoAutoCommit => write!(f, "no_auto_commit"),
-        }
-    }
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "snake_case")]
-pub enum GreenLevel {
-    Package,
-    Workspace,
-    MergeReady,
-}
-
-impl Display for GreenLevel {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::Package => write!(f, "package"),
-            Self::Workspace => write!(f, "workspace"),
-            Self::MergeReady => write!(f, "merge_ready"),
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "snake_case")]
-pub enum AcceptanceTest {
-    CargoTest { filter: Option<String> },
-    CustomCommand { cmd: String },
-    GreenLevel { level: GreenLevel },
-}
-
-impl Display for AcceptanceTest {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::CargoTest { .. } => write!(f, "cargo_test"),
-            Self::CustomCommand { .. } => write!(f, "custom_command"),
-            Self::GreenLevel { .. } => write!(f, "green_level"),
-        }
-    }
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "snake_case")]
-pub enum ReportingContract {
-    EventStream,
-    Summary,
-    Silent,
-}
-
-impl Display for ReportingContract {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::EventStream => write!(f, "event_stream"),
-            Self::Summary => write!(f, "summary"),
-            Self::Silent => write!(f, "silent"),
-        }
-    }
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "snake_case")]
-pub enum EscalationPolicy {
-    RetryThenEscalate { max_retries: u32 },
-    AutoEscalate,
-    NeverEscalate,
-}
-
-impl Display for EscalationPolicy {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::RetryThenEscalate { .. } => write!(f, "retry_then_escalate"),
-            Self::AutoEscalate => write!(f, "auto_escalate"),
-            Self::NeverEscalate => write!(f, "never_escalate"),
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub struct TaskPacket {
-    pub id: String,
-    pub objective: String,
-    pub scope: TaskScope,
-    pub repo_config: RepoConfig,
-    pub branch_policy: BranchPolicy,
-    pub acceptance_tests: Vec<AcceptanceTest>,
-    pub commit_policy: CommitPolicy,
-    pub reporting: ReportingContract,
-    pub escalation: EscalationPolicy,
-    pub created_at: u64,
-    pub metadata: BTreeMap<String, JsonValue>,
-}
-
-impl TaskPacket {
-    #[must_use]
-    pub fn resolve_scope_paths(&self) -> Vec<PathBuf> {
-        self.scope.resolve_paths(&self.repo_config)
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct TaskPacketValidationError {
-    errors: Vec<String>,
-}
-
-impl TaskPacketValidationError {
-    #[must_use]
-    pub fn new(errors: Vec<String>) -> Self {
-        Self { errors }
-    }
-
-    #[must_use]
-    pub fn errors(&self) -> &[String] {
-        &self.errors
-    }
-}
-
-impl Display for TaskPacketValidationError {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self.errors.join("; "))
-    }
-}
-
-impl std::error::Error for TaskPacketValidationError {}
-
-#[derive(Debug, Clone, PartialEq)]
-pub struct ValidatedPacket(TaskPacket);
-
-impl ValidatedPacket {
-    #[must_use]
-    pub fn packet(&self) -> &TaskPacket {
-        &self.0
-    }
-
-    #[must_use]
-    pub fn into_inner(self) -> TaskPacket {
-        self.0
-    }
-
-    #[must_use]
-    pub fn resolve_scope_paths(&self) -> Vec<PathBuf> {
-        self.0.resolve_scope_paths()
-    }
-}
-
-pub fn validate_packet(packet: TaskPacket) -> Result<ValidatedPacket, TaskPacketValidationError> {
-    let mut errors = Vec::new();
-
-    if packet.id.trim().is_empty() {
-        errors.push("packet id must not be empty".to_string());
-    }
-
-    if packet.objective.trim().is_empty() {
-        errors.push("packet objective must not be empty".to_string());
-    }
-
-    if packet.repo_config.repo_root.as_os_str().is_empty() {
-        errors.push("repo_config repo_root must not be empty".to_string());
-    }
-
-    if packet
-        .repo_config
-        .worktree_root
-        .as_ref()
-        .is_some_and(|path| path.as_os_str().is_empty())
-    {
-        errors.push("repo_config worktree_root must not be empty when present".to_string());
-    }
-
-    validate_scope(&packet.scope, &mut errors);
-    validate_branch_policy(&packet.branch_policy, &mut errors);
-    validate_acceptance_tests(&packet.acceptance_tests, &mut errors);
-    validate_escalation_policy(packet.escalation, &mut errors);
-
-    if errors.is_empty() {
-        Ok(ValidatedPacket(packet))
-    } else {
-        Err(TaskPacketValidationError::new(errors))
-    }
-}
-
-fn validate_scope(scope: &TaskScope, errors: &mut Vec<String>) {
-    match scope {
-        TaskScope::SingleFile { path } if path.as_os_str().is_empty() => {
-            errors.push("single_file scope path must not be empty".to_string());
-        }
-        TaskScope::Module { crate_name } if crate_name.trim().is_empty() => {
-            errors.push("module scope crate_name must not be empty".to_string());
-        }
-        TaskScope::Custom { paths } if paths.is_empty() => {
-            errors.push("custom scope paths must not be empty".to_string());
-        }
-        TaskScope::Custom { paths } => {
-            for (index, path) in paths.iter().enumerate() {
-                if path.as_os_str().is_empty() {
-                    errors.push(format!("custom scope contains empty path at index {index}"));
-                }
-            }
-        }
-        TaskScope::SingleFile { .. } | TaskScope::Module { .. } | TaskScope::Workspace => {}
-    }
-}
-
-fn validate_branch_policy(branch_policy: &BranchPolicy, errors: &mut Vec<String>) {
-    match branch_policy {
-        BranchPolicy::CreateNew { prefix } if prefix.trim().is_empty() => {
-            errors.push("create_new branch prefix must not be empty".to_string());
-        }
-        BranchPolicy::UseExisting { name } if name.trim().is_empty() => {
-            errors.push("use_existing branch name must not be empty".to_string());
-        }
-        BranchPolicy::CreateNew { .. }
-        | BranchPolicy::UseExisting { .. }
-        | BranchPolicy::WorktreeIsolated => {}
-    }
-}
-
-fn validate_acceptance_tests(tests: &[AcceptanceTest], errors: &mut Vec<String>) {
-    for test in tests {
-        match test {
-            AcceptanceTest::CargoTest { filter } => {
-                if filter
-                    .as_deref()
-                    .is_some_and(|value| value.trim().is_empty())
-                {
-                    errors.push("cargo_test filter must not be empty when present".to_string());
-                }
-            }
-            AcceptanceTest::CustomCommand { cmd } if cmd.trim().is_empty() => {
-                errors.push("custom_command cmd must not be empty".to_string());
-            }
-            AcceptanceTest::CustomCommand { .. } | AcceptanceTest::GreenLevel { .. } => {}
-        }
-    }
-}
-
-fn validate_escalation_policy(escalation: EscalationPolicy, errors: &mut Vec<String>) {
-    if matches!(
-        escalation,
-        EscalationPolicy::RetryThenEscalate { max_retries: 0 }
-    ) {
-        errors.push("retry_then_escalate max_retries must be greater than zero".to_string());
-    }
-}
-
-fn resolve_path(dispatch_root: &Path, path: &Path) -> PathBuf {
-    if path.is_absolute() {
-        path.to_path_buf()
-    } else {
-        dispatch_root.join(path)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use serde_json::json;
-    use std::time::{SystemTime, UNIX_EPOCH};
-
-    fn now_secs() -> u64 {
-        SystemTime::now()
-            .duration_since(UNIX_EPOCH)
-            .unwrap_or_default()
-            .as_secs()
-    }
-
-    fn sample_repo_config() -> RepoConfig {
-        RepoConfig {
-            repo_root: PathBuf::from("/repo"),
-            worktree_root: Some(PathBuf::from("/repo/.worktrees/task-1")),
-        }
-    }
-
-    fn sample_packet() -> TaskPacket {
-        let mut metadata = BTreeMap::new();
-        metadata.insert("attempt".to_string(), json!(1));
-        metadata.insert("lane".to_string(), json!("runtime"));
-
-        TaskPacket {
-            id: "packet_001".to_string(),
-            objective: "Implement typed task packet format".to_string(),
-            scope: TaskScope::Module {
-                crate_name: "runtime".to_string(),
-            },
-            repo_config: sample_repo_config(),
-            branch_policy: BranchPolicy::CreateNew {
-                prefix: "ultraclaw".to_string(),
-            },
-            acceptance_tests: vec![
-                AcceptanceTest::CargoTest {
-                    filter: Some("task_packet".to_string()),
-                },
-                AcceptanceTest::GreenLevel {
-                    level: GreenLevel::Workspace,
-                },
-            ],
-            commit_policy: CommitPolicy::CommitPerTask,
-            reporting: ReportingContract::EventStream,
-            escalation: EscalationPolicy::RetryThenEscalate { max_retries: 2 },
-            created_at: now_secs(),
-            metadata,
-        }
-    }
-
-    #[test]
-    fn valid_packet_passes_validation() {
-        // given
-        let packet = sample_packet();
-
-        // when
-        let validated = validate_packet(packet);
-
-        // then
-        assert!(validated.is_ok());
-    }
-
-    #[test]
-    fn invalid_packet_accumulates_errors() {
-        // given
-        let packet = TaskPacket {
-            id: " ".to_string(),
-            objective: " ".to_string(),
-            scope: TaskScope::Custom {
-                paths: vec![PathBuf::new()],
-            },
-            repo_config: RepoConfig {
-                repo_root: PathBuf::new(),
-                worktree_root: Some(PathBuf::new()),
-            },
-            branch_policy: BranchPolicy::CreateNew {
-                prefix: " ".to_string(),
-            },
-            acceptance_tests: vec![
-                AcceptanceTest::CargoTest {
-                    filter: Some(" ".to_string()),
-                },
-                AcceptanceTest::CustomCommand {
-                    cmd: " ".to_string(),
-                },
-            ],
-            commit_policy: CommitPolicy::NoAutoCommit,
-            reporting: ReportingContract::Silent,
-            escalation: EscalationPolicy::RetryThenEscalate { max_retries: 0 },
-            created_at: 0,
-            metadata: BTreeMap::new(),
-        };
-
-        // when
-        let error = validate_packet(packet).expect_err("packet should be rejected");
-
-        // then
-        assert!(error.errors().len() >= 8);
-        assert!(error
-            .errors()
-            .contains(&"packet id must not be empty".to_string()));
-        assert!(error
-            .errors()
-            .contains(&"packet objective must not be empty".to_string()));
-        assert!(error
-            .errors()
-            .contains(&"repo_config repo_root must not be empty".to_string()));
-        assert!(error
-            .errors()
-            .contains(&"create_new branch prefix must not be empty".to_string()));
-    }
-
-    #[test]
-    fn single_file_scope_resolves_against_worktree_root() {
-        // given
-        let repo_config = sample_repo_config();
-        let scope = TaskScope::SingleFile {
-            path: PathBuf::from("crates/runtime/src/task_packet.rs"),
-        };
-
-        // when
-        let paths = scope.resolve_paths(&repo_config);
-
-        // then
-        assert_eq!(
-            paths,
-            vec![PathBuf::from(
-                "/repo/.worktrees/task-1/crates/runtime/src/task_packet.rs"
-            )]
-        );
-    }
-
-    #[test]
-    fn workspace_scope_resolves_to_dispatch_root() {
-        // given
-        let repo_config = sample_repo_config();
-        let scope = TaskScope::Workspace;
-
-        // when
-        let paths = scope.resolve_paths(&repo_config);
-
-        // then
-        assert_eq!(paths, vec![PathBuf::from("/repo/.worktrees/task-1")]);
-    }
-
-    #[test]
-    fn module_scope_resolves_to_crate_directory() {
-        // given
-        let repo_config = sample_repo_config();
-        let scope = TaskScope::Module {
-            crate_name: "runtime".to_string(),
-        };
-
-        // when
-        let paths = scope.resolve_paths(&repo_config);
-
-        // then
-        assert_eq!(
-            paths,
-            vec![PathBuf::from("/repo/.worktrees/task-1/crates/runtime")]
-        );
-    }
-
-    #[test]
-    fn custom_scope_preserves_absolute_paths_and_resolves_relative_paths() {
-        // given
-        let repo_config = sample_repo_config();
-        let scope = TaskScope::Custom {
-            paths: vec![
-                PathBuf::from("Cargo.toml"),
-                PathBuf::from("/tmp/shared/script.sh"),
-            ],
-        };
-
-        // when
-        let paths = scope.resolve_paths(&repo_config);
-
-        // then
-        assert_eq!(
-            paths,
-            vec![
-                PathBuf::from("/repo/.worktrees/task-1/Cargo.toml"),
-                PathBuf::from("/tmp/shared/script.sh"),
-            ]
-        );
-    }
-
-    #[test]
-    fn serialization_roundtrip_preserves_packet() {
-        // given
-        let packet = sample_packet();
-
-        // when
-        let serialized = serde_json::to_string(&packet).expect("packet should serialize");
-        let deserialized: TaskPacket =
-            serde_json::from_str(&serialized).expect("packet should deserialize");
-
-        // then
-        assert_eq!(deserialized, packet);
-    }
-
-    #[test]
-    fn validated_packet_exposes_inner_packet_and_scope_paths() {
-        // given
-        let packet = sample_packet();
-
-        // when
-        let validated = validate_packet(packet.clone()).expect("packet should validate");
-        let resolved_paths = validated.resolve_scope_paths();
-        let inner = validated.into_inner();
-
-        // then
-        assert_eq!(
-            resolved_paths,
-            vec![PathBuf::from("/repo/.worktrees/task-1/crates/runtime")]
-        );
-        assert_eq!(inner, packet);
-    }
-
-    #[test]
-    fn display_impls_render_snake_case_variants() {
-        // given
-        let rendered = vec![
-            TaskScope::Workspace.to_string(),
-            BranchPolicy::WorktreeIsolated.to_string(),
-            CommitPolicy::SquashOnMerge.to_string(),
-            GreenLevel::MergeReady.to_string(),
-            AcceptanceTest::GreenLevel {
-                level: GreenLevel::Package,
-            }
-            .to_string(),
-            ReportingContract::EventStream.to_string(),
-            EscalationPolicy::AutoEscalate.to_string(),
-        ];
-
-        // when
-        let expected = vec![
-            "workspace",
-            "worktree_isolated",
-            "squash_on_merge",
-            "merge_ready",
-            "green_level",
-            "event_stream",
-            "auto_escalate",
-        ];
-
-        // then
-        assert_eq!(rendered, expected);
-    }
-}

rust/crates/runtime/src/task_registry.rs

@@ -1,4 +1,8 @@
 //! In-memory task registry for sub-agent task lifecycle management.
+//!
+//! Provides create, get, list, stop, update, and output operations
+//! matching the upstream TaskCreate/TaskGet/TaskList/TaskStop/TaskUpdate/TaskOutput
+//! tool surface.
 
 use std::collections::HashMap;
 use std::sync::{Arc, Mutex};
@@ -6,6 +10,7 @@ use std::time::{SystemTime, UNIX_EPOCH};
 
 use serde::{Deserialize, Serialize};
 
+/// Current status of a managed task.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum TaskStatus {
@@ -28,6 +33,7 @@ impl std::fmt::Display for TaskStatus {
     }
 }
 
+/// A single managed task entry.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct Task {
     pub task_id: String,
@@ -41,6 +47,7 @@ pub struct Task {
     pub team_id: Option<String>,
 }
 
+/// A message exchanged with a running task.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct TaskMessage {
     pub role: String,
@@ -48,6 +55,7 @@ pub struct TaskMessage {
     pub timestamp: u64,
 }
 
+/// Thread-safe task registry.
 #[derive(Debug, Clone, Default)]
 pub struct TaskRegistry {
     inner: Arc<Mutex<RegistryInner>>,
@@ -67,11 +75,13 @@ fn now_secs() -> u64 {
 }
 
 impl TaskRegistry {
+    /// Create a new empty registry.
     #[must_use]
     pub fn new() -> Self {
         Self::default()
     }
 
+    /// Create a new task and return its ID.
     pub fn create(&self, prompt: &str, description: Option<&str>) -> Task {
         let mut inner = self.inner.lock().expect("registry lock poisoned");
         inner.counter += 1;
@@ -92,21 +102,26 @@ impl TaskRegistry {
         task
     }
 
+    /// Look up a task by ID.
+    #[must_use]
     pub fn get(&self, task_id: &str) -> Option<Task> {
         let inner = self.inner.lock().expect("registry lock poisoned");
         inner.tasks.get(task_id).cloned()
     }
 
+    /// List all tasks, optionally filtered by status.
+    #[must_use]
     pub fn list(&self, status_filter: Option<TaskStatus>) -> Vec<Task> {
         let inner = self.inner.lock().expect("registry lock poisoned");
         inner
             .tasks
             .values()
-            .filter(|t| status_filter.map_or(true, |s| t.status == s))
+            .filter(|t| status_filter.is_none_or(|s| t.status == s))
             .cloned()
             .collect()
     }
 
+    /// Mark a task as stopped.
     pub fn stop(&self, task_id: &str) -> Result<Task, String> {
         let mut inner = self.inner.lock().expect("registry lock poisoned");
         let task = inner
@@ -129,6 +144,7 @@ impl TaskRegistry {
         Ok(task.clone())
     }
 
+    /// Send a message to a task, updating its state.
     pub fn update(&self, task_id: &str, message: &str) -> Result<Task, String> {
         let mut inner = self.inner.lock().expect("registry lock poisoned");
         let task = inner
@@ -145,6 +161,7 @@ impl TaskRegistry {
         Ok(task.clone())
     }
 
+    /// Get the accumulated output of a task.
     pub fn output(&self, task_id: &str) -> Result<String, String> {
         let inner = self.inner.lock().expect("registry lock poisoned");
         let task = inner
@@ -154,6 +171,7 @@ impl TaskRegistry {
         Ok(task.output.clone())
     }
 
+    /// Append output to a task (used by the task executor).
     pub fn append_output(&self, task_id: &str, output: &str) -> Result<(), String> {
         let mut inner = self.inner.lock().expect("registry lock poisoned");
         let task = inner
@@ -165,6 +183,7 @@ impl TaskRegistry {
         Ok(())
     }
 
+    /// Transition a task to a new status.
     pub fn set_status(&self, task_id: &str, status: TaskStatus) -> Result<(), String> {
         let mut inner = self.inner.lock().expect("registry lock poisoned");
         let task = inner
@@ -176,6 +195,7 @@ impl TaskRegistry {
         Ok(())
     }
 
+    /// Assign a task to a team.
     pub fn assign_team(&self, task_id: &str, team_id: &str) -> Result<(), String> {
         let mut inner = self.inner.lock().expect("registry lock poisoned");
         let task = inner
@@ -187,17 +207,21 @@ impl TaskRegistry {
         Ok(())
     }
 
+    /// Remove a task from the registry.
+    #[must_use]
     pub fn remove(&self, task_id: &str) -> Option<Task> {
         let mut inner = self.inner.lock().expect("registry lock poisoned");
         inner.tasks.remove(task_id)
     }
 
+    /// Number of tasks in the registry.
     #[must_use]
     pub fn len(&self) -> usize {
         let inner = self.inner.lock().expect("registry lock poisoned");
         inner.tasks.len()
     }
 
+    /// Whether the registry has no tasks.
     #[must_use]
     pub fn is_empty(&self) -> bool {
         self.len() == 0
@@ -311,139 +335,4 @@ mod tests {
             .set_status("nonexistent", TaskStatus::Running)
             .is_err());
     }
-
-    #[test]
-    fn task_status_display_all_variants() {
-        // given
-        let cases = [
-            (TaskStatus::Created, "created"),
-            (TaskStatus::Running, "running"),
-            (TaskStatus::Completed, "completed"),
-            (TaskStatus::Failed, "failed"),
-            (TaskStatus::Stopped, "stopped"),
-        ];
-
-        // when
-        let rendered: Vec<_> = cases
-            .into_iter()
-            .map(|(status, expected)| (status.to_string(), expected))
-            .collect();
-
-        // then
-        assert_eq!(
-            rendered,
-            vec![
-                ("created".to_string(), "created"),
-                ("running".to_string(), "running"),
-                ("completed".to_string(), "completed"),
-                ("failed".to_string(), "failed"),
-                ("stopped".to_string(), "stopped"),
-            ]
-        );
-    }
-
-    #[test]
-    fn stop_rejects_completed_task() {
-        // given
-        let registry = TaskRegistry::new();
-        let task = registry.create("done", None);
-        registry
-            .set_status(&task.task_id, TaskStatus::Completed)
-            .expect("set status should succeed");
-
-        // when
-        let result = registry.stop(&task.task_id);
-
-        // then
-        let error = result.expect_err("completed task should be rejected");
-        assert!(error.contains("already in terminal state"));
-        assert!(error.contains("completed"));
-    }
-
-    #[test]
-    fn stop_rejects_failed_task() {
-        // given
-        let registry = TaskRegistry::new();
-        let task = registry.create("failed", None);
-        registry
-            .set_status(&task.task_id, TaskStatus::Failed)
-            .expect("set status should succeed");
-
-        // when
-        let result = registry.stop(&task.task_id);
-
-        // then
-        let error = result.expect_err("failed task should be rejected");
-        assert!(error.contains("already in terminal state"));
-        assert!(error.contains("failed"));
-    }
-
-    #[test]
-    fn stop_succeeds_from_created_state() {
-        // given
-        let registry = TaskRegistry::new();
-        let task = registry.create("created task", None);
-
-        // when
-        let stopped = registry.stop(&task.task_id).expect("stop should succeed");
-
-        // then
-        assert_eq!(stopped.status, TaskStatus::Stopped);
-        assert!(stopped.updated_at >= task.updated_at);
-    }
-
-    #[test]
-    fn new_registry_is_empty() {
-        // given
-        let registry = TaskRegistry::new();
-
-        // when
-        let all_tasks = registry.list(None);
-
-        // then
-        assert!(registry.is_empty());
-        assert_eq!(registry.len(), 0);
-        assert!(all_tasks.is_empty());
-    }
-
-    #[test]
-    fn create_without_description() {
-        // given
-        let registry = TaskRegistry::new();
-
-        // when
-        let task = registry.create("Do the thing", None);
-
-        // then
-        assert!(task.task_id.starts_with("task_"));
-        assert_eq!(task.description, None);
-        assert!(task.messages.is_empty());
-        assert!(task.output.is_empty());
-        assert_eq!(task.team_id, None);
-    }
-
-    #[test]
-    fn remove_nonexistent_returns_none() {
-        // given
-        let registry = TaskRegistry::new();
-
-        // when
-        let removed = registry.remove("missing");
-
-        // then
-        assert!(removed.is_none());
-    }
-
-    #[test]
-    fn assign_team_rejects_missing_task() {
-        // given
-        let registry = TaskRegistry::new();
-
-        // when
-        let result = registry.assign_team("missing", "team_123");
-
-        // then
-        let error = result.expect_err("missing task should be rejected");
-        assert_eq!(error, "task not found: missing");
-    }
 }

rust/crates/runtime/src/team_cron_registry.rs

@@ -16,6 +16,11 @@ fn now_secs() -> u64 {
         .as_secs()
 }
 
+// ─────────────────────────────────────────────
+// Team registry
+// ─────────────────────────────────────────────
+
+/// A team groups multiple tasks for parallel execution.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct Team {
     pub team_id: String,
@@ -46,6 +51,7 @@ impl std::fmt::Display for TeamStatus {
     }
 }
 
+/// Thread-safe team registry.
 #[derive(Debug, Clone, Default)]
 pub struct TeamRegistry {
     inner: Arc<Mutex<TeamInner>>,
@@ -63,6 +69,8 @@ impl TeamRegistry {
         Self::default()
     }
 
+    /// Create a new team with the given name and task IDs.
+    #[must_use]
     pub fn create(&self, name: &str, task_ids: Vec<String>) -> Team {
         let mut inner = self.inner.lock().expect("team registry lock poisoned");
         inner.counter += 1;
@@ -80,16 +88,21 @@ impl TeamRegistry {
         team
     }
 
+    /// Get a team by ID.
+    #[must_use]
     pub fn get(&self, team_id: &str) -> Option<Team> {
         let inner = self.inner.lock().expect("team registry lock poisoned");
         inner.teams.get(team_id).cloned()
     }
 
+    /// List all teams.
+    #[must_use]
     pub fn list(&self) -> Vec<Team> {
         let inner = self.inner.lock().expect("team registry lock poisoned");
         inner.teams.values().cloned().collect()
     }
 
+    /// Delete a team.
     pub fn delete(&self, team_id: &str) -> Result<Team, String> {
         let mut inner = self.inner.lock().expect("team registry lock poisoned");
         let team = inner
@@ -101,6 +114,8 @@ impl TeamRegistry {
         Ok(team.clone())
     }
 
+    /// Remove a team entirely from the registry.
+    #[must_use]
     pub fn remove(&self, team_id: &str) -> Option<Team> {
         let mut inner = self.inner.lock().expect("team registry lock poisoned");
         inner.teams.remove(team_id)
@@ -118,6 +133,11 @@ impl TeamRegistry {
     }
 }
 
+// ─────────────────────────────────────────────
+// Cron registry
+// ─────────────────────────────────────────────
+
+/// A cron entry schedules a prompt to run on a recurring schedule.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct CronEntry {
     pub cron_id: String,
@@ -131,6 +151,7 @@ pub struct CronEntry {
     pub run_count: u64,
 }
 
+/// Thread-safe cron registry.
 #[derive(Debug, Clone, Default)]
 pub struct CronRegistry {
     inner: Arc<Mutex<CronInner>>,
@@ -148,6 +169,8 @@ impl CronRegistry {
         Self::default()
     }
 
+    /// Create a new cron entry.
+    #[must_use]
     pub fn create(&self, schedule: &str, prompt: &str, description: Option<&str>) -> CronEntry {
         let mut inner = self.inner.lock().expect("cron registry lock poisoned");
         inner.counter += 1;
@@ -168,11 +191,15 @@ impl CronRegistry {
         entry
     }
 
+    /// Get a cron entry by ID.
+    #[must_use]
     pub fn get(&self, cron_id: &str) -> Option<CronEntry> {
         let inner = self.inner.lock().expect("cron registry lock poisoned");
         inner.entries.get(cron_id).cloned()
     }
 
+    /// List all cron entries, optionally filtered to enabled only.
+    #[must_use]
     pub fn list(&self, enabled_only: bool) -> Vec<CronEntry> {
         let inner = self.inner.lock().expect("cron registry lock poisoned");
         inner
@@ -183,6 +210,7 @@ impl CronRegistry {
             .collect()
     }
 
+    /// Delete (remove) a cron entry.
     pub fn delete(&self, cron_id: &str) -> Result<CronEntry, String> {
         let mut inner = self.inner.lock().expect("cron registry lock poisoned");
         inner
@@ -263,7 +291,7 @@ mod tests {
         assert_eq!(still_there.status, TeamStatus::Deleted);
 
         // Hard remove
-        registry.remove(&t2.team_id);
+        let _ = registry.remove(&t2.team_id);
         assert_eq!(registry.len(), 1);
     }
 
@@ -339,170 +367,4 @@ mod tests {
         assert!(registry.record_run("nonexistent").is_err());
         assert!(registry.get("nonexistent").is_none());
     }
-
-    #[test]
-    fn team_status_display_all_variants() {
-        // given
-        let cases = [
-            (TeamStatus::Created, "created"),
-            (TeamStatus::Running, "running"),
-            (TeamStatus::Completed, "completed"),
-            (TeamStatus::Deleted, "deleted"),
-        ];
-
-        // when
-        let rendered: Vec<_> = cases
-            .into_iter()
-            .map(|(status, expected)| (status.to_string(), expected))
-            .collect();
-
-        // then
-        assert_eq!(
-            rendered,
-            vec![
-                ("created".to_string(), "created"),
-                ("running".to_string(), "running"),
-                ("completed".to_string(), "completed"),
-                ("deleted".to_string(), "deleted"),
-            ]
-        );
-    }
-
-    #[test]
-    fn new_team_registry_is_empty() {
-        // given
-        let registry = TeamRegistry::new();
-
-        // when
-        let teams = registry.list();
-
-        // then
-        assert!(registry.is_empty());
-        assert_eq!(registry.len(), 0);
-        assert!(teams.is_empty());
-    }
-
-    #[test]
-    fn team_remove_nonexistent_returns_none() {
-        // given
-        let registry = TeamRegistry::new();
-
-        // when
-        let removed = registry.remove("missing");
-
-        // then
-        assert!(removed.is_none());
-    }
-
-    #[test]
-    fn team_len_transitions() {
-        // given
-        let registry = TeamRegistry::new();
-
-        // when
-        let alpha = registry.create("Alpha", vec![]);
-        let beta = registry.create("Beta", vec![]);
-        let after_create = registry.len();
-        registry.remove(&alpha.team_id);
-        let after_first_remove = registry.len();
-        registry.remove(&beta.team_id);
-
-        // then
-        assert_eq!(after_create, 2);
-        assert_eq!(after_first_remove, 1);
-        assert_eq!(registry.len(), 0);
-        assert!(registry.is_empty());
-    }
-
-    #[test]
-    fn cron_list_all_disabled_returns_empty_for_enabled_only() {
-        // given
-        let registry = CronRegistry::new();
-        let first = registry.create("* * * * *", "Task 1", None);
-        let second = registry.create("0 * * * *", "Task 2", None);
-        registry
-            .disable(&first.cron_id)
-            .expect("disable should succeed");
-        registry
-            .disable(&second.cron_id)
-            .expect("disable should succeed");
-
-        // when
-        let enabled_only = registry.list(true);
-        let all_entries = registry.list(false);
-
-        // then
-        assert!(enabled_only.is_empty());
-        assert_eq!(all_entries.len(), 2);
-    }
-
-    #[test]
-    fn cron_create_without_description() {
-        // given
-        let registry = CronRegistry::new();
-
-        // when
-        let entry = registry.create("*/15 * * * *", "Check health", None);
-
-        // then
-        assert!(entry.cron_id.starts_with("cron_"));
-        assert_eq!(entry.description, None);
-        assert!(entry.enabled);
-        assert_eq!(entry.run_count, 0);
-        assert_eq!(entry.last_run_at, None);
-    }
-
-    #[test]
-    fn new_cron_registry_is_empty() {
-        // given
-        let registry = CronRegistry::new();
-
-        // when
-        let enabled_only = registry.list(true);
-        let all_entries = registry.list(false);
-
-        // then
-        assert!(registry.is_empty());
-        assert_eq!(registry.len(), 0);
-        assert!(enabled_only.is_empty());
-        assert!(all_entries.is_empty());
-    }
-
-    #[test]
-    fn cron_record_run_updates_timestamp_and_counter() {
-        // given
-        let registry = CronRegistry::new();
-        let entry = registry.create("*/5 * * * *", "Recurring", None);
-
-        // when
-        registry
-            .record_run(&entry.cron_id)
-            .expect("first run should succeed");
-        registry
-            .record_run(&entry.cron_id)
-            .expect("second run should succeed");
-        let fetched = registry.get(&entry.cron_id).expect("entry should exist");
-
-        // then
-        assert_eq!(fetched.run_count, 2);
-        assert!(fetched.last_run_at.is_some());
-        assert!(fetched.updated_at >= entry.updated_at);
-    }
-
-    #[test]
-    fn cron_disable_updates_timestamp() {
-        // given
-        let registry = CronRegistry::new();
-        let entry = registry.create("0 0 * * *", "Nightly", None);
-
-        // when
-        registry
-            .disable(&entry.cron_id)
-            .expect("disable should succeed");
-        let fetched = registry.get(&entry.cron_id).expect("entry should exist");
-
-        // then
-        assert!(!fetched.enabled);
-        assert!(fetched.updated_at >= entry.updated_at);
-    }
 }

rust/crates/runtime/src/trust_resolver.rs

@@ -1,299 +0,0 @@
-use std::path::{Path, PathBuf};
-
-const TRUST_PROMPT_CUES: &[&str] = &[
-    "do you trust the files in this folder",
-    "trust the files in this folder",
-    "trust this folder",
-    "allow and continue",
-    "yes, proceed",
-];
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum TrustPolicy {
-    AutoTrust,
-    RequireApproval,
-    Deny,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum TrustEvent {
-    TrustRequired { cwd: String },
-    TrustResolved { cwd: String, policy: TrustPolicy },
-    TrustDenied { cwd: String, reason: String },
-}
-
-#[derive(Debug, Clone, Default)]
-pub struct TrustConfig {
-    allowlisted: Vec<PathBuf>,
-    denied: Vec<PathBuf>,
-}
-
-impl TrustConfig {
-    #[must_use]
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    #[must_use]
-    pub fn with_allowlisted(mut self, path: impl Into<PathBuf>) -> Self {
-        self.allowlisted.push(path.into());
-        self
-    }
-
-    #[must_use]
-    pub fn with_denied(mut self, path: impl Into<PathBuf>) -> Self {
-        self.denied.push(path.into());
-        self
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum TrustDecision {
-    NotRequired,
-    Required {
-        policy: TrustPolicy,
-        events: Vec<TrustEvent>,
-    },
-}
-
-impl TrustDecision {
-    #[must_use]
-    pub fn policy(&self) -> Option<TrustPolicy> {
-        match self {
-            Self::NotRequired => None,
-            Self::Required { policy, .. } => Some(*policy),
-        }
-    }
-
-    #[must_use]
-    pub fn events(&self) -> &[TrustEvent] {
-        match self {
-            Self::NotRequired => &[],
-            Self::Required { events, .. } => events,
-        }
-    }
-}
-
-#[derive(Debug, Clone)]
-pub struct TrustResolver {
-    config: TrustConfig,
-}
-
-impl TrustResolver {
-    #[must_use]
-    pub fn new(config: TrustConfig) -> Self {
-        Self { config }
-    }
-
-    #[must_use]
-    pub fn resolve(&self, cwd: &str, screen_text: &str) -> TrustDecision {
-        if !detect_trust_prompt(screen_text) {
-            return TrustDecision::NotRequired;
-        }
-
-        let mut events = vec![TrustEvent::TrustRequired {
-            cwd: cwd.to_owned(),
-        }];
-
-        if let Some(matched_root) = self
-            .config
-            .denied
-            .iter()
-            .find(|root| path_matches(cwd, root))
-        {
-            let reason = format!("cwd matches denied trust root: {}", matched_root.display());
-            events.push(TrustEvent::TrustDenied {
-                cwd: cwd.to_owned(),
-                reason,
-            });
-            return TrustDecision::Required {
-                policy: TrustPolicy::Deny,
-                events,
-            };
-        }
-
-        if self
-            .config
-            .allowlisted
-            .iter()
-            .any(|root| path_matches(cwd, root))
-        {
-            events.push(TrustEvent::TrustResolved {
-                cwd: cwd.to_owned(),
-                policy: TrustPolicy::AutoTrust,
-            });
-            return TrustDecision::Required {
-                policy: TrustPolicy::AutoTrust,
-                events,
-            };
-        }
-
-        TrustDecision::Required {
-            policy: TrustPolicy::RequireApproval,
-            events,
-        }
-    }
-
-    #[must_use]
-    pub fn trusts(&self, cwd: &str) -> bool {
-        !self
-            .config
-            .denied
-            .iter()
-            .any(|root| path_matches(cwd, root))
-            && self
-                .config
-                .allowlisted
-                .iter()
-                .any(|root| path_matches(cwd, root))
-    }
-}
-
-#[must_use]
-pub fn detect_trust_prompt(screen_text: &str) -> bool {
-    let lowered = screen_text.to_ascii_lowercase();
-    TRUST_PROMPT_CUES
-        .iter()
-        .any(|needle| lowered.contains(needle))
-}
-
-#[must_use]
-pub fn path_matches_trusted_root(cwd: &str, trusted_root: &str) -> bool {
-    path_matches(cwd, &normalize_path(Path::new(trusted_root)))
-}
-
-fn path_matches(candidate: &str, root: &Path) -> bool {
-    let candidate = normalize_path(Path::new(candidate));
-    let root = normalize_path(root);
-    candidate == root || candidate.starts_with(&root)
-}
-
-fn normalize_path(path: &Path) -> PathBuf {
-    std::fs::canonicalize(path).unwrap_or_else(|_| path.to_path_buf())
-}
-
-#[cfg(test)]
-mod tests {
-    use super::{
-        detect_trust_prompt, path_matches_trusted_root, TrustConfig, TrustDecision, TrustEvent,
-        TrustPolicy, TrustResolver,
-    };
-
-    #[test]
-    fn detects_known_trust_prompt_copy() {
-        // given
-        let screen_text = "Do you trust the files in this folder?\n1. Yes, proceed\n2. No";
-
-        // when
-        let detected = detect_trust_prompt(screen_text);
-
-        // then
-        assert!(detected);
-    }
-
-    #[test]
-    fn does_not_emit_events_when_prompt_is_absent() {
-        // given
-        let resolver = TrustResolver::new(TrustConfig::new().with_allowlisted("/tmp/worktrees"));
-
-        // when
-        let decision = resolver.resolve("/tmp/worktrees/repo-a", "Ready for your input\n>");
-
-        // then
-        assert_eq!(decision, TrustDecision::NotRequired);
-        assert_eq!(decision.events(), &[]);
-        assert_eq!(decision.policy(), None);
-    }
-
-    #[test]
-    fn auto_trusts_allowlisted_cwd_after_prompt_detection() {
-        // given
-        let resolver = TrustResolver::new(TrustConfig::new().with_allowlisted("/tmp/worktrees"));
-
-        // when
-        let decision = resolver.resolve(
-            "/tmp/worktrees/repo-a",
-            "Do you trust the files in this folder?\n1. Yes, proceed\n2. No",
-        );
-
-        // then
-        assert_eq!(decision.policy(), Some(TrustPolicy::AutoTrust));
-        assert_eq!(
-            decision.events(),
-            &[
-                TrustEvent::TrustRequired {
-                    cwd: "/tmp/worktrees/repo-a".to_string(),
-                },
-                TrustEvent::TrustResolved {
-                    cwd: "/tmp/worktrees/repo-a".to_string(),
-                    policy: TrustPolicy::AutoTrust,
-                },
-            ]
-        );
-    }
-
-    #[test]
-    fn requires_approval_for_unknown_cwd_after_prompt_detection() {
-        // given
-        let resolver = TrustResolver::new(TrustConfig::new().with_allowlisted("/tmp/worktrees"));
-
-        // when
-        let decision = resolver.resolve(
-            "/tmp/other/repo-b",
-            "Do you trust the files in this folder?\n1. Yes, proceed\n2. No",
-        );
-
-        // then
-        assert_eq!(decision.policy(), Some(TrustPolicy::RequireApproval));
-        assert_eq!(
-            decision.events(),
-            &[TrustEvent::TrustRequired {
-                cwd: "/tmp/other/repo-b".to_string(),
-            }]
-        );
-    }
-
-    #[test]
-    fn denied_root_takes_precedence_over_allowlist() {
-        // given
-        let resolver = TrustResolver::new(
-            TrustConfig::new()
-                .with_allowlisted("/tmp/worktrees")
-                .with_denied("/tmp/worktrees/repo-c"),
-        );
-
-        // when
-        let decision = resolver.resolve(
-            "/tmp/worktrees/repo-c",
-            "Do you trust the files in this folder?\n1. Yes, proceed\n2. No",
-        );
-
-        // then
-        assert_eq!(decision.policy(), Some(TrustPolicy::Deny));
-        assert_eq!(
-            decision.events(),
-            &[
-                TrustEvent::TrustRequired {
-                    cwd: "/tmp/worktrees/repo-c".to_string(),
-                },
-                TrustEvent::TrustDenied {
-                    cwd: "/tmp/worktrees/repo-c".to_string(),
-                    reason: "cwd matches denied trust root: /tmp/worktrees/repo-c".to_string(),
-                },
-            ]
-        );
-    }
-
-    #[test]
-    fn sibling_prefix_does_not_match_trusted_root() {
-        // given
-        let trusted_root = "/tmp/worktrees";
-        let sibling_path = "/tmp/worktrees-other/repo-d";
-
-        // when
-        let matched = path_matches_trusted_root(sibling_path, trusted_root);
-
-        // then
-        assert!(!matched);
-    }
-}

rust/crates/runtime/src/worker_boot.rs

@@ -1,732 +0,0 @@
-//! In-memory worker-boot state machine and control registry.
-//!
-//! This provides a foundational control plane for reliable worker startup:
-//! trust-gate detection, ready-for-prompt handshakes, and prompt-misdelivery
-//! detection/recovery all live above raw terminal transport.
-
-use std::collections::HashMap;
-use std::path::{Path, PathBuf};
-use std::sync::{Arc, Mutex};
-use std::time::{SystemTime, UNIX_EPOCH};
-
-use serde::{Deserialize, Serialize};
-
-fn now_secs() -> u64 {
-    SystemTime::now()
-        .duration_since(UNIX_EPOCH)
-        .unwrap_or_default()
-        .as_secs()
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "snake_case")]
-pub enum WorkerStatus {
-    Spawning,
-    TrustRequired,
-    ReadyForPrompt,
-    PromptAccepted,
-    Running,
-    Blocked,
-    Finished,
-    Failed,
-}
-
-impl std::fmt::Display for WorkerStatus {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::Spawning => write!(f, "spawning"),
-            Self::TrustRequired => write!(f, "trust_required"),
-            Self::ReadyForPrompt => write!(f, "ready_for_prompt"),
-            Self::PromptAccepted => write!(f, "prompt_accepted"),
-            Self::Running => write!(f, "running"),
-            Self::Blocked => write!(f, "blocked"),
-            Self::Finished => write!(f, "finished"),
-            Self::Failed => write!(f, "failed"),
-        }
-    }
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "snake_case")]
-pub enum WorkerFailureKind {
-    TrustGate,
-    PromptDelivery,
-    Protocol,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
-pub struct WorkerFailure {
-    pub kind: WorkerFailureKind,
-    pub message: String,
-    pub created_at: u64,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "snake_case")]
-pub enum WorkerEventKind {
-    Spawning,
-    TrustRequired,
-    TrustResolved,
-    ReadyForPrompt,
-    PromptAccepted,
-    PromptMisdelivery,
-    PromptReplayArmed,
-    Running,
-    Restarted,
-    Finished,
-    Failed,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
-pub struct WorkerEvent {
-    pub seq: u64,
-    pub kind: WorkerEventKind,
-    pub status: WorkerStatus,
-    pub detail: Option<String>,
-    pub timestamp: u64,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
-pub struct Worker {
-    pub worker_id: String,
-    pub cwd: String,
-    pub status: WorkerStatus,
-    pub trust_auto_resolve: bool,
-    pub trust_gate_cleared: bool,
-    pub auto_recover_prompt_misdelivery: bool,
-    pub prompt_delivery_attempts: u32,
-    pub last_prompt: Option<String>,
-    pub replay_prompt: Option<String>,
-    pub last_error: Option<WorkerFailure>,
-    pub created_at: u64,
-    pub updated_at: u64,
-    pub events: Vec<WorkerEvent>,
-}
-
-#[derive(Debug, Clone, Default)]
-pub struct WorkerRegistry {
-    inner: Arc<Mutex<WorkerRegistryInner>>,
-}
-
-#[derive(Debug, Default)]
-struct WorkerRegistryInner {
-    workers: HashMap<String, Worker>,
-    counter: u64,
-}
-
-impl WorkerRegistry {
-    #[must_use]
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    #[must_use]
-    pub fn create(
-        &self,
-        cwd: &str,
-        trusted_roots: &[String],
-        auto_recover_prompt_misdelivery: bool,
-    ) -> Worker {
-        let mut inner = self.inner.lock().expect("worker registry lock poisoned");
-        inner.counter += 1;
-        let ts = now_secs();
-        let worker_id = format!("worker_{:08x}_{}", ts, inner.counter);
-        let trust_auto_resolve = trusted_roots
-            .iter()
-            .any(|root| path_matches_allowlist(cwd, root));
-        let mut worker = Worker {
-            worker_id: worker_id.clone(),
-            cwd: cwd.to_owned(),
-            status: WorkerStatus::Spawning,
-            trust_auto_resolve,
-            trust_gate_cleared: false,
-            auto_recover_prompt_misdelivery,
-            prompt_delivery_attempts: 0,
-            last_prompt: None,
-            replay_prompt: None,
-            last_error: None,
-            created_at: ts,
-            updated_at: ts,
-            events: Vec::new(),
-        };
-        push_event(
-            &mut worker,
-            WorkerEventKind::Spawning,
-            WorkerStatus::Spawning,
-            Some("worker created".to_string()),
-        );
-        inner.workers.insert(worker_id, worker.clone());
-        worker
-    }
-
-    #[must_use]
-    pub fn get(&self, worker_id: &str) -> Option<Worker> {
-        let inner = self.inner.lock().expect("worker registry lock poisoned");
-        inner.workers.get(worker_id).cloned()
-    }
-
-    pub fn observe(&self, worker_id: &str, screen_text: &str) -> Result<Worker, String> {
-        let mut inner = self.inner.lock().expect("worker registry lock poisoned");
-        let worker = inner
-            .workers
-            .get_mut(worker_id)
-            .ok_or_else(|| format!("worker not found: {worker_id}"))?;
-        let lowered = screen_text.to_ascii_lowercase();
-
-        if !worker.trust_gate_cleared && detect_trust_prompt(&lowered) {
-            worker.status = WorkerStatus::TrustRequired;
-            worker.last_error = Some(WorkerFailure {
-                kind: WorkerFailureKind::TrustGate,
-                message: "worker boot blocked on trust prompt".to_string(),
-                created_at: now_secs(),
-            });
-            push_event(
-                worker,
-                WorkerEventKind::TrustRequired,
-                WorkerStatus::TrustRequired,
-                Some("trust prompt detected".to_string()),
-            );
-
-            if worker.trust_auto_resolve {
-                worker.trust_gate_cleared = true;
-                worker.last_error = None;
-                worker.status = WorkerStatus::Spawning;
-                push_event(
-                    worker,
-                    WorkerEventKind::TrustResolved,
-                    WorkerStatus::Spawning,
-                    Some("allowlisted repo auto-resolved trust prompt".to_string()),
-                );
-            } else {
-                return Ok(worker.clone());
-            }
-        }
-
-        if prompt_misdelivery_is_relevant(worker)
-            && detect_prompt_misdelivery(&lowered, worker.last_prompt.as_deref())
-        {
-            let detail = prompt_preview(worker.last_prompt.as_deref().unwrap_or_default());
-            worker.last_error = Some(WorkerFailure {
-                kind: WorkerFailureKind::PromptDelivery,
-                message: format!("worker prompt landed in shell instead of coding agent: {detail}"),
-                created_at: now_secs(),
-            });
-            push_event(
-                worker,
-                WorkerEventKind::PromptMisdelivery,
-                WorkerStatus::Blocked,
-                Some("shell misdelivery detected".to_string()),
-            );
-            if worker.auto_recover_prompt_misdelivery {
-                worker.replay_prompt = worker.last_prompt.clone();
-                worker.status = WorkerStatus::ReadyForPrompt;
-                push_event(
-                    worker,
-                    WorkerEventKind::PromptReplayArmed,
-                    WorkerStatus::ReadyForPrompt,
-                    Some("prompt replay armed after shell misdelivery".to_string()),
-                );
-            } else {
-                worker.status = WorkerStatus::Blocked;
-            }
-            return Ok(worker.clone());
-        }
-
-        if detect_running_cue(&lowered)
-            && matches!(
-                worker.status,
-                WorkerStatus::PromptAccepted | WorkerStatus::ReadyForPrompt
-            )
-        {
-            worker.status = WorkerStatus::Running;
-            worker.last_error = None;
-            push_event(
-                worker,
-                WorkerEventKind::Running,
-                WorkerStatus::Running,
-                Some("worker accepted prompt and started running".to_string()),
-            );
-        }
-
-        if detect_ready_for_prompt(screen_text, &lowered)
-            && !matches!(
-                worker.status,
-                WorkerStatus::ReadyForPrompt | WorkerStatus::Running
-            )
-        {
-            worker.status = WorkerStatus::ReadyForPrompt;
-            if matches!(
-                worker.last_error.as_ref().map(|failure| failure.kind),
-                Some(WorkerFailureKind::TrustGate)
-            ) {
-                worker.last_error = None;
-            }
-            push_event(
-                worker,
-                WorkerEventKind::ReadyForPrompt,
-                WorkerStatus::ReadyForPrompt,
-                Some("worker is ready for prompt delivery".to_string()),
-            );
-        }
-
-        Ok(worker.clone())
-    }
-
-    pub fn resolve_trust(&self, worker_id: &str) -> Result<Worker, String> {
-        let mut inner = self.inner.lock().expect("worker registry lock poisoned");
-        let worker = inner
-            .workers
-            .get_mut(worker_id)
-            .ok_or_else(|| format!("worker not found: {worker_id}"))?;
-
-        if worker.status != WorkerStatus::TrustRequired {
-            return Err(format!(
-                "worker {worker_id} is not waiting on trust; current status: {}",
-                worker.status
-            ));
-        }
-
-        worker.trust_gate_cleared = true;
-        worker.last_error = None;
-        worker.status = WorkerStatus::Spawning;
-        push_event(
-            worker,
-            WorkerEventKind::TrustResolved,
-            WorkerStatus::Spawning,
-            Some("trust prompt resolved manually".to_string()),
-        );
-        Ok(worker.clone())
-    }
-
-    pub fn send_prompt(&self, worker_id: &str, prompt: Option<&str>) -> Result<Worker, String> {
-        let mut inner = self.inner.lock().expect("worker registry lock poisoned");
-        let worker = inner
-            .workers
-            .get_mut(worker_id)
-            .ok_or_else(|| format!("worker not found: {worker_id}"))?;
-
-        if worker.status != WorkerStatus::ReadyForPrompt {
-            return Err(format!(
-                "worker {worker_id} is not ready for prompt delivery; current status: {}",
-                worker.status
-            ));
-        }
-
-        let next_prompt = prompt
-            .map(str::trim)
-            .filter(|value| !value.is_empty())
-            .map(str::to_owned)
-            .or_else(|| worker.replay_prompt.clone())
-            .ok_or_else(|| format!("worker {worker_id} has no prompt to send or replay"))?;
-
-        worker.prompt_delivery_attempts += 1;
-        worker.last_prompt = Some(next_prompt.clone());
-        worker.replay_prompt = None;
-        worker.last_error = None;
-        worker.status = WorkerStatus::PromptAccepted;
-        push_event(
-            worker,
-            WorkerEventKind::PromptAccepted,
-            WorkerStatus::PromptAccepted,
-            Some(format!(
-                "prompt accepted for delivery: {}",
-                prompt_preview(&next_prompt)
-            )),
-        );
-        Ok(worker.clone())
-    }
-
-    pub fn await_ready(&self, worker_id: &str) -> Result<WorkerReadySnapshot, String> {
-        let worker = self
-            .get(worker_id)
-            .ok_or_else(|| format!("worker not found: {worker_id}"))?;
-
-        Ok(WorkerReadySnapshot {
-            worker_id: worker.worker_id.clone(),
-            status: worker.status,
-            ready: worker.status == WorkerStatus::ReadyForPrompt,
-            blocked: matches!(
-                worker.status,
-                WorkerStatus::TrustRequired | WorkerStatus::Blocked
-            ),
-            replay_prompt_ready: worker.replay_prompt.is_some(),
-            last_error: worker.last_error.clone(),
-        })
-    }
-
-    pub fn restart(&self, worker_id: &str) -> Result<Worker, String> {
-        let mut inner = self.inner.lock().expect("worker registry lock poisoned");
-        let worker = inner
-            .workers
-            .get_mut(worker_id)
-            .ok_or_else(|| format!("worker not found: {worker_id}"))?;
-        worker.status = WorkerStatus::Spawning;
-        worker.trust_gate_cleared = false;
-        worker.last_prompt = None;
-        worker.replay_prompt = None;
-        worker.last_error = None;
-        worker.prompt_delivery_attempts = 0;
-        push_event(
-            worker,
-            WorkerEventKind::Restarted,
-            WorkerStatus::Spawning,
-            Some("worker restarted".to_string()),
-        );
-        Ok(worker.clone())
-    }
-
-    pub fn terminate(&self, worker_id: &str) -> Result<Worker, String> {
-        let mut inner = self.inner.lock().expect("worker registry lock poisoned");
-        let worker = inner
-            .workers
-            .get_mut(worker_id)
-            .ok_or_else(|| format!("worker not found: {worker_id}"))?;
-        worker.status = WorkerStatus::Finished;
-        push_event(
-            worker,
-            WorkerEventKind::Finished,
-            WorkerStatus::Finished,
-            Some("worker terminated by control plane".to_string()),
-        );
-        Ok(worker.clone())
-    }
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
-pub struct WorkerReadySnapshot {
-    pub worker_id: String,
-    pub status: WorkerStatus,
-    pub ready: bool,
-    pub blocked: bool,
-    pub replay_prompt_ready: bool,
-    pub last_error: Option<WorkerFailure>,
-}
-
-fn prompt_misdelivery_is_relevant(worker: &Worker) -> bool {
-    matches!(
-        worker.status,
-        WorkerStatus::PromptAccepted | WorkerStatus::Running
-    ) && worker.last_prompt.is_some()
-}
-
-fn push_event(
-    worker: &mut Worker,
-    kind: WorkerEventKind,
-    status: WorkerStatus,
-    detail: Option<String>,
-) {
-    let timestamp = now_secs();
-    let seq = worker.events.len() as u64 + 1;
-    worker.updated_at = timestamp;
-    worker.events.push(WorkerEvent {
-        seq,
-        kind,
-        status,
-        detail,
-        timestamp,
-    });
-}
-
-fn path_matches_allowlist(cwd: &str, trusted_root: &str) -> bool {
-    let cwd = normalize_path(cwd);
-    let trusted_root = normalize_path(trusted_root);
-    cwd == trusted_root || cwd.starts_with(&trusted_root)
-}
-
-fn normalize_path(path: &str) -> PathBuf {
-    std::fs::canonicalize(path).unwrap_or_else(|_| Path::new(path).to_path_buf())
-}
-
-fn detect_trust_prompt(lowered: &str) -> bool {
-    [
-        "do you trust the files in this folder",
-        "trust the files in this folder",
-        "trust this folder",
-        "allow and continue",
-        "yes, proceed",
-    ]
-    .iter()
-    .any(|needle| lowered.contains(needle))
-}
-
-fn detect_ready_for_prompt(screen_text: &str, lowered: &str) -> bool {
-    if [
-        "ready for input",
-        "ready for your input",
-        "ready for prompt",
-        "send a message",
-    ]
-    .iter()
-    .any(|needle| lowered.contains(needle))
-    {
-        return true;
-    }
-
-    let Some(last_non_empty) = screen_text
-        .lines()
-        .rev()
-        .find(|line| !line.trim().is_empty())
-    else {
-        return false;
-    };
-    let trimmed = last_non_empty.trim();
-    if is_shell_prompt(trimmed) {
-        return false;
-    }
-
-    trimmed == ">"
-        || trimmed == "›"
-        || trimmed == "❯"
-        || trimmed.starts_with("> ")
-        || trimmed.starts_with("› ")
-        || trimmed.starts_with("❯ ")
-        || trimmed.contains("│ >")
-        || trimmed.contains("│ ›")
-        || trimmed.contains("│ ❯")
-}
-
-fn detect_running_cue(lowered: &str) -> bool {
-    [
-        "thinking",
-        "working",
-        "running tests",
-        "inspecting",
-        "analyzing",
-    ]
-    .iter()
-    .any(|needle| lowered.contains(needle))
-}
-
-fn is_shell_prompt(trimmed: &str) -> bool {
-    trimmed.ends_with('$')
-        || trimmed.ends_with('%')
-        || trimmed.ends_with('#')
-        || trimmed.starts_with('$')
-        || trimmed.starts_with('%')
-        || trimmed.starts_with('#')
-}
-
-fn detect_prompt_misdelivery(lowered: &str, prompt: Option<&str>) -> bool {
-    let Some(prompt) = prompt else {
-        return false;
-    };
-
-    let shell_error = [
-        "command not found",
-        "syntax error near unexpected token",
-        "parse error near",
-        "no such file or directory",
-        "unknown command",
-    ]
-    .iter()
-    .any(|needle| lowered.contains(needle));
-
-    if !shell_error {
-        return false;
-    }
-
-    let first_prompt_line = prompt
-        .lines()
-        .find(|line| !line.trim().is_empty())
-        .map(|line| line.trim().to_ascii_lowercase())
-        .unwrap_or_default();
-
-    first_prompt_line.is_empty() || lowered.contains(&first_prompt_line)
-}
-
-fn prompt_preview(prompt: &str) -> String {
-    let trimmed = prompt.trim();
-    if trimmed.chars().count() <= 48 {
-        return trimmed.to_string();
-    }
-    let preview = trimmed.chars().take(48).collect::<String>();
-    format!("{}…", preview.trim_end())
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn allowlisted_trust_prompt_auto_resolves_then_reaches_ready_state() {
-        let registry = WorkerRegistry::new();
-        let worker = registry.create(
-            "/tmp/worktrees/repo-a",
-            &["/tmp/worktrees".to_string()],
-            true,
-        );
-
-        let after_trust = registry
-            .observe(
-                &worker.worker_id,
-                "Do you trust the files in this folder?\n1. Yes, proceed\n2. No",
-            )
-            .expect("trust observe should succeed");
-        assert_eq!(after_trust.status, WorkerStatus::Spawning);
-        assert!(after_trust.trust_gate_cleared);
-        assert!(after_trust
-            .events
-            .iter()
-            .any(|event| event.kind == WorkerEventKind::TrustRequired));
-        assert!(after_trust
-            .events
-            .iter()
-            .any(|event| event.kind == WorkerEventKind::TrustResolved));
-
-        let ready = registry
-            .observe(&worker.worker_id, "Ready for your input\n>")
-            .expect("ready observe should succeed");
-        assert_eq!(ready.status, WorkerStatus::ReadyForPrompt);
-        assert!(ready.last_error.is_none());
-    }
-
-    #[test]
-    fn trust_prompt_blocks_non_allowlisted_worker_until_resolved() {
-        let registry = WorkerRegistry::new();
-        let worker = registry.create("/tmp/repo-b", &[], true);
-
-        let blocked = registry
-            .observe(
-                &worker.worker_id,
-                "Do you trust the files in this folder?\n1. Yes, proceed\n2. No",
-            )
-            .expect("trust observe should succeed");
-        assert_eq!(blocked.status, WorkerStatus::TrustRequired);
-        assert_eq!(
-            blocked.last_error.expect("trust error should exist").kind,
-            WorkerFailureKind::TrustGate
-        );
-
-        let send_before_resolve = registry.send_prompt(&worker.worker_id, Some("ship it"));
-        assert!(send_before_resolve
-            .expect_err("prompt delivery should be gated")
-            .contains("not ready for prompt delivery"));
-
-        let resolved = registry
-            .resolve_trust(&worker.worker_id)
-            .expect("manual trust resolution should succeed");
-        assert_eq!(resolved.status, WorkerStatus::Spawning);
-        assert!(resolved.trust_gate_cleared);
-    }
-
-    #[test]
-    fn ready_detection_ignores_plain_shell_prompts() {
-        assert!(!detect_ready_for_prompt("bellman@host %", "bellman@host %"));
-        assert!(!detect_ready_for_prompt("/tmp/repo $", "/tmp/repo $"));
-        assert!(detect_ready_for_prompt("│ >", "│ >"));
-    }
-
-    #[test]
-    fn prompt_misdelivery_is_detected_and_replay_can_be_rearmed() {
-        let registry = WorkerRegistry::new();
-        let worker = registry.create("/tmp/repo-c", &[], true);
-        registry
-            .observe(&worker.worker_id, "Ready for input\n>")
-            .expect("ready observe should succeed");
-
-        let accepted = registry
-            .send_prompt(&worker.worker_id, Some("Implement worker handshake"))
-            .expect("prompt send should succeed");
-        assert_eq!(accepted.status, WorkerStatus::PromptAccepted);
-        assert_eq!(accepted.prompt_delivery_attempts, 1);
-
-        let recovered = registry
-            .observe(
-                &worker.worker_id,
-                "% Implement worker handshake\nzsh: command not found: Implement",
-            )
-            .expect("misdelivery observe should succeed");
-        assert_eq!(recovered.status, WorkerStatus::ReadyForPrompt);
-        assert_eq!(
-            recovered
-                .last_error
-                .expect("misdelivery error should exist")
-                .kind,
-            WorkerFailureKind::PromptDelivery
-        );
-        assert_eq!(
-            recovered.replay_prompt.as_deref(),
-            Some("Implement worker handshake")
-        );
-        assert!(recovered
-            .events
-            .iter()
-            .any(|event| event.kind == WorkerEventKind::PromptMisdelivery));
-        assert!(recovered
-            .events
-            .iter()
-            .any(|event| event.kind == WorkerEventKind::PromptReplayArmed));
-
-        let replayed = registry
-            .send_prompt(&worker.worker_id, None)
-            .expect("replay send should succeed");
-        assert_eq!(replayed.status, WorkerStatus::PromptAccepted);
-        assert!(replayed.replay_prompt.is_none());
-        assert_eq!(replayed.prompt_delivery_attempts, 2);
-    }
-
-    #[test]
-    fn await_ready_surfaces_blocked_or_ready_worker_state() {
-        let registry = WorkerRegistry::new();
-        let worker = registry.create("/tmp/repo-d", &[], false);
-
-        let initial = registry
-            .await_ready(&worker.worker_id)
-            .expect("await should succeed");
-        assert!(!initial.ready);
-        assert!(!initial.blocked);
-
-        registry
-            .observe(
-                &worker.worker_id,
-                "Do you trust the files in this folder?\n1. Yes, proceed\n2. No",
-            )
-            .expect("trust observe should succeed");
-        let blocked = registry
-            .await_ready(&worker.worker_id)
-            .expect("await should succeed");
-        assert!(!blocked.ready);
-        assert!(blocked.blocked);
-
-        registry
-            .resolve_trust(&worker.worker_id)
-            .expect("manual trust resolution should succeed");
-        registry
-            .observe(&worker.worker_id, "Ready for your input\n>")
-            .expect("ready observe should succeed");
-        let ready = registry
-            .await_ready(&worker.worker_id)
-            .expect("await should succeed");
-        assert!(ready.ready);
-        assert!(!ready.blocked);
-        assert!(ready.last_error.is_none());
-    }
-
-    #[test]
-    fn restart_and_terminate_reset_or_finish_worker() {
-        let registry = WorkerRegistry::new();
-        let worker = registry.create("/tmp/repo-e", &[], true);
-        registry
-            .observe(&worker.worker_id, "Ready for input\n>")
-            .expect("ready observe should succeed");
-        registry
-            .send_prompt(&worker.worker_id, Some("Run tests"))
-            .expect("prompt send should succeed");
-
-        let restarted = registry
-            .restart(&worker.worker_id)
-            .expect("restart should succeed");
-        assert_eq!(restarted.status, WorkerStatus::Spawning);
-        assert_eq!(restarted.prompt_delivery_attempts, 0);
-        assert!(restarted.last_prompt.is_none());
-
-        let finished = registry
-            .terminate(&worker.worker_id)
-            .expect("terminate should succeed");
-        assert_eq!(finished.status, WorkerStatus::Finished);
-        assert!(finished
-            .events
-            .iter()
-            .any(|event| event.kind == WorkerEventKind::Finished));
-    }
-}

rust/crates/rusty-claude-cli/.claw/sessions/session-newer.jsonl

@@ -1 +0,0 @@
-{"created_at_ms":1775230717464,"session_id":"session-1775230717464-3","type":"session_meta","updated_at_ms":1775230717464,"version":1}

rust/crates/rusty-claude-cli/Cargo.toml

@@ -18,7 +18,6 @@ pulldown-cmark = "0.13"
 rustyline = "15"
 runtime = { path = "../runtime" }
 plugins = { path = "../plugins" }
-serde = { version = "1", features = ["derive"] }
 serde_json.workspace = true
 syntect = "5"
 tokio = { version = "1", features = ["rt-multi-thread", "signal", "time"] }

rust/crates/rusty-claude-cli/src/main.rs

@@ -39,18 +39,16 @@ use init::initialize_repo;
 use plugins::{PluginHooks, PluginManager, PluginManagerConfig, PluginRegistry};
 use render::{MarkdownStreamState, Spinner, TerminalRenderer};
 use runtime::{
-    clear_oauth_credentials, format_usd, generate_pkce_pair, generate_state, load_system_prompt,
-    parse_oauth_callback_request_target, pricing_for_model, resolve_sandbox_status,
-    save_oauth_credentials, ApiClient, ApiRequest, AssistantEvent, CompactionConfig, ConfigLoader,
-    ConfigSource, ContentBlock, ConversationMessage, ConversationRuntime, McpServerManager,
-    McpTool, MessageRole, ModelPricing, OAuthAuthorizationRequest, OAuthConfig,
+    clear_oauth_credentials, generate_pkce_pair, generate_state, load_system_prompt,
+    parse_oauth_callback_request_target, resolve_sandbox_status, save_oauth_credentials, ApiClient,
+    ApiRequest, AssistantEvent, CompactionConfig, ConfigLoader, ConfigSource, ContentBlock,
+    ConversationMessage, ConversationRuntime, MessageRole, OAuthAuthorizationRequest, OAuthConfig,
     OAuthTokenExchangeRequest, PermissionMode, PermissionPolicy, ProjectContext, PromptCacheEvent,
     ResolvedPermissionMode, RuntimeError, Session, TokenUsage, ToolError, ToolExecutor,
     UsageTracker,
 };
-use serde::Deserialize;
 use serde_json::json;
-use tools::{GlobalToolRegistry, RuntimeToolDefinition, ToolSearchOutput};
+use tools::GlobalToolRegistry;
 
 const DEFAULT_MODEL: &str = "claude-opus-4-6";
 fn max_tokens_for_model(model: &str) -> u32 {
@@ -595,17 +593,11 @@ fn current_tool_registry() -> Result<GlobalToolRegistry, String> {
     let cwd = env::current_dir().map_err(|error| error.to_string())?;
     let loader = ConfigLoader::default_for(&cwd);
     let runtime_config = loader.load().map_err(|error| error.to_string())?;
-    let state = build_runtime_plugin_state_with_loader(&cwd, &loader, &runtime_config)
+    let plugin_manager = build_plugin_manager(&cwd, &loader, &runtime_config);
+    let plugin_tools = plugin_manager
+        .aggregated_tools()
         .map_err(|error| error.to_string())?;
-    let registry = state.tool_registry.clone();
-    if let Some(mcp_state) = state.mcp_state {
-        mcp_state
-            .lock()
-            .unwrap_or_else(std::sync::PoisonError::into_inner)
-            .shutdown()
-            .map_err(|error| error.to_string())?;
-    }
-    Ok(registry)
+    GlobalToolRegistry::with_plugin_tools(plugin_tools)
 }
 
 fn parse_permission_mode_arg(value: &str) -> Result<PermissionMode, String> {
@@ -1594,35 +1586,23 @@ struct RuntimePluginState {
     feature_config: runtime::RuntimeFeatureConfig,
     tool_registry: GlobalToolRegistry,
     plugin_registry: PluginRegistry,
-    mcp_state: Option<Arc<Mutex<RuntimeMcpState>>>,
-}
-
-struct RuntimeMcpState {
-    runtime: tokio::runtime::Runtime,
-    manager: McpServerManager,
-    pending_servers: Vec<String>,
 }
 
 struct BuiltRuntime {
     runtime: Option<ConversationRuntime<AnthropicRuntimeClient, CliToolExecutor>>,
     plugin_registry: PluginRegistry,
     plugins_active: bool,
-    mcp_state: Option<Arc<Mutex<RuntimeMcpState>>>,
-    mcp_active: bool,
 }
 
 impl BuiltRuntime {
     fn new(
         runtime: ConversationRuntime<AnthropicRuntimeClient, CliToolExecutor>,
         plugin_registry: PluginRegistry,
-        mcp_state: Option<Arc<Mutex<RuntimeMcpState>>>,
     ) -> Self {
         Self {
             runtime: Some(runtime),
             plugin_registry,
             plugins_active: true,
-            mcp_state,
-            mcp_active: true,
         }
     }
 
@@ -1642,19 +1622,6 @@ impl BuiltRuntime {
         }
         Ok(())
     }
-
-    fn shutdown_mcp(&mut self) -> Result<(), Box<dyn std::error::Error>> {
-        if self.mcp_active {
-            if let Some(mcp_state) = &self.mcp_state {
-                mcp_state
-                    .lock()
-                    .unwrap_or_else(std::sync::PoisonError::into_inner)
-                    .shutdown()?;
-            }
-            self.mcp_active = false;
-        }
-        Ok(())
-    }
 }
 
 impl Deref for BuiltRuntime {
@@ -1677,284 +1644,10 @@ impl DerefMut for BuiltRuntime {
 
 impl Drop for BuiltRuntime {
     fn drop(&mut self) {
-        let _ = self.shutdown_mcp();
         let _ = self.shutdown_plugins();
     }
 }
 
-#[derive(Debug, Deserialize)]
-struct ToolSearchRequest {
-    query: String,
-    max_results: Option<usize>,
-}
-
-#[derive(Debug, Deserialize)]
-struct McpToolRequest {
-    #[serde(rename = "qualifiedName")]
-    qualified_name: Option<String>,
-    tool: Option<String>,
-    arguments: Option<serde_json::Value>,
-}
-
-#[derive(Debug, Deserialize)]
-struct ListMcpResourcesRequest {
-    server: Option<String>,
-}
-
-#[derive(Debug, Deserialize)]
-struct ReadMcpResourceRequest {
-    server: String,
-    uri: String,
-}
-
-impl RuntimeMcpState {
-    fn new(
-        runtime_config: &runtime::RuntimeConfig,
-    ) -> Result<Option<(Self, runtime::McpToolDiscoveryReport)>, Box<dyn std::error::Error>> {
-        let mut manager = McpServerManager::from_runtime_config(runtime_config);
-        if manager.server_names().is_empty() && manager.unsupported_servers().is_empty() {
-            return Ok(None);
-        }
-
-        let runtime = tokio::runtime::Runtime::new()?;
-        let discovery = runtime.block_on(manager.discover_tools_best_effort());
-        let pending_servers = discovery
-            .failed_servers
-            .iter()
-            .map(|failure| failure.server_name.clone())
-            .chain(
-                discovery
-                    .unsupported_servers
-                    .iter()
-                    .map(|server| server.server_name.clone()),
-            )
-            .collect::<BTreeSet<_>>()
-            .into_iter()
-            .collect::<Vec<_>>();
-
-        Ok(Some((
-            Self {
-                runtime,
-                manager,
-                pending_servers,
-            },
-            discovery,
-        )))
-    }
-
-    fn shutdown(&mut self) -> Result<(), Box<dyn std::error::Error>> {
-        self.runtime.block_on(self.manager.shutdown())?;
-        Ok(())
-    }
-
-    fn pending_servers(&self) -> Option<Vec<String>> {
-        (!self.pending_servers.is_empty()).then(|| self.pending_servers.clone())
-    }
-
-    fn server_names(&self) -> Vec<String> {
-        self.manager.server_names()
-    }
-
-    fn call_tool(
-        &mut self,
-        qualified_tool_name: &str,
-        arguments: Option<serde_json::Value>,
-    ) -> Result<String, ToolError> {
-        let response = self
-            .runtime
-            .block_on(self.manager.call_tool(qualified_tool_name, arguments))
-            .map_err(|error| ToolError::new(error.to_string()))?;
-        if let Some(error) = response.error {
-            return Err(ToolError::new(format!(
-                "MCP tool `{qualified_tool_name}` returned JSON-RPC error: {} ({})",
-                error.message, error.code
-            )));
-        }
-
-        let result = response.result.ok_or_else(|| {
-            ToolError::new(format!(
-                "MCP tool `{qualified_tool_name}` returned no result payload"
-            ))
-        })?;
-        serde_json::to_string_pretty(&result).map_err(|error| ToolError::new(error.to_string()))
-    }
-
-    fn list_resources_for_server(&mut self, server_name: &str) -> Result<String, ToolError> {
-        let result = self
-            .runtime
-            .block_on(self.manager.list_resources(server_name))
-            .map_err(|error| ToolError::new(error.to_string()))?;
-        serde_json::to_string_pretty(&json!({
-            "server": server_name,
-            "resources": result.resources,
-        }))
-        .map_err(|error| ToolError::new(error.to_string()))
-    }
-
-    fn list_resources_for_all_servers(&mut self) -> Result<String, ToolError> {
-        let mut resources = Vec::new();
-        let mut failures = Vec::new();
-
-        for server_name in self.server_names() {
-            match self
-                .runtime
-                .block_on(self.manager.list_resources(&server_name))
-            {
-                Ok(result) => resources.push(json!({
-                    "server": server_name,
-                    "resources": result.resources,
-                })),
-                Err(error) => failures.push(json!({
-                    "server": server_name,
-                    "error": error.to_string(),
-                })),
-            }
-        }
-
-        if resources.is_empty() && !failures.is_empty() {
-            let message = failures
-                .iter()
-                .filter_map(|failure| failure.get("error").and_then(serde_json::Value::as_str))
-                .collect::<Vec<_>>()
-                .join("; ");
-            return Err(ToolError::new(message));
-        }
-
-        serde_json::to_string_pretty(&json!({
-            "resources": resources,
-            "failures": failures,
-        }))
-        .map_err(|error| ToolError::new(error.to_string()))
-    }
-
-    fn read_resource(&mut self, server_name: &str, uri: &str) -> Result<String, ToolError> {
-        let result = self
-            .runtime
-            .block_on(self.manager.read_resource(server_name, uri))
-            .map_err(|error| ToolError::new(error.to_string()))?;
-        serde_json::to_string_pretty(&json!({
-            "server": server_name,
-            "contents": result.contents,
-        }))
-        .map_err(|error| ToolError::new(error.to_string()))
-    }
-}
-
-fn build_runtime_mcp_state(
-    runtime_config: &runtime::RuntimeConfig,
-) -> Result<
-    (
-        Option<Arc<Mutex<RuntimeMcpState>>>,
-        Vec<RuntimeToolDefinition>,
-    ),
-    Box<dyn std::error::Error>,
-> {
-    let Some((mcp_state, discovery)) = RuntimeMcpState::new(runtime_config)? else {
-        return Ok((None, Vec::new()));
-    };
-
-    let mut runtime_tools = discovery
-        .tools
-        .iter()
-        .map(mcp_runtime_tool_definition)
-        .collect::<Vec<_>>();
-    if !mcp_state.server_names().is_empty() {
-        runtime_tools.extend(mcp_wrapper_tool_definitions());
-    }
-
-    Ok((Some(Arc::new(Mutex::new(mcp_state))), runtime_tools))
-}
-
-fn mcp_runtime_tool_definition(tool: &runtime::ManagedMcpTool) -> RuntimeToolDefinition {
-    RuntimeToolDefinition {
-        name: tool.qualified_name.clone(),
-        description: Some(
-            tool.tool
-                .description
-                .clone()
-                .unwrap_or_else(|| format!("Invoke MCP tool `{}`.", tool.qualified_name)),
-        ),
-        input_schema: tool
-            .tool
-            .input_schema
-            .clone()
-            .unwrap_or_else(|| json!({ "type": "object", "additionalProperties": true })),
-        required_permission: permission_mode_for_mcp_tool(&tool.tool),
-    }
-}
-
-fn mcp_wrapper_tool_definitions() -> Vec<RuntimeToolDefinition> {
-    vec![
-        RuntimeToolDefinition {
-            name: "MCPTool".to_string(),
-            description: Some(
-                "Call a configured MCP tool by its qualified name and JSON arguments.".to_string(),
-            ),
-            input_schema: json!({
-                "type": "object",
-                "properties": {
-                    "qualifiedName": { "type": "string" },
-                    "arguments": {}
-                },
-                "required": ["qualifiedName"],
-                "additionalProperties": false
-            }),
-            required_permission: PermissionMode::DangerFullAccess,
-        },
-        RuntimeToolDefinition {
-            name: "ListMcpResourcesTool".to_string(),
-            description: Some(
-                "List MCP resources from one configured server or from every connected server."
-                    .to_string(),
-            ),
-            input_schema: json!({
-                "type": "object",
-                "properties": {
-                    "server": { "type": "string" }
-                },
-                "additionalProperties": false
-            }),
-            required_permission: PermissionMode::ReadOnly,
-        },
-        RuntimeToolDefinition {
-            name: "ReadMcpResourceTool".to_string(),
-            description: Some("Read a specific MCP resource from a configured server.".to_string()),
-            input_schema: json!({
-                "type": "object",
-                "properties": {
-                    "server": { "type": "string" },
-                    "uri": { "type": "string" }
-                },
-                "required": ["server", "uri"],
-                "additionalProperties": false
-            }),
-            required_permission: PermissionMode::ReadOnly,
-        },
-    ]
-}
-
-fn permission_mode_for_mcp_tool(tool: &McpTool) -> PermissionMode {
-    let read_only = mcp_annotation_flag(tool, "readOnlyHint");
-    let destructive = mcp_annotation_flag(tool, "destructiveHint");
-    let open_world = mcp_annotation_flag(tool, "openWorldHint");
-
-    if read_only && !destructive && !open_world {
-        PermissionMode::ReadOnly
-    } else if destructive || open_world {
-        PermissionMode::DangerFullAccess
-    } else {
-        PermissionMode::WorkspaceWrite
-    }
-}
-
-fn mcp_annotation_flag(tool: &McpTool, key: &str) -> bool {
-    tool.annotations
-        .as_ref()
-        .and_then(|annotations| annotations.get(key))
-        .and_then(serde_json::Value::as_bool)
-        .unwrap_or(false)
-}
-
 struct HookAbortMonitor {
     stop_tx: Option<Sender<()>>,
     join_handle: Option<JoinHandle<()>>,
@@ -2205,13 +1898,7 @@ impl LiveCli {
                     "output_tokens": summary.usage.output_tokens,
                     "cache_creation_input_tokens": summary.usage.cache_creation_input_tokens,
                     "cache_read_input_tokens": summary.usage.cache_read_input_tokens,
-                },
-                "estimated_cost": format_usd(
-                    summary.usage.estimate_cost_usd_with_pricing(
-                        pricing_for_model(&self.model)
-                            .unwrap_or_else(runtime::ModelPricing::default_sonnet_tier)
-                    ).total_cost_usd()
-                )
+                }
             })
         );
         Ok(())
@@ -2252,7 +1939,7 @@ impl LiveCli {
                 false
             }
             SlashCommand::Teleport { target } => {
-                Self::run_teleport(target.as_deref())?;
+                self.run_teleport(target.as_deref())?;
                 false
             }
             SlashCommand::DebugToolCall => {
@@ -2820,7 +2507,8 @@ impl LiveCli {
         Ok(())
     }
 
-    fn run_teleport(target: Option<&str>) -> Result<(), Box<dyn std::error::Error>> {
+    #[allow(clippy::unused_self)]
+    fn run_teleport(&self, target: Option<&str>) -> Result<(), Box<dyn std::error::Error>> {
         let Some(target) = target.map(str::trim).filter(|value| !value.is_empty()) else {
             println!("Usage: /teleport <symbol-or-path>");
             return Ok(());
@@ -3867,14 +3555,11 @@ fn build_runtime_plugin_state_with_loader(
         .feature_config()
         .clone()
         .with_hooks(runtime_config.hooks().merged(&plugin_hook_config));
-    let (mcp_state, runtime_tools) = build_runtime_mcp_state(runtime_config)?;
-    let tool_registry = GlobalToolRegistry::with_plugin_tools(plugin_registry.aggregated_tools()?)?
-        .with_runtime_tools(runtime_tools)?;
+    let tool_registry = GlobalToolRegistry::with_plugin_tools(plugin_registry.aggregated_tools()?)?;
     Ok(RuntimePluginState {
         feature_config,
         tool_registry,
         plugin_registry,
-        mcp_state,
     })
 }
 
@@ -4296,11 +3981,8 @@ fn build_runtime_with_plugin_state(
         feature_config,
         tool_registry,
         plugin_registry,
-        mcp_state,
     } = runtime_plugin_state;
     plugin_registry.initialize()?;
-    let policy = permission_policy(permission_mode, &feature_config, &tool_registry)
-        .map_err(std::io::Error::other)?;
     let mut runtime = ConversationRuntime::new_with_features(
         session,
         AnthropicRuntimeClient::new(
@@ -4312,20 +3994,16 @@ fn build_runtime_with_plugin_state(
             tool_registry.clone(),
             progress_reporter,
         )?,
-        CliToolExecutor::new(
-            allowed_tools.clone(),
-            emit_output,
-            tool_registry.clone(),
-            mcp_state.clone(),
-        ),
-        policy,
+        CliToolExecutor::new(allowed_tools.clone(), emit_output, tool_registry.clone()),
+        permission_policy(permission_mode, &feature_config, &tool_registry)
+            .map_err(std::io::Error::other)?,
         system_prompt,
         &feature_config,
     );
     if emit_output {
         runtime = runtime.with_hook_progress_reporter(Box::new(CliHookProgressReporter));
     }
-    Ok(BuiltRuntime::new(runtime, plugin_registry, mcp_state))
+    Ok(BuiltRuntime::new(runtime, plugin_registry))
 }
 
 struct CliHookProgressReporter;
@@ -5264,7 +4942,6 @@ struct CliToolExecutor {
     emit_output: bool,
     allowed_tools: Option<AllowedToolSet>,
     tool_registry: GlobalToolRegistry,
-    mcp_state: Option<Arc<Mutex<RuntimeMcpState>>>,
 }
 
 impl CliToolExecutor {
@@ -5272,72 +4949,12 @@ impl CliToolExecutor {
         allowed_tools: Option<AllowedToolSet>,
         emit_output: bool,
         tool_registry: GlobalToolRegistry,
-        mcp_state: Option<Arc<Mutex<RuntimeMcpState>>>,
     ) -> Self {
         Self {
             renderer: TerminalRenderer::new(),
             emit_output,
             allowed_tools,
             tool_registry,
-            mcp_state,
-        }
-    }
-
-    fn execute_search_tool(&self, value: serde_json::Value) -> Result<String, ToolError> {
-        let input: ToolSearchRequest = serde_json::from_value(value)
-            .map_err(|error| ToolError::new(format!("invalid tool input JSON: {error}")))?;
-        let pending_mcp_servers = self.mcp_state.as_ref().and_then(|state| {
-            state
-                .lock()
-                .unwrap_or_else(std::sync::PoisonError::into_inner)
-                .pending_servers()
-        });
-        serde_json::to_string_pretty(&self.tool_registry.search(
-            &input.query,
-            input.max_results.unwrap_or(5),
-            pending_mcp_servers,
-        ))
-        .map_err(|error| ToolError::new(error.to_string()))
-    }
-
-    fn execute_runtime_tool(
-        &self,
-        tool_name: &str,
-        value: serde_json::Value,
-    ) -> Result<String, ToolError> {
-        let Some(mcp_state) = &self.mcp_state else {
-            return Err(ToolError::new(format!(
-                "runtime tool `{tool_name}` is unavailable without configured MCP servers"
-            )));
-        };
-        let mut mcp_state = mcp_state
-            .lock()
-            .unwrap_or_else(std::sync::PoisonError::into_inner);
-
-        match tool_name {
-            "MCPTool" => {
-                let input: McpToolRequest = serde_json::from_value(value)
-                    .map_err(|error| ToolError::new(format!("invalid tool input JSON: {error}")))?;
-                let qualified_name = input
-                    .qualified_name
-                    .or(input.tool)
-                    .ok_or_else(|| ToolError::new("missing required field `qualifiedName`"))?;
-                mcp_state.call_tool(&qualified_name, input.arguments)
-            }
-            "ListMcpResourcesTool" => {
-                let input: ListMcpResourcesRequest = serde_json::from_value(value)
-                    .map_err(|error| ToolError::new(format!("invalid tool input JSON: {error}")))?;
-                match input.server {
-                    Some(server_name) => mcp_state.list_resources_for_server(&server_name),
-                    None => mcp_state.list_resources_for_all_servers(),
-                }
-            }
-            "ReadMcpResourceTool" => {
-                let input: ReadMcpResourceRequest = serde_json::from_value(value)
-                    .map_err(|error| ToolError::new(format!("invalid tool input JSON: {error}")))?;
-                mcp_state.read_resource(&input.server, &input.uri)
-            }
-            _ => mcp_state.call_tool(tool_name, Some(value)),
         }
     }
 }
@@ -5355,16 +4972,7 @@ impl ToolExecutor for CliToolExecutor {
         }
         let value = serde_json::from_str(input)
             .map_err(|error| ToolError::new(format!("invalid tool input JSON: {error}")))?;
-        let result = if tool_name == "ToolSearch" {
-            self.execute_search_tool(value)
-        } else if self.tool_registry.has_runtime_tool(tool_name) {
-            self.execute_runtime_tool(tool_name, value)
-        } else {
-            self.tool_registry
-                .execute(tool_name, &value)
-                .map_err(ToolError::new)
-        };
-        match result {
+        match self.tool_registry.execute(tool_name, &value) {
             Ok(output) => {
                 if self.emit_output {
                     let markdown = format_tool_result(tool_name, &output, false);
@@ -5376,12 +4984,12 @@ impl ToolExecutor for CliToolExecutor {
             }
             Err(error) => {
                 if self.emit_output {
-                    let markdown = format_tool_result(tool_name, &error.to_string(), true);
+                    let markdown = format_tool_result(tool_name, &error, true);
                     self.renderer
                         .stream_markdown(&markdown, &mut io::stdout())
                         .map_err(|stream_error| ToolError::new(stream_error.to_string()))?;
                 }
-                Err(error)
+                Err(ToolError::new(error))
             }
         }
     }
@@ -5580,13 +5188,12 @@ mod tests {
         format_unknown_slash_command_message, normalize_permission_mode, parse_args,
         parse_git_status_branch, parse_git_status_metadata_for, parse_git_workspace_summary,
         permission_policy, print_help_to, push_output_block, render_config_report,
-        render_diff_report, render_diff_report_for, render_memory_report, render_repl_help, render_resume_usage,
+        render_diff_report, render_memory_report, render_repl_help, render_resume_usage,
         resolve_model_alias, resolve_session_reference, response_to_events,
         resume_supported_slash_commands, run_resume_command,
         slash_command_completion_candidates_with_sessions, status_context, validate_no_args,
-        write_mcp_server_fixture, CliAction, CliOutputFormat, CliToolExecutor, GitWorkspaceSummary,
-        InternalPromptProgressEvent, InternalPromptProgressState, LiveCli, SlashCommand,
-        StatusUsage, DEFAULT_MODEL,
+        CliAction, CliOutputFormat, GitWorkspaceSummary, InternalPromptProgressEvent,
+        InternalPromptProgressState, LiveCli, SlashCommand, StatusUsage, DEFAULT_MODEL,
     };
     use api::{MessageResponse, OutputContentBlock, Usage};
     use plugins::{
@@ -5594,7 +5201,7 @@ mod tests {
     };
     use runtime::{
         AssistantEvent, ConfigLoader, ContentBlock, ConversationMessage, MessageRole,
-        PermissionMode, Session, ToolExecutor,
+        PermissionMode, Session,
     };
     use serde_json::json;
     use std::fs;
@@ -5708,8 +5315,6 @@ mod tests {
     }
     #[test]
     fn defaults_to_repl_when_no_args() {
-        let _guard = env_lock();
-        std::env::remove_var("RUSTY_CLAUDE_PERMISSION_MODE");
         assert_eq!(
             parse_args(&[]).expect("args should parse"),
             CliAction::Repl {
@@ -5790,8 +5395,6 @@ mod tests {
 
     #[test]
     fn parses_prompt_subcommand() {
-        let _guard = env_lock();
-        std::env::remove_var("RUSTY_CLAUDE_PERMISSION_MODE");
         let args = vec![
             "prompt".to_string(),
             "hello".to_string(),
@@ -5811,8 +5414,6 @@ mod tests {
 
     #[test]
     fn parses_bare_prompt_and_json_output_flag() {
-        let _guard = env_lock();
-        std::env::remove_var("RUSTY_CLAUDE_PERMISSION_MODE");
         let args = vec![
             "--output-format=json".to_string(),
             "--model".to_string(),
@@ -5834,8 +5435,6 @@ mod tests {
 
     #[test]
     fn resolves_model_aliases_in_args() {
-        let _guard = env_lock();
-        std::env::remove_var("RUSTY_CLAUDE_PERMISSION_MODE");
         let args = vec![
             "--model".to_string(),
             "opus".to_string(),
@@ -5889,8 +5488,6 @@ mod tests {
 
     #[test]
     fn parses_allowed_tools_flags_with_aliases_and_lists() {
-        let _guard = env_lock();
-        std::env::remove_var("RUSTY_CLAUDE_PERMISSION_MODE");
         let args = vec![
             "--allowedTools".to_string(),
             "read,glob".to_string(),
@@ -5973,8 +5570,6 @@ mod tests {
 
     #[test]
     fn parses_single_word_command_aliases_without_falling_back_to_prompt_mode() {
-        let _guard = env_lock();
-        std::env::remove_var("RUSTY_CLAUDE_PERMISSION_MODE");
         assert_eq!(
             parse_args(&["help".to_string()]).expect("help should parse"),
             CliAction::Help
@@ -6005,8 +5600,6 @@ mod tests {
 
     #[test]
     fn multi_word_prompt_still_uses_shorthand_prompt_mode() {
-        let _guard = env_lock();
-        std::env::remove_var("RUSTY_CLAUDE_PERMISSION_MODE");
         assert_eq!(
             parse_args(&["help".to_string(), "me".to_string(), "debug".to_string()])
                 .expect("prompt shorthand should still work"),
@@ -6317,16 +5910,50 @@ mod tests {
             .into_iter()
             .map(|spec| spec.name)
             .collect::<Vec<_>>();
-        // Now with 135+ slash commands, verify minimum resume support
-        assert!(
-            names.len() >= 39,
-            "expected at least 39 resume-supported commands, got {}",
-            names.len()
+        assert_eq!(
+            names,
+            vec![
+                "help",
+                "status",
+                "sandbox",
+                "compact",
+                "clear",
+                "cost",
+                "config",
+                "mcp",
+                "memory",
+                "init",
+                "diff",
+                "version",
+                "export",
+                "agents",
+                "skills",
+                "doctor",
+                "plan",
+                "tasks",
+                "theme",
+                "vim",
+                "usage",
+                "stats",
+                "copy",
+                "hooks",
+                "files",
+                "context",
+                "color",
+                "effort",
+                "fast",
+                "summary",
+                "tag",
+                "brief",
+                "advisor",
+                "stickers",
+                "insights",
+                "thinkback",
+                "keybindings",
+                "privacy-settings",
+                "output-style",
+            ]
         );
-        // Verify key resume commands still exist
-        assert!(names.contains(&"help"));
-        assert!(names.contains(&"status"));
-        assert!(names.contains(&"compact"));
     }
 
     #[test]
@@ -6632,7 +6259,9 @@ UU conflicted.rs",
         git(&["add", "tracked.txt"], &root);
         git(&["commit", "-m", "init", "--quiet"], &root);
 
-        let report = render_diff_report_for(&root).expect("diff report should render");
+        let report = with_current_dir(&root, || {
+            render_diff_report().expect("diff report should render")
+        });
         assert!(report.contains("clean working tree"));
 
         fs::remove_dir_all(root).expect("cleanup temp dir");
@@ -6655,7 +6284,9 @@ UU conflicted.rs",
         fs::write(root.join("tracked.txt"), "hello\nstaged\nunstaged\n")
             .expect("update file twice");
 
-        let report = render_diff_report_for(&root).expect("diff report should render");
+        let report = with_current_dir(&root, || {
+            render_diff_report().expect("diff report should render")
+        });
         assert!(report.contains("Staged changes:"));
         assert!(report.contains("Unstaged changes:"));
         assert!(report.contains("tracked.txt"));
@@ -6680,7 +6311,9 @@ UU conflicted.rs",
         fs::write(root.join("ignored.txt"), "secret\n").expect("write ignored file");
         fs::write(root.join("tracked.txt"), "hello\nworld\n").expect("write tracked change");
 
-        let report = render_diff_report_for(&root).expect("diff report should render");
+        let report = with_current_dir(&root, || {
+            render_diff_report().expect("diff report should render")
+        });
         assert!(report.contains("tracked.txt"));
         assert!(!report.contains("+++ b/ignored.txt"));
         assert!(!report.contains("+++ b/.omx/state.json"));
@@ -6900,11 +6533,7 @@ UU conflicted.rs",
 
     #[test]
     fn init_template_mentions_detected_rust_workspace() {
-        let _guard = cwd_lock()
-            .lock()
-            .unwrap_or_else(std::sync::PoisonError::into_inner);
-        let workspace_root = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../..");
-        let rendered = crate::init::render_init_claude_md(&workspace_root);
+        let rendered = crate::init::render_init_claude_md(std::path::Path::new("."));
         assert!(rendered.contains("# CLAUDE.md"));
         assert!(rendered.contains("cargo clippy --workspace --all-targets -- -D warnings"));
     }
@@ -7295,111 +6924,6 @@ UU conflicted.rs",
         let _ = fs::remove_dir_all(source_root);
     }
 
-    #[test]
-    fn build_runtime_plugin_state_discovers_mcp_tools_and_surfaces_pending_servers() {
-        let config_home = temp_dir();
-        let workspace = temp_dir();
-        fs::create_dir_all(&config_home).expect("config home");
-        fs::create_dir_all(&workspace).expect("workspace");
-        let script_path = workspace.join("fixture-mcp.py");
-        write_mcp_server_fixture(&script_path);
-        fs::write(
-            config_home.join("settings.json"),
-            format!(
-                r#"{{
-                  "mcpServers": {{
-                    "alpha": {{
-                      "command": "python3",
-                      "args": ["{}"]
-                    }},
-                    "broken": {{
-                      "command": "python3",
-                      "args": ["-c", "import sys; sys.exit(0)"]
-                    }}
-                  }}
-                }}"#,
-                script_path.to_string_lossy()
-            ),
-        )
-        .expect("write mcp settings");
-
-        let loader = ConfigLoader::new(&workspace, &config_home);
-        let runtime_config = loader.load().expect("runtime config should load");
-        let state = build_runtime_plugin_state_with_loader(&workspace, &loader, &runtime_config)
-            .expect("runtime plugin state should load");
-
-        let allowed = state
-            .tool_registry
-            .normalize_allowed_tools(&["mcp__alpha__echo".to_string(), "MCPTool".to_string()])
-            .expect("mcp tools should be allow-listable")
-            .expect("allow-list should exist");
-        assert!(allowed.contains("mcp__alpha__echo"));
-        assert!(allowed.contains("MCPTool"));
-
-        let mut executor = CliToolExecutor::new(
-            None,
-            false,
-            state.tool_registry.clone(),
-            state.mcp_state.clone(),
-        );
-
-        let tool_output = executor
-            .execute("mcp__alpha__echo", r#"{"text":"hello"}"#)
-            .expect("discovered mcp tool should execute");
-        let tool_json: serde_json::Value =
-            serde_json::from_str(&tool_output).expect("tool output should be json");
-        assert_eq!(tool_json["structuredContent"]["echoed"], "hello");
-
-        let wrapped_output = executor
-            .execute(
-                "MCPTool",
-                r#"{"qualifiedName":"mcp__alpha__echo","arguments":{"text":"wrapped"}}"#,
-            )
-            .expect("generic mcp wrapper should execute");
-        let wrapped_json: serde_json::Value =
-            serde_json::from_str(&wrapped_output).expect("wrapped output should be json");
-        assert_eq!(wrapped_json["structuredContent"]["echoed"], "wrapped");
-
-        let search_output = executor
-            .execute("ToolSearch", r#"{"query":"alpha echo","max_results":5}"#)
-            .expect("tool search should execute");
-        let search_json: serde_json::Value =
-            serde_json::from_str(&search_output).expect("search output should be json");
-        assert_eq!(search_json["matches"][0], "mcp__alpha__echo");
-        assert_eq!(search_json["pending_mcp_servers"][0], "broken");
-
-        let listed = executor
-            .execute("ListMcpResourcesTool", r#"{"server":"alpha"}"#)
-            .expect("resources should list");
-        let listed_json: serde_json::Value =
-            serde_json::from_str(&listed).expect("resource output should be json");
-        assert_eq!(listed_json["resources"][0]["uri"], "file://guide.txt");
-
-        let read = executor
-            .execute(
-                "ReadMcpResourceTool",
-                r#"{"server":"alpha","uri":"file://guide.txt"}"#,
-            )
-            .expect("resource should read");
-        let read_json: serde_json::Value =
-            serde_json::from_str(&read).expect("resource read output should be json");
-        assert_eq!(
-            read_json["contents"][0]["text"],
-            "contents for file://guide.txt"
-        );
-
-        if let Some(mcp_state) = state.mcp_state {
-            mcp_state
-                .lock()
-                .unwrap_or_else(std::sync::PoisonError::into_inner)
-                .shutdown()
-                .expect("mcp shutdown should succeed");
-        }
-
-        let _ = fs::remove_dir_all(config_home);
-        let _ = fs::remove_dir_all(workspace);
-    }
-
     #[test]
     fn build_runtime_runs_plugin_lifecycle_init_and_shutdown() {
         let config_home = temp_dir();
@@ -7458,105 +6982,6 @@ UU conflicted.rs",
     }
 }
 
-fn write_mcp_server_fixture(script_path: &Path) {
-    let script = [
-            "#!/usr/bin/env python3",
-            "import json, sys",
-            "",
-            "def read_message():",
-            "    header = b''",
-            r"    while not header.endswith(b'\r\n\r\n'):",
-            "        chunk = sys.stdin.buffer.read(1)",
-            "        if not chunk:",
-            "            return None",
-            "        header += chunk",
-            "    length = 0",
-            r"    for line in header.decode().split('\r\n'):",
-            r"        if line.lower().startswith('content-length:'):",
-            "            length = int(line.split(':', 1)[1].strip())",
-            "    payload = sys.stdin.buffer.read(length)",
-            "    return json.loads(payload.decode())",
-            "",
-            "def send_message(message):",
-            "    payload = json.dumps(message).encode()",
-            r"    sys.stdout.buffer.write(f'Content-Length: {len(payload)}\r\n\r\n'.encode() + payload)",
-            "    sys.stdout.buffer.flush()",
-            "",
-            "while True:",
-            "    request = read_message()",
-            "    if request is None:",
-            "        break",
-            "    method = request['method']",
-            "    if method == 'initialize':",
-            "        send_message({",
-            "            'jsonrpc': '2.0',",
-            "            'id': request['id'],",
-            "            'result': {",
-            "                'protocolVersion': request['params']['protocolVersion'],",
-            "                'capabilities': {'tools': {}, 'resources': {}},",
-            "                'serverInfo': {'name': 'fixture', 'version': '1.0.0'}",
-            "            }",
-            "        })",
-            "    elif method == 'tools/list':",
-            "        send_message({",
-            "            'jsonrpc': '2.0',",
-            "            'id': request['id'],",
-            "            'result': {",
-            "                'tools': [",
-            "                    {",
-            "                        'name': 'echo',",
-            "                        'description': 'Echo from MCP fixture',",
-            "                        'inputSchema': {",
-            "                            'type': 'object',",
-            "                            'properties': {'text': {'type': 'string'}},",
-            "                            'required': ['text'],",
-            "                            'additionalProperties': False",
-            "                        },",
-            "                        'annotations': {'readOnlyHint': True}",
-            "                    }",
-            "                ]",
-            "            }",
-            "        })",
-            "    elif method == 'tools/call':",
-            "        args = request['params'].get('arguments') or {}",
-            "        send_message({",
-            "            'jsonrpc': '2.0',",
-            "            'id': request['id'],",
-            "            'result': {",
-            "                'content': [{'type': 'text', 'text': f\"echo:{args.get('text', '')}\"}],",
-            "                'structuredContent': {'echoed': args.get('text', '')},",
-            "                'isError': False",
-            "            }",
-            "        })",
-            "    elif method == 'resources/list':",
-            "        send_message({",
-            "            'jsonrpc': '2.0',",
-            "            'id': request['id'],",
-            "            'result': {",
-            "                'resources': [{'uri': 'file://guide.txt', 'name': 'guide', 'mimeType': 'text/plain'}]",
-            "            }",
-            "        })",
-            "    elif method == 'resources/read':",
-            "        uri = request['params']['uri']",
-            "        send_message({",
-            "            'jsonrpc': '2.0',",
-            "            'id': request['id'],",
-            "            'result': {",
-            "                'contents': [{'uri': uri, 'mimeType': 'text/plain', 'text': f'contents for {uri}'}]",
-            "            }",
-            "        })",
-            "    else:",
-            "        send_message({",
-            "            'jsonrpc': '2.0',",
-            "            'id': request['id'],",
-            "            'error': {'code': -32601, 'message': method}",
-            "        })",
-            "",
-        ]
-        .join("\n");
-    fs::write(script_path, script).expect("mcp fixture script should write");
-}
-
 #[cfg(test)]
 mod sandbox_report_tests {
     use super::{format_sandbox_report, HookAbortMonitor};

rust/crates/rusty-claude-cli/tests/mock_parity_harness.rs

@@ -35,8 +35,6 @@ fn clean_env_cli_reaches_mock_anthropic_service_across_scripted_parity_scenarios
             stdin: None,
             prepare: prepare_noop,
             assert: assert_streaming_text,
-            extra_env: None,
-            resume_session: None,
         },
         ScenarioCase {
             name: "read_file_roundtrip",
@@ -45,8 +43,6 @@ fn clean_env_cli_reaches_mock_anthropic_service_across_scripted_parity_scenarios
             stdin: None,
             prepare: prepare_read_fixture,
             assert: assert_read_file_roundtrip,
-            extra_env: None,
-            resume_session: None,
         },
         ScenarioCase {
             name: "grep_chunk_assembly",
@@ -55,8 +51,6 @@ fn clean_env_cli_reaches_mock_anthropic_service_across_scripted_parity_scenarios
             stdin: None,
             prepare: prepare_grep_fixture,
             assert: assert_grep_chunk_assembly,
-            extra_env: None,
-            resume_session: None,
         },
         ScenarioCase {
             name: "write_file_allowed",
@@ -65,8 +59,6 @@ fn clean_env_cli_reaches_mock_anthropic_service_across_scripted_parity_scenarios
             stdin: None,
             prepare: prepare_noop,
             assert: assert_write_file_allowed,
-            extra_env: None,
-            resume_session: None,
         },
         ScenarioCase {
             name: "write_file_denied",
@@ -75,8 +67,6 @@ fn clean_env_cli_reaches_mock_anthropic_service_across_scripted_parity_scenarios
             stdin: None,
             prepare: prepare_noop,
             assert: assert_write_file_denied,
-            extra_env: None,
-            resume_session: None,
         },
         ScenarioCase {
             name: "multi_tool_turn_roundtrip",
@@ -85,8 +75,6 @@ fn clean_env_cli_reaches_mock_anthropic_service_across_scripted_parity_scenarios
             stdin: None,
             prepare: prepare_multi_tool_fixture,
             assert: assert_multi_tool_turn_roundtrip,
-            extra_env: None,
-            resume_session: None,
         },
         ScenarioCase {
             name: "bash_stdout_roundtrip",
@@ -95,8 +83,6 @@ fn clean_env_cli_reaches_mock_anthropic_service_across_scripted_parity_scenarios
             stdin: None,
             prepare: prepare_noop,
             assert: assert_bash_stdout_roundtrip,
-            extra_env: None,
-            resume_session: None,
         },
         ScenarioCase {
             name: "bash_permission_prompt_approved",
@@ -105,8 +91,6 @@ fn clean_env_cli_reaches_mock_anthropic_service_across_scripted_parity_scenarios
             stdin: Some("y\n"),
             prepare: prepare_noop,
             assert: assert_bash_permission_prompt_approved,
-            extra_env: None,
-            resume_session: None,
         },
         ScenarioCase {
             name: "bash_permission_prompt_denied",
@@ -115,8 +99,6 @@ fn clean_env_cli_reaches_mock_anthropic_service_across_scripted_parity_scenarios
             stdin: Some("n\n"),
             prepare: prepare_noop,
             assert: assert_bash_permission_prompt_denied,
-            extra_env: None,
-            resume_session: None,
         },
         ScenarioCase {
             name: "plugin_tool_roundtrip",
@@ -125,28 +107,6 @@ fn clean_env_cli_reaches_mock_anthropic_service_across_scripted_parity_scenarios
             stdin: None,
             prepare: prepare_plugin_fixture,
             assert: assert_plugin_tool_roundtrip,
-            extra_env: None,
-            resume_session: None,
-        },
-        ScenarioCase {
-            name: "auto_compact_triggered",
-            permission_mode: "read-only",
-            allowed_tools: None,
-            stdin: None,
-            prepare: prepare_noop,
-            assert: assert_auto_compact_triggered,
-            extra_env: None,
-            resume_session: None,
-        },
-        ScenarioCase {
-            name: "token_cost_reporting",
-            permission_mode: "read-only",
-            allowed_tools: None,
-            stdin: None,
-            prepare: prepare_noop,
-            assert: assert_token_cost_reporting,
-            extra_env: None,
-            resume_session: None,
         },
     ];
 
@@ -185,8 +145,8 @@ fn clean_env_cli_reaches_mock_anthropic_service_across_scripted_parity_scenarios
     let captured = runtime.block_on(server.captured_requests());
     assert_eq!(
         captured.len(),
-        21,
-        "twelve scenarios should produce twenty-one requests"
+        19,
+        "ten scenarios should produce nineteen requests"
     );
     assert!(captured
         .iter()
@@ -219,8 +179,6 @@ fn clean_env_cli_reaches_mock_anthropic_service_across_scripted_parity_scenarios
             "bash_permission_prompt_denied",
             "plugin_tool_roundtrip",
             "plugin_tool_roundtrip",
-            "auto_compact_triggered",
-            "token_cost_reporting",
         ]
     );
 
@@ -247,8 +205,6 @@ struct ScenarioCase {
     stdin: Option<&'static str>,
     prepare: fn(&HarnessWorkspace),
     assert: fn(&HarnessWorkspace, &ScenarioRun),
-    extra_env: Option<(&'static str, &'static str)>,
-    resume_session: Option<&'static str>,
 }
 
 struct HarnessWorkspace {
@@ -322,12 +278,6 @@ fn run_case(case: ScenarioCase, workspace: &HarnessWorkspace, base_url: &str) ->
     if let Some(allowed_tools) = case.allowed_tools {
         command.args(["--allowedTools", allowed_tools]);
     }
-    if let Some((key, value)) = case.extra_env {
-        command.env(key, value);
-    }
-    if let Some(session_id) = case.resume_session {
-        command.args(["--resume", session_id]);
-    }
 
     let prompt = format!("{SCENARIO_PREFIX}{}", case.name);
     command.arg(prompt);
@@ -358,28 +308,6 @@ fn run_case(case: ScenarioCase, workspace: &HarnessWorkspace, base_url: &str) ->
     }
 }
 
-#[allow(dead_code)]
-fn prepare_auto_compact_fixture(workspace: &HarnessWorkspace) {
-    let sessions_dir = workspace.root.join(".claw").join("sessions");
-    fs::create_dir_all(&sessions_dir).expect("sessions dir should exist");
-
-    // Write a pre-seeded session with 6 messages so auto-compact can remove them
-    let session_id = "parity-auto-compact-seed";
-    let session_jsonl = r#"{"type":"session_meta","version":3,"session_id":"parity-auto-compact-seed","created_at_ms":1743724800000,"updated_at_ms":1743724800000}
-{"type":"message","message":{"role":"user","blocks":[{"type":"text","text":"step one of the parity scenario"}]}}
-{"type":"message","message":{"role":"assistant","blocks":[{"type":"text","text":"acknowledged step one"}]}}
-{"type":"message","message":{"role":"user","blocks":[{"type":"text","text":"step two of the parity scenario"}]}}
-{"type":"message","message":{"role":"assistant","blocks":[{"type":"text","text":"acknowledged step two"}]}}
-{"type":"message","message":{"role":"user","blocks":[{"type":"text","text":"step three of the parity scenario"}]}}
-{"type":"message","message":{"role":"assistant","blocks":[{"type":"text","text":"acknowledged step three"}]}}
-"#;
-    fs::write(
-        sessions_dir.join(format!("{session_id}.jsonl")),
-        session_jsonl,
-    )
-    .expect("pre-seeded session should write");
-}
-
 fn prepare_noop(_: &HarnessWorkspace) {}
 
 fn prepare_read_fixture(workspace: &HarnessWorkspace) {
@@ -681,60 +609,6 @@ fn assert_plugin_tool_roundtrip(_: &HarnessWorkspace, run: &ScenarioRun) {
         .contains("hello from plugin parity"));
 }
 
-fn assert_auto_compact_triggered(_: &HarnessWorkspace, run: &ScenarioRun) {
-    // Validates that the auto_compaction field is present in JSON output (format parity).
-    // Trigger behavior is covered by conversation::tests::auto_compacts_when_cumulative_input_threshold_is_crossed.
-    assert_eq!(run.response["iterations"], Value::from(1));
-    assert_eq!(run.response["tool_uses"], Value::Array(Vec::new()));
-    assert!(
-        run.response["message"]
-            .as_str()
-            .expect("message text")
-            .contains("auto compact parity complete."),
-        "expected auto compact message in response"
-    );
-    // auto_compaction key must be present in JSON (may be null for below-threshold sessions)
-    assert!(
-        run.response
-            .as_object()
-            .expect("response object")
-            .contains_key("auto_compaction"),
-        "auto_compaction key must be present in JSON output"
-    );
-    // Verify input_tokens field reflects the large mock token counts
-    let input_tokens = run.response["usage"]["input_tokens"]
-        .as_u64()
-        .expect("input_tokens should be present");
-    assert!(
-        input_tokens >= 50_000,
-        "input_tokens should reflect mock service value (got {input_tokens})"
-    );
-}
-
-fn assert_token_cost_reporting(_: &HarnessWorkspace, run: &ScenarioRun) {
-    assert_eq!(run.response["iterations"], Value::from(1));
-    assert!(run.response["message"]
-        .as_str()
-        .expect("message text")
-        .contains("token cost reporting parity complete."),);
-    let usage = &run.response["usage"];
-    assert!(
-        usage["input_tokens"].as_u64().unwrap_or(0) > 0,
-        "input_tokens should be non-zero"
-    );
-    assert!(
-        usage["output_tokens"].as_u64().unwrap_or(0) > 0,
-        "output_tokens should be non-zero"
-    );
-    assert!(
-        run.response["estimated_cost"]
-            .as_str()
-            .map(|cost| cost.starts_with('$'))
-            .unwrap_or(false),
-        "estimated_cost should be a dollar-prefixed string"
-    );
-}
-
 fn parse_json_output(stdout: &str) -> Value {
     if let Some(index) = stdout.rfind("{\"auto_compaction\"") {
         return serde_json::from_str(&stdout[index..]).unwrap_or_else(|error| {

rust/mock_parity_scenarios.json

@@ -4,7 +4,7 @@
     "category": "baseline",
     "description": "Validates streamed assistant text with no tool calls.",
     "parity_refs": [
-      "Mock parity harness \u2014 milestone 1",
+      "Mock parity harness — milestone 1",
       "Streaming response support validated by the mock parity harness"
     ]
   },
@@ -13,8 +13,8 @@
     "category": "file-tools",
     "description": "Exercises read_file tool execution and final assistant synthesis.",
     "parity_refs": [
-      "Mock parity harness \u2014 milestone 1",
-      "File tools \u2014 harness-validated flows"
+      "Mock parity harness — milestone 1",
+      "File tools — harness-validated flows"
     ]
   },
   {
@@ -22,8 +22,8 @@
     "category": "file-tools",
     "description": "Validates grep_search partial JSON chunk assembly and follow-up synthesis.",
     "parity_refs": [
-      "Mock parity harness \u2014 milestone 1",
-      "File tools \u2014 harness-validated flows"
+      "Mock parity harness — milestone 1",
+      "File tools — harness-validated flows"
     ]
   },
   {
@@ -31,8 +31,8 @@
     "category": "file-tools",
     "description": "Confirms workspace-write write_file success and filesystem side effects.",
     "parity_refs": [
-      "Mock parity harness \u2014 milestone 1",
-      "File tools \u2014 harness-validated flows"
+      "Mock parity harness — milestone 1",
+      "File tools — harness-validated flows"
     ]
   },
   {
@@ -40,7 +40,7 @@
     "category": "permissions",
     "description": "Confirms read-only mode blocks write_file with an error result.",
     "parity_refs": [
-      "Mock parity harness \u2014 milestone 1",
+      "Mock parity harness — milestone 1",
       "Permission enforcement across tool paths"
     ]
   },
@@ -49,7 +49,7 @@
     "category": "multi-tool-turns",
     "description": "Executes read_file and grep_search in the same assistant turn before the final reply.",
     "parity_refs": [
-      "Mock parity harness \u2014 milestone 2 (behavioral expansion)",
+      "Mock parity harness — milestone 2 (behavioral expansion)",
       "Multi-tool assistant turns"
     ]
   },
@@ -58,8 +58,8 @@
     "category": "bash",
     "description": "Validates bash execution and stdout roundtrip in danger-full-access mode.",
     "parity_refs": [
-      "Mock parity harness \u2014 milestone 2 (behavioral expansion)",
-      "Bash tool \u2014 upstream has 18 submodules, Rust has 1:"
+      "Mock parity harness — milestone 2 (behavioral expansion)",
+      "Bash tool — upstream has 18 submodules, Rust has 1:"
     ]
   },
   {
@@ -67,7 +67,7 @@
     "category": "permissions",
     "description": "Exercises workspace-write to bash escalation with a positive approval response.",
     "parity_refs": [
-      "Mock parity harness \u2014 milestone 2 (behavioral expansion)",
+      "Mock parity harness — milestone 2 (behavioral expansion)",
       "Permission enforcement across tool paths"
     ]
   },
@@ -76,7 +76,7 @@
     "category": "permissions",
     "description": "Exercises workspace-write to bash escalation with a denied approval response.",
     "parity_refs": [
-      "Mock parity harness \u2014 milestone 2 (behavioral expansion)",
+      "Mock parity harness — milestone 2 (behavioral expansion)",
       "Permission enforcement across tool paths"
     ]
   },
@@ -85,25 +85,8 @@
     "category": "plugin-paths",
     "description": "Loads an external plugin tool and executes it through the runtime tool registry.",
     "parity_refs": [
-      "Mock parity harness \u2014 milestone 2 (behavioral expansion)",
+      "Mock parity harness — milestone 2 (behavioral expansion)",
       "Plugin tool execution path"
     ]
-  },
-  {
-    "name": "auto_compact_triggered",
-    "category": "session-compaction",
-    "description": "Verifies auto-compact fires when cumulative input tokens exceed the configured threshold.",
-    "parity_refs": [
-      "Session compaction behavior matching",
-      "auto_compaction threshold from env"
-    ]
-  },
-  {
-    "name": "token_cost_reporting",
-    "category": "token-usage",
-    "description": "Confirms usage token counts and estimated_cost appear in JSON output.",
-    "parity_refs": [
-      "Token counting / cost tracking accuracy"
-    ]
   }
 ]

src/_archive_helper.py

@@ -1,17 +0,0 @@
-"""Shared helper for archive placeholder packages."""
-
-from __future__ import annotations
-
-import json
-from pathlib import Path
-
-
-def load_archive_metadata(package_name: str) -> dict:
-    """Load archive metadata from reference_data/subsystems/{package_name}.json."""
-    snapshot_path = (
-        Path(__file__).resolve().parent
-        / "reference_data"
-        / "subsystems"
-        / f"{package_name}.json"
-    )
-    return json.loads(snapshot_path.read_text())

src/assistant/__init__.py

@@ -2,13 +2,15 @@
 
 from __future__ import annotations
 
-from src._archive_helper import load_archive_metadata
+import json
+from pathlib import Path
 
-_SNAPSHOT = load_archive_metadata("assistant")
+SNAPSHOT_PATH = Path(__file__).resolve().parent.parent / 'reference_data' / 'subsystems' / 'assistant.json'
+_SNAPSHOT = json.loads(SNAPSHOT_PATH.read_text())
 
-ARCHIVE_NAME = _SNAPSHOT["archive_name"]
-MODULE_COUNT = _SNAPSHOT["module_count"]
-SAMPLE_FILES = tuple(_SNAPSHOT["sample_files"])
+ARCHIVE_NAME = _SNAPSHOT['archive_name']
+MODULE_COUNT = _SNAPSHOT['module_count']
+SAMPLE_FILES = tuple(_SNAPSHOT['sample_files'])
 PORTING_NOTE = f"Python placeholder package for '{ARCHIVE_NAME}' with {MODULE_COUNT} archived module references."
 
-__all__ = ["ARCHIVE_NAME", "MODULE_COUNT", "PORTING_NOTE", "SAMPLE_FILES"]
+__all__ = ['ARCHIVE_NAME', 'MODULE_COUNT', 'PORTING_NOTE', 'SAMPLE_FILES']

src/bootstrap/__init__.py

@@ -2,13 +2,15 @@
 
 from __future__ import annotations
 
-from src._archive_helper import load_archive_metadata
+import json
+from pathlib import Path
 
-_SNAPSHOT = load_archive_metadata("bootstrap")
+SNAPSHOT_PATH = Path(__file__).resolve().parent.parent / 'reference_data' / 'subsystems' / 'bootstrap.json'
+_SNAPSHOT = json.loads(SNAPSHOT_PATH.read_text())
 
-ARCHIVE_NAME = _SNAPSHOT["archive_name"]
-MODULE_COUNT = _SNAPSHOT["module_count"]
-SAMPLE_FILES = tuple(_SNAPSHOT["sample_files"])
+ARCHIVE_NAME = _SNAPSHOT['archive_name']
+MODULE_COUNT = _SNAPSHOT['module_count']
+SAMPLE_FILES = tuple(_SNAPSHOT['sample_files'])
 PORTING_NOTE = f"Python placeholder package for '{ARCHIVE_NAME}' with {MODULE_COUNT} archived module references."
 
-__all__ = ["ARCHIVE_NAME", "MODULE_COUNT", "PORTING_NOTE", "SAMPLE_FILES"]
+__all__ = ['ARCHIVE_NAME', 'MODULE_COUNT', 'PORTING_NOTE', 'SAMPLE_FILES']

src/bridge/__init__.py

@@ -2,13 +2,15 @@
 
 from __future__ import annotations
 
-from src._archive_helper import load_archive_metadata
+import json
+from pathlib import Path
 
-_SNAPSHOT = load_archive_metadata("bridge")
+SNAPSHOT_PATH = Path(__file__).resolve().parent.parent / 'reference_data' / 'subsystems' / 'bridge.json'
+_SNAPSHOT = json.loads(SNAPSHOT_PATH.read_text())
 
-ARCHIVE_NAME = _SNAPSHOT["archive_name"]
-MODULE_COUNT = _SNAPSHOT["module_count"]
-SAMPLE_FILES = tuple(_SNAPSHOT["sample_files"])
+ARCHIVE_NAME = _SNAPSHOT['archive_name']
+MODULE_COUNT = _SNAPSHOT['module_count']
+SAMPLE_FILES = tuple(_SNAPSHOT['sample_files'])
 PORTING_NOTE = f"Python placeholder package for '{ARCHIVE_NAME}' with {MODULE_COUNT} archived module references."
 
-__all__ = ["ARCHIVE_NAME", "MODULE_COUNT", "PORTING_NOTE", "SAMPLE_FILES"]
+__all__ = ['ARCHIVE_NAME', 'MODULE_COUNT', 'PORTING_NOTE', 'SAMPLE_FILES']

src/buddy/__init__.py

@@ -2,13 +2,15 @@
 
 from __future__ import annotations
 
-from src._archive_helper import load_archive_metadata
+import json
+from pathlib import Path
 
-_SNAPSHOT = load_archive_metadata("buddy")
+SNAPSHOT_PATH = Path(__file__).resolve().parent.parent / 'reference_data' / 'subsystems' / 'buddy.json'
+_SNAPSHOT = json.loads(SNAPSHOT_PATH.read_text())
 
-ARCHIVE_NAME = _SNAPSHOT["archive_name"]
-MODULE_COUNT = _SNAPSHOT["module_count"]
-SAMPLE_FILES = tuple(_SNAPSHOT["sample_files"])
+ARCHIVE_NAME = _SNAPSHOT['archive_name']
+MODULE_COUNT = _SNAPSHOT['module_count']
+SAMPLE_FILES = tuple(_SNAPSHOT['sample_files'])
 PORTING_NOTE = f"Python placeholder package for '{ARCHIVE_NAME}' with {MODULE_COUNT} archived module references."
 
-__all__ = ["ARCHIVE_NAME", "MODULE_COUNT", "PORTING_NOTE", "SAMPLE_FILES"]
+__all__ = ['ARCHIVE_NAME', 'MODULE_COUNT', 'PORTING_NOTE', 'SAMPLE_FILES']

src/cli/__init__.py

@@ -2,13 +2,15 @@
 
 from __future__ import annotations
 
-from src._archive_helper import load_archive_metadata
+import json
+from pathlib import Path
 
-_SNAPSHOT = load_archive_metadata("cli")
+SNAPSHOT_PATH = Path(__file__).resolve().parent.parent / 'reference_data' / 'subsystems' / 'cli.json'
+_SNAPSHOT = json.loads(SNAPSHOT_PATH.read_text())
 
-ARCHIVE_NAME = _SNAPSHOT["archive_name"]
-MODULE_COUNT = _SNAPSHOT["module_count"]
-SAMPLE_FILES = tuple(_SNAPSHOT["sample_files"])
+ARCHIVE_NAME = _SNAPSHOT['archive_name']
+MODULE_COUNT = _SNAPSHOT['module_count']
+SAMPLE_FILES = tuple(_SNAPSHOT['sample_files'])
 PORTING_NOTE = f"Python placeholder package for '{ARCHIVE_NAME}' with {MODULE_COUNT} archived module references."
 
-__all__ = ["ARCHIVE_NAME", "MODULE_COUNT", "PORTING_NOTE", "SAMPLE_FILES"]
+__all__ = ['ARCHIVE_NAME', 'MODULE_COUNT', 'PORTING_NOTE', 'SAMPLE_FILES']

src/components/__init__.py

@@ -2,13 +2,15 @@
 
 from __future__ import annotations
 
-from src._archive_helper import load_archive_metadata
+import json
+from pathlib import Path
 
-_SNAPSHOT = load_archive_metadata("components")
+SNAPSHOT_PATH = Path(__file__).resolve().parent.parent / 'reference_data' / 'subsystems' / 'components.json'
+_SNAPSHOT = json.loads(SNAPSHOT_PATH.read_text())
 
-ARCHIVE_NAME = _SNAPSHOT["archive_name"]
-MODULE_COUNT = _SNAPSHOT["module_count"]
-SAMPLE_FILES = tuple(_SNAPSHOT["sample_files"])
+ARCHIVE_NAME = _SNAPSHOT['archive_name']
+MODULE_COUNT = _SNAPSHOT['module_count']
+SAMPLE_FILES = tuple(_SNAPSHOT['sample_files'])
 PORTING_NOTE = f"Python placeholder package for '{ARCHIVE_NAME}' with {MODULE_COUNT} archived module references."
 
-__all__ = ["ARCHIVE_NAME", "MODULE_COUNT", "PORTING_NOTE", "SAMPLE_FILES"]
+__all__ = ['ARCHIVE_NAME', 'MODULE_COUNT', 'PORTING_NOTE', 'SAMPLE_FILES']

src/constants/__init__.py

@@ -2,13 +2,15 @@
 
 from __future__ import annotations
 
-from src._archive_helper import load_archive_metadata
+import json
+from pathlib import Path
 
-_SNAPSHOT = load_archive_metadata("constants")
+SNAPSHOT_PATH = Path(__file__).resolve().parent.parent / 'reference_data' / 'subsystems' / 'constants.json'
+_SNAPSHOT = json.loads(SNAPSHOT_PATH.read_text())
 
-ARCHIVE_NAME = _SNAPSHOT["archive_name"]
-MODULE_COUNT = _SNAPSHOT["module_count"]
-SAMPLE_FILES = tuple(_SNAPSHOT["sample_files"])
+ARCHIVE_NAME = _SNAPSHOT['archive_name']
+MODULE_COUNT = _SNAPSHOT['module_count']
+SAMPLE_FILES = tuple(_SNAPSHOT['sample_files'])
 PORTING_NOTE = f"Python placeholder package for '{ARCHIVE_NAME}' with {MODULE_COUNT} archived module references."
 
-__all__ = ["ARCHIVE_NAME", "MODULE_COUNT", "PORTING_NOTE", "SAMPLE_FILES"]
+__all__ = ['ARCHIVE_NAME', 'MODULE_COUNT', 'PORTING_NOTE', 'SAMPLE_FILES']

src/coordinator/__init__.py

@@ -2,13 +2,15 @@
 
 from __future__ import annotations
 
-from src._archive_helper import load_archive_metadata
+import json
+from pathlib import Path
 
-_SNAPSHOT = load_archive_metadata("coordinator")
+SNAPSHOT_PATH = Path(__file__).resolve().parent.parent / 'reference_data' / 'subsystems' / 'coordinator.json'
+_SNAPSHOT = json.loads(SNAPSHOT_PATH.read_text())
 
-ARCHIVE_NAME = _SNAPSHOT["archive_name"]
-MODULE_COUNT = _SNAPSHOT["module_count"]
-SAMPLE_FILES = tuple(_SNAPSHOT["sample_files"])
+ARCHIVE_NAME = _SNAPSHOT['archive_name']
+MODULE_COUNT = _SNAPSHOT['module_count']
+SAMPLE_FILES = tuple(_SNAPSHOT['sample_files'])
 PORTING_NOTE = f"Python placeholder package for '{ARCHIVE_NAME}' with {MODULE_COUNT} archived module references."
 
-__all__ = ["ARCHIVE_NAME", "MODULE_COUNT", "PORTING_NOTE", "SAMPLE_FILES"]
+__all__ = ['ARCHIVE_NAME', 'MODULE_COUNT', 'PORTING_NOTE', 'SAMPLE_FILES']

src/entrypoints/__init__.py

@@ -2,13 +2,15 @@
 
 from __future__ import annotations
 
-from src._archive_helper import load_archive_metadata
+import json
+from pathlib import Path
 
-_SNAPSHOT = load_archive_metadata("entrypoints")
+SNAPSHOT_PATH = Path(__file__).resolve().parent.parent / 'reference_data' / 'subsystems' / 'entrypoints.json'
+_SNAPSHOT = json.loads(SNAPSHOT_PATH.read_text())
 
-ARCHIVE_NAME = _SNAPSHOT["archive_name"]
-MODULE_COUNT = _SNAPSHOT["module_count"]
-SAMPLE_FILES = tuple(_SNAPSHOT["sample_files"])
+ARCHIVE_NAME = _SNAPSHOT['archive_name']
+MODULE_COUNT = _SNAPSHOT['module_count']
+SAMPLE_FILES = tuple(_SNAPSHOT['sample_files'])
 PORTING_NOTE = f"Python placeholder package for '{ARCHIVE_NAME}' with {MODULE_COUNT} archived module references."
 
-__all__ = ["ARCHIVE_NAME", "MODULE_COUNT", "PORTING_NOTE", "SAMPLE_FILES"]
+__all__ = ['ARCHIVE_NAME', 'MODULE_COUNT', 'PORTING_NOTE', 'SAMPLE_FILES']

src/hooks/__init__.py

@@ -2,13 +2,15 @@
 
 from __future__ import annotations
 
-from src._archive_helper import load_archive_metadata
+import json
+from pathlib import Path
 
-_SNAPSHOT = load_archive_metadata("hooks")
+SNAPSHOT_PATH = Path(__file__).resolve().parent.parent / 'reference_data' / 'subsystems' / 'hooks.json'
+_SNAPSHOT = json.loads(SNAPSHOT_PATH.read_text())
 
-ARCHIVE_NAME = _SNAPSHOT["archive_name"]
-MODULE_COUNT = _SNAPSHOT["module_count"]
-SAMPLE_FILES = tuple(_SNAPSHOT["sample_files"])
+ARCHIVE_NAME = _SNAPSHOT['archive_name']
+MODULE_COUNT = _SNAPSHOT['module_count']
+SAMPLE_FILES = tuple(_SNAPSHOT['sample_files'])
 PORTING_NOTE = f"Python placeholder package for '{ARCHIVE_NAME}' with {MODULE_COUNT} archived module references."
 
-__all__ = ["ARCHIVE_NAME", "MODULE_COUNT", "PORTING_NOTE", "SAMPLE_FILES"]
+__all__ = ['ARCHIVE_NAME', 'MODULE_COUNT', 'PORTING_NOTE', 'SAMPLE_FILES']

src/keybindings/__init__.py

@@ -2,13 +2,15 @@
 
 from __future__ import annotations
 
-from src._archive_helper import load_archive_metadata
+import json
+from pathlib import Path
 
-_SNAPSHOT = load_archive_metadata("keybindings")
+SNAPSHOT_PATH = Path(__file__).resolve().parent.parent / 'reference_data' / 'subsystems' / 'keybindings.json'
+_SNAPSHOT = json.loads(SNAPSHOT_PATH.read_text())
 
-ARCHIVE_NAME = _SNAPSHOT["archive_name"]
-MODULE_COUNT = _SNAPSHOT["module_count"]
-SAMPLE_FILES = tuple(_SNAPSHOT["sample_files"])
+ARCHIVE_NAME = _SNAPSHOT['archive_name']
+MODULE_COUNT = _SNAPSHOT['module_count']
+SAMPLE_FILES = tuple(_SNAPSHOT['sample_files'])
 PORTING_NOTE = f"Python placeholder package for '{ARCHIVE_NAME}' with {MODULE_COUNT} archived module references."
 
-__all__ = ["ARCHIVE_NAME", "MODULE_COUNT", "PORTING_NOTE", "SAMPLE_FILES"]
+__all__ = ['ARCHIVE_NAME', 'MODULE_COUNT', 'PORTING_NOTE', 'SAMPLE_FILES']

src/memdir/__init__.py

@@ -2,13 +2,15 @@
 
 from __future__ import annotations
 
-from src._archive_helper import load_archive_metadata
+import json
+from pathlib import Path
 
-_SNAPSHOT = load_archive_metadata("memdir")
+SNAPSHOT_PATH = Path(__file__).resolve().parent.parent / 'reference_data' / 'subsystems' / 'memdir.json'
+_SNAPSHOT = json.loads(SNAPSHOT_PATH.read_text())
 
-ARCHIVE_NAME = _SNAPSHOT["archive_name"]
-MODULE_COUNT = _SNAPSHOT["module_count"]
-SAMPLE_FILES = tuple(_SNAPSHOT["sample_files"])
+ARCHIVE_NAME = _SNAPSHOT['archive_name']
+MODULE_COUNT = _SNAPSHOT['module_count']
+SAMPLE_FILES = tuple(_SNAPSHOT['sample_files'])
 PORTING_NOTE = f"Python placeholder package for '{ARCHIVE_NAME}' with {MODULE_COUNT} archived module references."
 
-__all__ = ["ARCHIVE_NAME", "MODULE_COUNT", "PORTING_NOTE", "SAMPLE_FILES"]
+__all__ = ['ARCHIVE_NAME', 'MODULE_COUNT', 'PORTING_NOTE', 'SAMPLE_FILES']

src/migrations/__init__.py

@@ -2,13 +2,15 @@
 
 from __future__ import annotations
 
-from src._archive_helper import load_archive_metadata
+import json
+from pathlib import Path
 
-_SNAPSHOT = load_archive_metadata("migrations")
+SNAPSHOT_PATH = Path(__file__).resolve().parent.parent / 'reference_data' / 'subsystems' / 'migrations.json'
+_SNAPSHOT = json.loads(SNAPSHOT_PATH.read_text())
 
-ARCHIVE_NAME = _SNAPSHOT["archive_name"]
-MODULE_COUNT = _SNAPSHOT["module_count"]
-SAMPLE_FILES = tuple(_SNAPSHOT["sample_files"])
+ARCHIVE_NAME = _SNAPSHOT['archive_name']
+MODULE_COUNT = _SNAPSHOT['module_count']
+SAMPLE_FILES = tuple(_SNAPSHOT['sample_files'])
 PORTING_NOTE = f"Python placeholder package for '{ARCHIVE_NAME}' with {MODULE_COUNT} archived module references."
 
-__all__ = ["ARCHIVE_NAME", "MODULE_COUNT", "PORTING_NOTE", "SAMPLE_FILES"]
+__all__ = ['ARCHIVE_NAME', 'MODULE_COUNT', 'PORTING_NOTE', 'SAMPLE_FILES']

src/moreright/__init__.py

@@ -2,13 +2,15 @@
 
 from __future__ import annotations
 
-from src._archive_helper import load_archive_metadata
+import json
+from pathlib import Path
 
-_SNAPSHOT = load_archive_metadata("moreright")
+SNAPSHOT_PATH = Path(__file__).resolve().parent.parent / 'reference_data' / 'subsystems' / 'moreright.json'
+_SNAPSHOT = json.loads(SNAPSHOT_PATH.read_text())
 
-ARCHIVE_NAME = _SNAPSHOT["archive_name"]
-MODULE_COUNT = _SNAPSHOT["module_count"]
-SAMPLE_FILES = tuple(_SNAPSHOT["sample_files"])
+ARCHIVE_NAME = _SNAPSHOT['archive_name']
+MODULE_COUNT = _SNAPSHOT['module_count']
+SAMPLE_FILES = tuple(_SNAPSHOT['sample_files'])
 PORTING_NOTE = f"Python placeholder package for '{ARCHIVE_NAME}' with {MODULE_COUNT} archived module references."
 
-__all__ = ["ARCHIVE_NAME", "MODULE_COUNT", "PORTING_NOTE", "SAMPLE_FILES"]
+__all__ = ['ARCHIVE_NAME', 'MODULE_COUNT', 'PORTING_NOTE', 'SAMPLE_FILES']

src/native_ts/__init__.py

@@ -1,14 +1,16 @@
-"""Python package placeholder for the archived `native_ts` subsystem."""
+"""Python package placeholder for the archived `native-ts` subsystem."""
 
 from __future__ import annotations
 
-from src._archive_helper import load_archive_metadata
+import json
+from pathlib import Path
 
-_SNAPSHOT = load_archive_metadata("native_ts")
+SNAPSHOT_PATH = Path(__file__).resolve().parent.parent / 'reference_data' / 'subsystems' / 'native_ts.json'
+_SNAPSHOT = json.loads(SNAPSHOT_PATH.read_text())
 
-ARCHIVE_NAME = _SNAPSHOT["archive_name"]
-MODULE_COUNT = _SNAPSHOT["module_count"]
-SAMPLE_FILES = tuple(_SNAPSHOT["sample_files"])
+ARCHIVE_NAME = _SNAPSHOT['archive_name']
+MODULE_COUNT = _SNAPSHOT['module_count']
+SAMPLE_FILES = tuple(_SNAPSHOT['sample_files'])
 PORTING_NOTE = f"Python placeholder package for '{ARCHIVE_NAME}' with {MODULE_COUNT} archived module references."
 
-__all__ = ["ARCHIVE_NAME", "MODULE_COUNT", "PORTING_NOTE", "SAMPLE_FILES"]
+__all__ = ['ARCHIVE_NAME', 'MODULE_COUNT', 'PORTING_NOTE', 'SAMPLE_FILES']

src/outputStyles/__init__.py

@@ -2,13 +2,15 @@
 
 from __future__ import annotations
 
-from src._archive_helper import load_archive_metadata
+import json
+from pathlib import Path
 
-_SNAPSHOT = load_archive_metadata("outputStyles")
+SNAPSHOT_PATH = Path(__file__).resolve().parent.parent / 'reference_data' / 'subsystems' / 'outputStyles.json'
+_SNAPSHOT = json.loads(SNAPSHOT_PATH.read_text())
 
-ARCHIVE_NAME = _SNAPSHOT["archive_name"]
-MODULE_COUNT = _SNAPSHOT["module_count"]
-SAMPLE_FILES = tuple(_SNAPSHOT["sample_files"])
+ARCHIVE_NAME = _SNAPSHOT['archive_name']
+MODULE_COUNT = _SNAPSHOT['module_count']
+SAMPLE_FILES = tuple(_SNAPSHOT['sample_files'])
 PORTING_NOTE = f"Python placeholder package for '{ARCHIVE_NAME}' with {MODULE_COUNT} archived module references."
 
-__all__ = ["ARCHIVE_NAME", "MODULE_COUNT", "PORTING_NOTE", "SAMPLE_FILES"]
+__all__ = ['ARCHIVE_NAME', 'MODULE_COUNT', 'PORTING_NOTE', 'SAMPLE_FILES']

src/plugins/__init__.py

@@ -2,13 +2,15 @@
 
 from __future__ import annotations
 
-from src._archive_helper import load_archive_metadata
+import json
+from pathlib import Path
 
-_SNAPSHOT = load_archive_metadata("plugins")
+SNAPSHOT_PATH = Path(__file__).resolve().parent.parent / 'reference_data' / 'subsystems' / 'plugins.json'
+_SNAPSHOT = json.loads(SNAPSHOT_PATH.read_text())
 
-ARCHIVE_NAME = _SNAPSHOT["archive_name"]
-MODULE_COUNT = _SNAPSHOT["module_count"]
-SAMPLE_FILES = tuple(_SNAPSHOT["sample_files"])
+ARCHIVE_NAME = _SNAPSHOT['archive_name']
+MODULE_COUNT = _SNAPSHOT['module_count']
+SAMPLE_FILES = tuple(_SNAPSHOT['sample_files'])
 PORTING_NOTE = f"Python placeholder package for '{ARCHIVE_NAME}' with {MODULE_COUNT} archived module references."
 
-__all__ = ["ARCHIVE_NAME", "MODULE_COUNT", "PORTING_NOTE", "SAMPLE_FILES"]
+__all__ = ['ARCHIVE_NAME', 'MODULE_COUNT', 'PORTING_NOTE', 'SAMPLE_FILES']

src/remote/__init__.py

@@ -2,13 +2,15 @@
 
 from __future__ import annotations
 
-from src._archive_helper import load_archive_metadata
+import json
+from pathlib import Path
 
-_SNAPSHOT = load_archive_metadata("remote")
+SNAPSHOT_PATH = Path(__file__).resolve().parent.parent / 'reference_data' / 'subsystems' / 'remote.json'
+_SNAPSHOT = json.loads(SNAPSHOT_PATH.read_text())
 
-ARCHIVE_NAME = _SNAPSHOT["archive_name"]
-MODULE_COUNT = _SNAPSHOT["module_count"]
-SAMPLE_FILES = tuple(_SNAPSHOT["sample_files"])
+ARCHIVE_NAME = _SNAPSHOT['archive_name']
+MODULE_COUNT = _SNAPSHOT['module_count']
+SAMPLE_FILES = tuple(_SNAPSHOT['sample_files'])
 PORTING_NOTE = f"Python placeholder package for '{ARCHIVE_NAME}' with {MODULE_COUNT} archived module references."
 
-__all__ = ["ARCHIVE_NAME", "MODULE_COUNT", "PORTING_NOTE", "SAMPLE_FILES"]
+__all__ = ['ARCHIVE_NAME', 'MODULE_COUNT', 'PORTING_NOTE', 'SAMPLE_FILES']

src/schemas/__init__.py

@@ -2,13 +2,15 @@
 
 from __future__ import annotations
 
-from src._archive_helper import load_archive_metadata
+import json
+from pathlib import Path
 
-_SNAPSHOT = load_archive_metadata("schemas")
+SNAPSHOT_PATH = Path(__file__).resolve().parent.parent / 'reference_data' / 'subsystems' / 'schemas.json'
+_SNAPSHOT = json.loads(SNAPSHOT_PATH.read_text())
 
-ARCHIVE_NAME = _SNAPSHOT["archive_name"]
-MODULE_COUNT = _SNAPSHOT["module_count"]
-SAMPLE_FILES = tuple(_SNAPSHOT["sample_files"])
+ARCHIVE_NAME = _SNAPSHOT['archive_name']
+MODULE_COUNT = _SNAPSHOT['module_count']
+SAMPLE_FILES = tuple(_SNAPSHOT['sample_files'])
 PORTING_NOTE = f"Python placeholder package for '{ARCHIVE_NAME}' with {MODULE_COUNT} archived module references."
 
-__all__ = ["ARCHIVE_NAME", "MODULE_COUNT", "PORTING_NOTE", "SAMPLE_FILES"]
+__all__ = ['ARCHIVE_NAME', 'MODULE_COUNT', 'PORTING_NOTE', 'SAMPLE_FILES']

src/screens/__init__.py

@@ -2,13 +2,15 @@
 
 from __future__ import annotations
 
-from src._archive_helper import load_archive_metadata
+import json
+from pathlib import Path
 
-_SNAPSHOT = load_archive_metadata("screens")
+SNAPSHOT_PATH = Path(__file__).resolve().parent.parent / 'reference_data' / 'subsystems' / 'screens.json'
+_SNAPSHOT = json.loads(SNAPSHOT_PATH.read_text())
 
-ARCHIVE_NAME = _SNAPSHOT["archive_name"]
-MODULE_COUNT = _SNAPSHOT["module_count"]
-SAMPLE_FILES = tuple(_SNAPSHOT["sample_files"])
+ARCHIVE_NAME = _SNAPSHOT['archive_name']
+MODULE_COUNT = _SNAPSHOT['module_count']
+SAMPLE_FILES = tuple(_SNAPSHOT['sample_files'])
 PORTING_NOTE = f"Python placeholder package for '{ARCHIVE_NAME}' with {MODULE_COUNT} archived module references."
 
-__all__ = ["ARCHIVE_NAME", "MODULE_COUNT", "PORTING_NOTE", "SAMPLE_FILES"]
+__all__ = ['ARCHIVE_NAME', 'MODULE_COUNT', 'PORTING_NOTE', 'SAMPLE_FILES']

src/server/__init__.py

@@ -2,13 +2,15 @@
 
 from __future__ import annotations
 
-from src._archive_helper import load_archive_metadata
+import json
+from pathlib import Path
 
-_SNAPSHOT = load_archive_metadata("server")
+SNAPSHOT_PATH = Path(__file__).resolve().parent.parent / 'reference_data' / 'subsystems' / 'server.json'
+_SNAPSHOT = json.loads(SNAPSHOT_PATH.read_text())
 
-ARCHIVE_NAME = _SNAPSHOT["archive_name"]
-MODULE_COUNT = _SNAPSHOT["module_count"]
-SAMPLE_FILES = tuple(_SNAPSHOT["sample_files"])
+ARCHIVE_NAME = _SNAPSHOT['archive_name']
+MODULE_COUNT = _SNAPSHOT['module_count']
+SAMPLE_FILES = tuple(_SNAPSHOT['sample_files'])
 PORTING_NOTE = f"Python placeholder package for '{ARCHIVE_NAME}' with {MODULE_COUNT} archived module references."
 
-__all__ = ["ARCHIVE_NAME", "MODULE_COUNT", "PORTING_NOTE", "SAMPLE_FILES"]
+__all__ = ['ARCHIVE_NAME', 'MODULE_COUNT', 'PORTING_NOTE', 'SAMPLE_FILES']

src/services/__init__.py

@@ -2,13 +2,15 @@
 
 from __future__ import annotations
 
-from src._archive_helper import load_archive_metadata
+import json
+from pathlib import Path
 
-_SNAPSHOT = load_archive_metadata("services")
+SNAPSHOT_PATH = Path(__file__).resolve().parent.parent / 'reference_data' / 'subsystems' / 'services.json'
+_SNAPSHOT = json.loads(SNAPSHOT_PATH.read_text())
 
-ARCHIVE_NAME = _SNAPSHOT["archive_name"]
-MODULE_COUNT = _SNAPSHOT["module_count"]
-SAMPLE_FILES = tuple(_SNAPSHOT["sample_files"])
+ARCHIVE_NAME = _SNAPSHOT['archive_name']
+MODULE_COUNT = _SNAPSHOT['module_count']
+SAMPLE_FILES = tuple(_SNAPSHOT['sample_files'])
 PORTING_NOTE = f"Python placeholder package for '{ARCHIVE_NAME}' with {MODULE_COUNT} archived module references."
 
-__all__ = ["ARCHIVE_NAME", "MODULE_COUNT", "PORTING_NOTE", "SAMPLE_FILES"]
+__all__ = ['ARCHIVE_NAME', 'MODULE_COUNT', 'PORTING_NOTE', 'SAMPLE_FILES']

src/skills/__init__.py

@@ -2,13 +2,15 @@
 
 from __future__ import annotations
 
-from src._archive_helper import load_archive_metadata
+import json
+from pathlib import Path
 
-_SNAPSHOT = load_archive_metadata("skills")
+SNAPSHOT_PATH = Path(__file__).resolve().parent.parent / 'reference_data' / 'subsystems' / 'skills.json'
+_SNAPSHOT = json.loads(SNAPSHOT_PATH.read_text())
 
-ARCHIVE_NAME = _SNAPSHOT["archive_name"]
-MODULE_COUNT = _SNAPSHOT["module_count"]
-SAMPLE_FILES = tuple(_SNAPSHOT["sample_files"])
+ARCHIVE_NAME = _SNAPSHOT['archive_name']
+MODULE_COUNT = _SNAPSHOT['module_count']
+SAMPLE_FILES = tuple(_SNAPSHOT['sample_files'])
 PORTING_NOTE = f"Python placeholder package for '{ARCHIVE_NAME}' with {MODULE_COUNT} archived module references."
 
-__all__ = ["ARCHIVE_NAME", "MODULE_COUNT", "PORTING_NOTE", "SAMPLE_FILES"]
+__all__ = ['ARCHIVE_NAME', 'MODULE_COUNT', 'PORTING_NOTE', 'SAMPLE_FILES']

src/state/__init__.py

@@ -2,13 +2,15 @@
 
 from __future__ import annotations
 
-from src._archive_helper import load_archive_metadata
+import json
+from pathlib import Path
 
-_SNAPSHOT = load_archive_metadata("state")
+SNAPSHOT_PATH = Path(__file__).resolve().parent.parent / 'reference_data' / 'subsystems' / 'state.json'
+_SNAPSHOT = json.loads(SNAPSHOT_PATH.read_text())
 
-ARCHIVE_NAME = _SNAPSHOT["archive_name"]
-MODULE_COUNT = _SNAPSHOT["module_count"]
-SAMPLE_FILES = tuple(_SNAPSHOT["sample_files"])
+ARCHIVE_NAME = _SNAPSHOT['archive_name']
+MODULE_COUNT = _SNAPSHOT['module_count']
+SAMPLE_FILES = tuple(_SNAPSHOT['sample_files'])
 PORTING_NOTE = f"Python placeholder package for '{ARCHIVE_NAME}' with {MODULE_COUNT} archived module references."
 
-__all__ = ["ARCHIVE_NAME", "MODULE_COUNT", "PORTING_NOTE", "SAMPLE_FILES"]
+__all__ = ['ARCHIVE_NAME', 'MODULE_COUNT', 'PORTING_NOTE', 'SAMPLE_FILES']

src/types/__init__.py

@@ -2,13 +2,15 @@
 
 from __future__ import annotations
 
-from src._archive_helper import load_archive_metadata
+import json
+from pathlib import Path
 
-_SNAPSHOT = load_archive_metadata("types")
+SNAPSHOT_PATH = Path(__file__).resolve().parent.parent / 'reference_data' / 'subsystems' / 'types.json'
+_SNAPSHOT = json.loads(SNAPSHOT_PATH.read_text())
 
-ARCHIVE_NAME = _SNAPSHOT["archive_name"]
-MODULE_COUNT = _SNAPSHOT["module_count"]
-SAMPLE_FILES = tuple(_SNAPSHOT["sample_files"])
+ARCHIVE_NAME = _SNAPSHOT['archive_name']
+MODULE_COUNT = _SNAPSHOT['module_count']
+SAMPLE_FILES = tuple(_SNAPSHOT['sample_files'])
 PORTING_NOTE = f"Python placeholder package for '{ARCHIVE_NAME}' with {MODULE_COUNT} archived module references."
 
-__all__ = ["ARCHIVE_NAME", "MODULE_COUNT", "PORTING_NOTE", "SAMPLE_FILES"]
+__all__ = ['ARCHIVE_NAME', 'MODULE_COUNT', 'PORTING_NOTE', 'SAMPLE_FILES']

src/upstreamproxy/__init__.py

@@ -2,13 +2,15 @@
 
 from __future__ import annotations
 
-from src._archive_helper import load_archive_metadata
+import json
+from pathlib import Path
 
-_SNAPSHOT = load_archive_metadata("upstreamproxy")
+SNAPSHOT_PATH = Path(__file__).resolve().parent.parent / 'reference_data' / 'subsystems' / 'upstreamproxy.json'
+_SNAPSHOT = json.loads(SNAPSHOT_PATH.read_text())
 
-ARCHIVE_NAME = _SNAPSHOT["archive_name"]
-MODULE_COUNT = _SNAPSHOT["module_count"]
-SAMPLE_FILES = tuple(_SNAPSHOT["sample_files"])
+ARCHIVE_NAME = _SNAPSHOT['archive_name']
+MODULE_COUNT = _SNAPSHOT['module_count']
+SAMPLE_FILES = tuple(_SNAPSHOT['sample_files'])
 PORTING_NOTE = f"Python placeholder package for '{ARCHIVE_NAME}' with {MODULE_COUNT} archived module references."
 
-__all__ = ["ARCHIVE_NAME", "MODULE_COUNT", "PORTING_NOTE", "SAMPLE_FILES"]
+__all__ = ['ARCHIVE_NAME', 'MODULE_COUNT', 'PORTING_NOTE', 'SAMPLE_FILES']

src/utils/__init__.py

@@ -2,13 +2,15 @@
 
 from __future__ import annotations
 
-from src._archive_helper import load_archive_metadata
+import json
+from pathlib import Path
 
-_SNAPSHOT = load_archive_metadata("utils")
+SNAPSHOT_PATH = Path(__file__).resolve().parent.parent / 'reference_data' / 'subsystems' / 'utils.json'
+_SNAPSHOT = json.loads(SNAPSHOT_PATH.read_text())
 
-ARCHIVE_NAME = _SNAPSHOT["archive_name"]
-MODULE_COUNT = _SNAPSHOT["module_count"]
-SAMPLE_FILES = tuple(_SNAPSHOT["sample_files"])
+ARCHIVE_NAME = _SNAPSHOT['archive_name']
+MODULE_COUNT = _SNAPSHOT['module_count']
+SAMPLE_FILES = tuple(_SNAPSHOT['sample_files'])
 PORTING_NOTE = f"Python placeholder package for '{ARCHIVE_NAME}' with {MODULE_COUNT} archived module references."
 
-__all__ = ["ARCHIVE_NAME", "MODULE_COUNT", "PORTING_NOTE", "SAMPLE_FILES"]
+__all__ = ['ARCHIVE_NAME', 'MODULE_COUNT', 'PORTING_NOTE', 'SAMPLE_FILES']

src/vim/__init__.py

@@ -2,13 +2,15 @@
 
 from __future__ import annotations
 
-from src._archive_helper import load_archive_metadata
+import json
+from pathlib import Path
 
-_SNAPSHOT = load_archive_metadata("vim")
+SNAPSHOT_PATH = Path(__file__).resolve().parent.parent / 'reference_data' / 'subsystems' / 'vim.json'
+_SNAPSHOT = json.loads(SNAPSHOT_PATH.read_text())
 
-ARCHIVE_NAME = _SNAPSHOT["archive_name"]
-MODULE_COUNT = _SNAPSHOT["module_count"]
-SAMPLE_FILES = tuple(_SNAPSHOT["sample_files"])
+ARCHIVE_NAME = _SNAPSHOT['archive_name']
+MODULE_COUNT = _SNAPSHOT['module_count']
+SAMPLE_FILES = tuple(_SNAPSHOT['sample_files'])
 PORTING_NOTE = f"Python placeholder package for '{ARCHIVE_NAME}' with {MODULE_COUNT} archived module references."
 
-__all__ = ["ARCHIVE_NAME", "MODULE_COUNT", "PORTING_NOTE", "SAMPLE_FILES"]
+__all__ = ['ARCHIVE_NAME', 'MODULE_COUNT', 'PORTING_NOTE', 'SAMPLE_FILES']

src/voice/__init__.py

@@ -2,13 +2,15 @@
 
 from __future__ import annotations
 
-from src._archive_helper import load_archive_metadata
+import json
+from pathlib import Path
 
-_SNAPSHOT = load_archive_metadata("voice")
+SNAPSHOT_PATH = Path(__file__).resolve().parent.parent / 'reference_data' / 'subsystems' / 'voice.json'
+_SNAPSHOT = json.loads(SNAPSHOT_PATH.read_text())
 
-ARCHIVE_NAME = _SNAPSHOT["archive_name"]
-MODULE_COUNT = _SNAPSHOT["module_count"]
-SAMPLE_FILES = tuple(_SNAPSHOT["sample_files"])
+ARCHIVE_NAME = _SNAPSHOT['archive_name']
+MODULE_COUNT = _SNAPSHOT['module_count']
+SAMPLE_FILES = tuple(_SNAPSHOT['sample_files'])
 PORTING_NOTE = f"Python placeholder package for '{ARCHIVE_NAME}' with {MODULE_COUNT} archived module references."
 
-__all__ = ["ARCHIVE_NAME", "MODULE_COUNT", "PORTING_NOTE", "SAMPLE_FILES"]
+__all__ = ['ARCHIVE_NAME', 'MODULE_COUNT', 'PORTING_NOTE', 'SAMPLE_FILES']