rebrand: Claude Code -> Claw Code in all prompts and source text

.claw.json

@@ -1,5 +0,0 @@
-{
-  "aliases": {
-    "quick": "haiku"
-  }
-}

.github/FUNDING.yml

@@ -1,3 +1 @@
-github:
-  - ultraworkers
-  - Yeachan-Heo
+github: instructkr

.github/scripts/check_doc_source_of_truth.py

@@ -1,45 +0,0 @@
-#!/usr/bin/env python3
-from __future__ import annotations
-
-from pathlib import Path
-import re
-import sys
-
-ROOT = Path(__file__).resolve().parents[2]
-FILES = [
-    ROOT / 'README.md',
-    ROOT / 'USAGE.md',
-    ROOT / 'PARITY.md',
-    ROOT / 'PHILOSOPHY.md',
-    ROOT / 'ROADMAP.md',
-    ROOT / '.github' / 'FUNDING.yml',
-]
-FILES.extend(sorted((ROOT / 'docs').rglob('*.md')) if (ROOT / 'docs').exists() else [])
-
-FORBIDDEN = {
-    r'github\.com/Yeachan-Heo/claw-code(?!-parity)': 'replace old claw-code GitHub links with ultraworkers/claw-code',
-    r'github\.com/code-yeongyu/claw-code': 'replace stale alternate claw-code GitHub links with ultraworkers/claw-code',
-    r'discord\.gg/6ztZB9jvWq': 'replace the stale UltraWorkers Discord invite with the current invite',
-    r'api\.star-history\.com/svg\?repos=Yeachan-Heo/claw-code': 'update star-history embeds to ultraworkers/claw-code',
-    r'star-history\.com/#Yeachan-Heo/claw-code': 'update star-history links to ultraworkers/claw-code',
-    r'assets/clawd-hero\.jpeg': 'rename stale hero asset references to assets/claw-hero.jpeg',
-    r'assets/instructkr\.png': 'remove stale instructkr image references',
-}
-
-errors: list[str] = []
-for path in FILES:
-    if not path.exists():
-        continue
-    text = path.read_text(encoding='utf-8')
-    for pattern, message in FORBIDDEN.items():
-        for match in re.finditer(pattern, text):
-            line = text.count('\n', 0, match.start()) + 1
-            errors.append(f'{path.relative_to(ROOT)}:{line}: {message}')
-
-if errors:
-    print('doc source-of-truth check failed:', file=sys.stderr)
-    for error in errors:
-        print(f'  - {error}', file=sys.stderr)
-    sys.exit(1)
-
-print('doc source-of-truth check passed')

.github/workflows/release.yml

@@ -1,68 +0,0 @@
-name: Release binaries
-
-on:
-  push:
-    tags:
-      - 'v*'
-  workflow_dispatch:
-
-permissions:
-  contents: write
-
-concurrency:
-  group: release-${{ github.ref }}
-  cancel-in-progress: false
-
-env:
-  CARGO_TERM_COLOR: always
-
-jobs:
-  build:
-    name: build-${{ matrix.name }}
-    runs-on: ${{ matrix.os }}
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - name: linux-x64
-            os: ubuntu-latest
-            bin: claw
-            artifact_name: claw-linux-x64
-          - name: macos-arm64
-            os: macos-14
-            bin: claw
-            artifact_name: claw-macos-arm64
-    defaults:
-      run:
-        working-directory: rust
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: dtolnay/rust-toolchain@stable
-
-      - uses: Swatinem/rust-cache@v2
-        with:
-          workspaces: rust -> target
-
-      - name: Build release binary
-        run: cargo build --release -p rusty-claude-cli
-
-      - name: Package artifact
-        shell: bash
-        run: |
-          mkdir -p dist
-          cp "target/release/${{ matrix.bin }}" "dist/${{ matrix.artifact_name }}"
-          chmod +x "dist/${{ matrix.artifact_name }}"
-
-      - name: Upload workflow artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: ${{ matrix.artifact_name }}
-          path: rust/dist/${{ matrix.artifact_name }}
-
-      - name: Upload release asset
-        if: startsWith(github.ref, 'refs/tags/')
-        uses: softprops/action-gh-release@v2
-        with:
-          files: rust/dist/${{ matrix.artifact_name }}
-          fail_on_unmatched_files: true

.github/workflows/rust-ci.yml

@@ -1,100 +0,0 @@
-name: Rust CI
-
-on:
-  push:
-    branches:
-      - main
-      - 'gaebal/**'
-      - 'omx-issue-*'
-    paths:
-      - .github/workflows/rust-ci.yml
-      - .github/scripts/check_doc_source_of_truth.py
-      - .github/FUNDING.yml
-      - README.md
-      - USAGE.md
-      - PARITY.md
-      - PHILOSOPHY.md
-      - ROADMAP.md
-      - docs/**
-      - rust/**
-  pull_request:
-    branches:
-      - main
-    paths:
-      - .github/workflows/rust-ci.yml
-      - .github/scripts/check_doc_source_of_truth.py
-      - .github/FUNDING.yml
-      - README.md
-      - USAGE.md
-      - PARITY.md
-      - PHILOSOPHY.md
-      - ROADMAP.md
-      - docs/**
-      - rust/**
-  workflow_dispatch:
-
-concurrency:
-  group: rust-ci-${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
-  cancel-in-progress: true
-
-defaults:
-  run:
-    working-directory: rust
-
-env:
-  CARGO_TERM_COLOR: always
-
-jobs:
-  doc-source-of-truth:
-    name: docs source-of-truth
-    runs-on: ubuntu-latest
-    defaults:
-      run:
-        working-directory: .
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
-        with:
-          python-version: "3.x"
-      - name: Check docs and metadata for stale branding
-        run: python .github/scripts/check_doc_source_of_truth.py
-
-  fmt:
-    name: cargo fmt
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: dtolnay/rust-toolchain@stable
-        with:
-          components: rustfmt
-      - uses: Swatinem/rust-cache@v2
-        with:
-          workspaces: rust -> target
-      - name: Check formatting
-        run: cargo fmt --all --check
-
-  test-workspace:
-    name: cargo test --workspace
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: dtolnay/rust-toolchain@stable
-      - uses: Swatinem/rust-cache@v2
-        with:
-          workspaces: rust -> target
-      - name: Run workspace tests
-        run: cargo test --workspace
-
-  clippy-workspace:
-    name: cargo clippy --workspace
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: dtolnay/rust-toolchain@stable
-        with:
-          components: clippy
-      - uses: Swatinem/rust-cache@v2
-        with:
-          workspaces: rust -> target
-      - name: Run workspace clippy
-        run: cargo clippy --workspace

.gitignore

@@ -5,8 +5,3 @@ archive/
 # Claude Code local artifacts
 .claude/settings.local.json
 .claude/sessions/
-# Claw Code local artifacts
-.claw/settings.local.json
-.claw/sessions/
-.clawhip/
-status-help.txt

.omx/cc2/issue-parity-intake.json

@@ -1,429 +0,0 @@
-{
-  "schema_version": "cc2.issue_parity_intake.v1",
-  "generated_at": "2026-05-14T08:02:00Z",
-  "task_id": "3",
-  "owner": "worker-2",
-  "goal": "G001-stream0-board",
-  "notes": [
-    "Leader owns Ultragoal; this artifact does not mutate .omx/ultragoal.",
-    "Rows are scoped intake/classification evidence for Worker 1/Task 2 board integration."
-  ],
-  "source_manifest": {
-    "claw_open_latest": {
-      "path": ".omx/research/claw-open-latest.json",
-      "sha256_prefix_from_plan": "89e3e027fa735f38",
-      "covered_issue_numbers": [3028, 3029, 3030, 3031, 3032, 3033, 3034, 3035, 3036, 3037, 3038]
-    },
-    "claw_issues": {
-      "path": ".omx/research/claw-issues.json",
-      "sha256_prefix_from_plan": "e64fdba7df3b78ed",
-      "covered_issue_numbers": [2997, 3003, 3004, 3005, 3006, 3007, 3020, 3023]
-    },
-    "opencode": {
-      "repo_path": ".omx/research/repos/opencode",
-      "metadata_path": ".omx/research/opencode-repo.json",
-      "issues_path": ".omx/research/opencode-issues.json",
-      "head_from_plan": "27ac53aaacc677b1401c4e75ca7a7dadf8b2c349"
-    },
-    "codex": {
-      "repo_path": ".omx/research/repos/codex",
-      "metadata_path": ".omx/research/codex-repo.json",
-      "issues_path": ".omx/research/codex-issues.json",
-      "head_from_plan": "6a225e4005209f2325ab3c681c7c6beba2907d4d"
-    }
-  },
-  "issue_clusters": [
-    {
-      "id": "CC2-ISSUE-3007",
-      "source_anchor": "https://github.com/ultraworkers/claw-code/issues/3007",
-      "source_type": "github_issue",
-      "source_number": 3007,
-      "title": "Permission modes do not enforce path scope on file tools or shell expansion in bash",
-      "theme": "security/path-scope",
-      "release_bucket": "alpha_blocker",
-      "lifecycle_status": "active",
-      "roadmap_anchor": "ROADMAP.md#11-policy-engine-for-autonomous-coding; ROADMAP.md#9-green-ness-contract",
-      "dependencies": ["permission path canonicalization", "file tool target validation", "bash command/path validation reachability", "policy regression fixtures"],
-      "verification_required": ["workspace-write cannot read/write/delete outside workspace", "shell expansion and symlink traversal are rejected or policy-blocked", "file tools and bash use the same target-scope decision record"],
-      "deferral_rationale": null,
-      "classification_rationale": "Security/sandbox escape class; plan names #3007 as alpha blocker."
-    },
-    {
-      "id": "CC2-ISSUE-3020",
-      "source_anchor": "https://github.com/ultraworkers/claw-code/issues/3020",
-      "source_type": "github_issue",
-      "source_number": 3020,
-      "title": "OpenAI-compatible model IDs with slashes are stripped before request",
-      "theme": "provider/model-routing",
-      "release_bucket": "beta_adoption",
-      "lifecycle_status": "open",
-      "roadmap_anchor": "ROADMAP.md#provider-routing-model-name-prefix-must-win-over-env-var-presence-fixed-2026-04-08-0530c50",
-      "dependencies": ["provider profile contract", "wire model-id preservation option", "routing-prefix source reporting"],
-      "verification_required": ["OpenAI-compatible endpoint receives exact model id when preservation is enabled", "status JSON reports raw model input, route, and wire model id"],
-      "deferral_rationale": null,
-      "classification_rationale": "Core provider correctness but below alpha state/security contracts unless it blocks the selected alpha model path."
-    },
-    {
-      "id": "CC2-ISSUE-3006",
-      "source_anchor": "https://github.com/ultraworkers/claw-code/issues/3006",
-      "source_type": "github_issue",
-      "source_number": 3006,
-      "title": "Not Working in windows",
-      "theme": "windows/install",
-      "release_bucket": "beta_adoption",
-      "lifecycle_status": "open",
-      "roadmap_anchor": "ROADMAP.md#immediate-backlog-from-current-real-pain",
-      "dependencies": ["Windows support policy", "PowerShell install path", "dependency/version matrix", "diagnostic setup output"],
-      "verification_required": ["fresh Windows/PowerShell setup smoke documented", "unsupported native paths fail with actionable WSL2/native guidance"],
-      "deferral_rationale": null,
-      "classification_rationale": "Real adoption blocker; plan places Windows/install in beta adoption overlay."
-    },
-    {
-      "id": "CC2-ISSUE-3005",
-      "source_anchor": "https://github.com/ultraworkers/claw-code/issues/3005",
-      "source_type": "github_issue",
-      "source_number": 3005,
-      "title": "DeepSeek V4-flash/pro fails with 400 Bad Request (missing reasoning_content) while deepseek-reasoner works",
-      "theme": "provider/response-shape",
-      "release_bucket": "beta_adoption",
-      "lifecycle_status": "open",
-      "roadmap_anchor": "ROADMAP.md#5-failure-taxonomy; ROADMAP.md#provider-routing-model-name-prefix-must-win-over-env-var-presence-fixed-2026-04-08-0530c50",
-      "dependencies": ["OpenAI-compatible diagnostics playbook", "provider error taxonomy", "reasoning/thinking field compatibility tests"],
-      "verification_required": ["provider 400 response classified with actionable remediation", "DeepSeek-compatible response-shape fixture does not hide assistant output"],
-      "deferral_rationale": null,
-      "classification_rationale": "Provider compatibility issue that shares the #3032 diagnostics lane."
-    },
-    {
-      "id": "CC2-ISSUE-3004",
-      "source_anchor": "https://github.com/ultraworkers/claw-code/issues/3004",
-      "source_type": "github_issue",
-      "source_number": 3004,
-      "title": "When can we adapt to zed?",
-      "theme": "ide/acp",
-      "release_bucket": "ga_ecosystem",
-      "lifecycle_status": "deferred_with_rationale",
-      "roadmap_anchor": "ROADMAP.md#phase-5-plugin-and-mcp-lifecycle-maturity",
-      "dependencies": ["stable session/control API", "plugin/MCP lifecycle", "engine API or ACP bridge decision"],
-      "verification_required": ["Zed/ACP smoke once core state/control contracts exist"],
-      "deferral_rationale": "IDE integration is valuable but should wait until boot/session/event/control truth surfaces are stable.",
-      "classification_rationale": "Matches plan's GA ecosystem lane for Zed/ACP."
-    },
-    {
-      "id": "CC2-ISSUE-3003",
-      "source_anchor": "https://github.com/ultraworkers/claw-code/issues/3003",
-      "source_type": "github_issue",
-      "source_number": 3003,
-      "title": ".claude/sessions should not be submitted to repo",
-      "theme": "session-hygiene/gitignore",
-      "release_bucket": "beta_adoption",
-      "lifecycle_status": "open",
-      "roadmap_anchor": "ROADMAP.md#9-green-ness-contract; ROADMAP.md#8-recovery-recipes-for-common-failures",
-      "dependencies": ["artifact ignore policy", "session storage boundary docs", "repo hygiene check"],
-      "verification_required": ["session directories are ignored", "status/doctor warns about tracked session artifacts"],
-      "deferral_rationale": null,
-      "classification_rationale": "Small but user-visible session hygiene and data-leak prevention item."
-    },
-    {
-      "id": "CC2-ISSUE-2997",
-      "source_anchor": "https://github.com/ultraworkers/claw-code/issues/2997",
-      "source_type": "github_issue",
-      "source_number": 2997,
-      "title": "License?",
-      "theme": "docs/license",
-      "release_bucket": "beta_adoption",
-      "lifecycle_status": "open",
-      "roadmap_anchor": "ROADMAP.md#immediate-backlog-from-current-real-pain",
-      "dependencies": ["maintainer license decision", "LICENSE file", "README/USAGE attribution wording"],
-      "verification_required": ["repository license file exists", "package metadata and docs reference the same license"],
-      "deferral_rationale": null,
-      "classification_rationale": "Adoption/readiness documentation gap; requires maintainer decision before implementation."
-    },
-    {
-      "id": "CC2-ISSUE-3023",
-      "source_anchor": "https://github.com/ultraworkers/claw-code/issues/3023",
-      "source_type": "github_issue",
-      "source_number": 3023,
-      "title": "Protect claw-code from AI slop PRs",
-      "theme": "repo-hygiene/anti-slop",
-      "release_bucket": "beta_adoption",
-      "lifecycle_status": "open",
-      "roadmap_anchor": "ROADMAP.md#immediate-backlog-from-current-real-pain",
-      "dependencies": ["contributor policy", "PR quality gate selection", "false-positive review escape hatch"],
-      "verification_required": ["selected PR quality gate runs on sample good/bad PR fixtures", "maintainers can override false positives"],
-      "deferral_rationale": null,
-      "classification_rationale": "Protects project throughput but should not precede alpha core safety contracts."
-    },
-    {
-      "id": "CC2-ISSUE-3028",
-      "source_anchor": "https://github.com/ultraworkers/claw-code/issues/3028",
-      "source_type": "github_issue",
-      "source_number": 3028,
-      "title": "docs: add navigation and file-context usage guide",
-      "theme": "docs/navigation-context",
-      "release_bucket": "beta_adoption",
-      "lifecycle_status": "open",
-      "roadmap_anchor": "ROADMAP.md#7-human-ux-still-leaks-into-claw-workflows",
-      "dependencies": ["current TUI/shell key behavior inventory", "file context syntax docs", "secret-handling guidance"],
-      "verification_required": ["docs include terminal history, scrollback, @file context, attach/external file caveats", "examples work against current CLI"],
-      "deferral_rationale": null,
-      "classification_rationale": "Documentation support item from latest open issue refresh."
-    },
-    {
-      "id": "CC2-ISSUE-3029",
-      "source_anchor": "https://github.com/ultraworkers/claw-code/issues/3029",
-      "source_type": "github_issue",
-      "source_number": 3029,
-      "title": "build: add cross-platform installer path and release artifact quickstart",
-      "theme": "install/distribution",
-      "release_bucket": "beta_adoption",
-      "lifecycle_status": "open",
-      "roadmap_anchor": "ROADMAP.md#immediate-backlog-from-current-real-pain",
-      "dependencies": ["release artifact policy", "install.sh/install.ps1 contract", "PATH/update/uninstall instructions"],
-      "verification_required": ["install quickstart smoke on supported OS/arch", "failed install prints actionable diagnostics"],
-      "deferral_rationale": null,
-      "classification_rationale": "Distribution friction belongs in adoption overlay."
-    },
-    {
-      "id": "CC2-ISSUE-3030",
-      "source_anchor": "https://github.com/ultraworkers/claw-code/issues/3030",
-      "source_type": "github_issue",
-      "source_number": 3030,
-      "title": "feat: make provider/model setup less env-var-driven",
-      "theme": "provider/setup-profiles",
-      "release_bucket": "beta_adoption",
-      "lifecycle_status": "open",
-      "roadmap_anchor": "ROADMAP.md#3-structured-session-control-api; ROADMAP.md#145-boot-preflight-doctor-contract",
-      "dependencies": ["provider profiles", "setup wizard or dry-run", "secret redaction", "base-url/model smoke test"],
-      "verification_required": ["setup validates provider route without echoing keys", "session-only versus persisted profile behavior is explicit"],
-      "deferral_rationale": null,
-      "classification_rationale": "Directly reduces current provider setup support churn."
-    },
-    {
-      "id": "CC2-ISSUE-3031",
-      "source_anchor": "https://github.com/ultraworkers/claw-code/issues/3031",
-      "source_type": "github_issue",
-      "source_number": 3031,
-      "title": "feat: auto-compact or clearly recover from context-window provider errors",
-      "theme": "session-recovery/context-window",
-      "release_bucket": "beta_adoption",
-      "lifecycle_status": "open",
-      "roadmap_anchor": "ROADMAP.md#8-recovery-recipes-for-common-failures; ROADMAP.md#158-compact_messages_if_needed-drops-turns-silently-no-structured-compaction-event-emitted",
-      "dependencies": ["provider error classifier", "safe compact retry policy", "compaction event/audit trail", "retry loop cap"],
-      "verification_required": ["context-window error either compacts+retries once safely or emits exact recovery command", "compaction event is machine-visible"],
-      "deferral_rationale": null,
-      "classification_rationale": "Recovery reliability item; promoted only if selected alpha provider path hits it."
-    },
-    {
-      "id": "CC2-ISSUE-3032",
-      "source_anchor": "https://github.com/ultraworkers/claw-code/issues/3032",
-      "source_type": "github_issue",
-      "source_number": 3032,
-      "title": "docs: add OpenAI-compatible/local provider diagnostics playbook",
-      "theme": "provider/diagnostics-docs",
-      "release_bucket": "beta_adoption",
-      "lifecycle_status": "open",
-      "roadmap_anchor": "ROADMAP.md#5-failure-taxonomy",
-      "dependencies": ["raw chat-completions smoke tests", "tool-call response-shape examples", "provider failure taxonomy"],
-      "verification_required": ["playbook distinguishes Claw bugs from wrapper/tool-call-shape bugs", "curl examples cover non-streaming and streaming tool calls"],
-      "deferral_rationale": null,
-      "classification_rationale": "Shared diagnostic lane for #3005/#3020/local model reports."
-    },
-    {
-      "id": "CC2-ISSUE-3033",
-      "source_anchor": "https://github.com/ultraworkers/claw-code/issues/3033",
-      "source_type": "github_issue",
-      "source_number": 3033,
-      "title": "feat: add minimal claw serve JSON-RPC engine API",
-      "theme": "engine-api/control-plane",
-      "release_bucket": "ga_ecosystem",
-      "lifecycle_status": "deferred_with_rationale",
-      "roadmap_anchor": "ROADMAP.md#3-structured-session-control-api; ROADMAP.md#phase-4-claws-first-task-execution",
-      "dependencies": ["stable session state API", "event schema v1", "permission policy contract", "cancel/prompt stream semantics"],
-      "verification_required": ["protocol conformance fixtures for session/create prompt/stream cancel error", "capability negotiation backwards compatibility"],
-      "deferral_rationale": "Engine API should expose, not invent, stable core control-plane semantics after alpha contracts land.",
-      "classification_rationale": "Useful integration surface but too broad for alpha unless narrowed to existing session control API."
-    },
-    {
-      "id": "CC2-ISSUE-3034",
-      "source_anchor": "https://github.com/ultraworkers/claw-code/issues/3034",
-      "source_type": "github_issue",
-      "source_number": 3034,
-      "title": "docs: define evidence-gated Hermes handoff loop for Claw Code execution",
-      "theme": "sdlc/evidence-handoff",
-      "release_bucket": "post_2_0_research",
-      "lifecycle_status": "deferred_with_rationale",
-      "roadmap_anchor": "ROADMAP.md#4-canonical-lane-event-schema; ROADMAP.md#10-typed-task-packet-format",
-      "dependencies": ["typed task packet", "evidence bundle schema", "report gate status vocabulary"],
-      "verification_required": ["handoff packet fixture validates scope/success/test evidence fields", "post-flight gate consumes evidence instead of free-text summary"],
-      "deferral_rationale": "Can inform event/report/task contracts, but Hermes-specific loop should stay research/docs until core schemas are stable.",
-      "classification_rationale": "Only the generic evidence-gated contract is Claw 2.0; Hermes branding is not core."
-    },
-    {
-      "id": "CC2-ISSUE-3035",
-      "source_anchor": "https://github.com/ultraworkers/claw-code/issues/3035",
-      "source_type": "github_issue",
-      "source_number": 3035,
-      "title": "fix: improve compacted session resume discoverability",
-      "theme": "session-resume/discoverability",
-      "release_bucket": "beta_adoption",
-      "lifecycle_status": "open",
-      "roadmap_anchor": "ROADMAP.md#8-recovery-recipes-for-common-failures; ROADMAP.md#160-session_store-has-no-list_sessions-delete_session-or-session_exists",
-      "dependencies": ["session enumeration", "latest-session workspace search boundary", "compacted session marker"],
-      "verification_required": ["/resume latest finds newest eligible compacted session", "/session or status lists resumable compacted sessions with path/id"],
-      "deferral_rationale": null,
-      "classification_rationale": "Session recovery/adoption item."
-    },
-    {
-      "id": "CC2-ISSUE-3036",
-      "source_anchor": "https://github.com/ultraworkers/claw-code/issues/3036",
-      "source_type": "github_issue",
-      "source_number": 3036,
-      "title": "docs: add official Ollama/llama.cpp/vLLM local model examples",
-      "theme": "provider/local-docs",
-      "release_bucket": "beta_adoption",
-      "lifecycle_status": "open",
-      "roadmap_anchor": "ROADMAP.md#145-boot-preflight-doctor-contract; ROADMAP.md#5-failure-taxonomy",
-      "dependencies": ["known-good local provider examples", "raw /v1 smoke test", "tool-call limitation warning"],
-      "verification_required": ["docs include Ollama/llama.cpp/vLLM examples and HELLO smoke", "tool-call caveats are explicit"],
-      "deferral_rationale": null,
-      "classification_rationale": "Local provider adoption support."
-    },
-    {
-      "id": "CC2-ISSUE-3037",
-      "source_anchor": "https://github.com/ultraworkers/claw-code/issues/3037",
-      "source_type": "github_issue",
-      "source_number": 3037,
-      "title": "docs: clarify Claw Code positioning as multi-provider Claude-Code-shaped runtime",
-      "theme": "docs/product-positioning",
-      "release_bucket": "beta_adoption",
-      "lifecycle_status": "open",
-      "roadmap_anchor": "ROADMAP.md#goal; ROADMAP.md#definition-of-clawable",
-      "dependencies": ["README positioning copy", "provider support truth table", "identity leak bug policy"],
-      "verification_required": ["README/docs answer Claude-only question directly", "provider support wording matches implemented routes"],
-      "deferral_rationale": null,
-      "classification_rationale": "Clarifies product identity for adoption without broad implementation."
-    },
-    {
-      "id": "CC2-ISSUE-3038",
-      "source_anchor": "https://github.com/ultraworkers/claw-code/issues/3038",
-      "source_type": "github_issue",
-      "source_number": 3038,
-      "title": "roadmap: track skills/plugins/marketplace ecosystem gap after core UX stabilizes",
-      "theme": "plugin-marketplace/ecosystem",
-      "release_bucket": "ga_ecosystem",
-      "lifecycle_status": "deferred_with_rationale",
-      "roadmap_anchor": "ROADMAP.md#13-first-class-pluginmcp-lifecycle-contract; ROADMAP.md#14-mcp-end-to-end-lifecycle-parity",
-      "dependencies": ["plugin/MCP lifecycle contract", "extension point inventory", "discovery/install/update flow design"],
-      "verification_required": ["extension point inventory exists", "marketplace work explicitly depends on core UX stabilization"],
-      "deferral_rationale": "Marketplace breadth should wait until core setup/auth/provider/session UX and plugin lifecycle are reliable.",
-      "classification_rationale": "Matches plan's ga_ecosystem/post-2.0 caution for marketplace parity."
-    }
-  ],
-  "parity_rows": [
-    {
-      "id": "CC2-PARITY-OPENCODE-PLUGIN-ECOSYSTEM",
-      "source_anchor": "anomalyco/opencode@27ac53aa packages/app/web/desktop/plugin/sdk/extensions/zed/slack/containers plus issue #3038",
-      "source_type": "repo_clone_and_local_issue",
-      "title": "Plugin/skills/marketplace ecosystem inventory",
-      "release_bucket": "ga_ecosystem",
-      "lifecycle_status": "deferred_with_rationale",
-      "dependencies": ["Claw plugin/MCP lifecycle contract", "current extension-point inventory"],
-      "verification_required": ["inventory maps current Claw plugin/skill/MCP extension points before marketplace implementation"],
-      "deferral_rationale": "Adapt ecosystem discovery only after core setup/provider/session reliability is stable."
-    },
-    {
-      "id": "CC2-PARITY-OPENCODE-PERMISSION-PRESETS",
-      "source_anchor": "https://github.com/anomalyco/opencode/issues/27464 and ROADMAP.md#11-policy-engine-for-autonomous-coding",
-      "source_type": "external_issue_and_roadmap",
-      "title": "Quick permission preset switching mapped onto Claw policy profiles",
-      "release_bucket": "beta_adoption",
-      "lifecycle_status": "open",
-      "dependencies": ["policy profile model", "approval-token audit trail"],
-      "verification_required": ["preset switch is visible in status/report output and cannot bypass path-scope enforcement"],
-      "deferral_rationale": null
-    },
-    {
-      "id": "CC2-PARITY-OPENCODE-CUSTOM-PROVIDER-PARAMS",
-      "source_anchor": "https://github.com/anomalyco/opencode/issues/27462 and #3030/#3032",
-      "source_type": "external_issue_and_local_issue",
-      "title": "Custom API parameter passthrough for provider profiles",
-      "release_bucket": "beta_adoption",
-      "lifecycle_status": "open",
-      "dependencies": ["provider profile schema", "secret redaction", "request audit surface"],
-      "verification_required": ["custom params are schema-validated, redacted, and visible as provenance without leaking secrets"],
-      "deferral_rationale": null
-    },
-    {
-      "id": "CC2-PARITY-OPENCODE-TODOWRITE-AUTOCOMPLETE",
-      "source_anchor": "https://github.com/anomalyco/opencode/issues/27453 and ROADMAP.md#10-typed-task-packet-format",
-      "source_type": "external_issue_and_roadmap",
-      "title": "Task/Todo completion assistance via typed task lifecycle",
-      "release_bucket": "ga_ecosystem",
-      "lifecycle_status": "deferred_with_rationale",
-      "dependencies": ["typed task packet", "task lifecycle events", "evidence-gated completion"],
-      "verification_required": ["auto-complete suggestions cannot mark work complete without evidence bundle or explicit user approval"],
-      "deferral_rationale": "Useful UX should follow, not precede, typed task lifecycle and evidence contract."
-    },
-    {
-      "id": "CC2-PARITY-OPENCODE-WINDOWS-DISTRIBUTION",
-      "source_anchor": "https://github.com/anomalyco/opencode/issues/27476 https://github.com/anomalyco/opencode/issues/27459 https://github.com/anomalyco/opencode/issues/27470 and #3006/#3029",
-      "source_type": "external_issues_and_local_issues",
-      "title": "Windows/GLIBC/distribution reliability parity lessons",
-      "release_bucket": "beta_adoption",
-      "lifecycle_status": "open",
-      "dependencies": ["install artifact matrix", "Windows encoding guidance", "minimum Linux/GLIBC support statement"],
-      "verification_required": ["release quickstart documents supported OS matrix and known terminal/encoding caveats"],
-      "deferral_rationale": null
-    },
-    {
-      "id": "CC2-PARITY-CODEX-GRANULAR-PERMISSIONS",
-      "source_anchor": "https://github.com/openai/codex/issues/22595 and Codex docs permissions/app/plugin concepts",
-      "source_type": "external_issue_and_docs",
-      "title": "Granular app/plugin permissions adapted to Claw policy engine",
-      "release_bucket": "alpha_blocker",
-      "lifecycle_status": "active",
-      "dependencies": ["permission enforcer path-scope fix", "plugin/MCP capability model", "approval-token replay protection"],
-      "verification_required": ["granular permission grants do not widen workspace path scope implicitly"],
-      "deferral_rationale": null
-    },
-    {
-      "id": "CC2-PARITY-CODEX-SESSION-RECOVERY",
-      "source_anchor": "https://github.com/openai/codex/issues/22619 https://github.com/openai/codex/issues/22597 https://github.com/openai/codex/issues/22593 and #3035",
-      "source_type": "external_issues_and_local_issue",
-      "title": "Safe local session/thread recovery without storage amplification",
-      "release_bucket": "beta_adoption",
-      "lifecycle_status": "open",
-      "dependencies": ["session enumeration", "resume latest boundary", "JSONL/storage compaction policy"],
-      "verification_required": ["recoverable sessions are discoverable and session forks avoid unbounded duplicate history"],
-      "deferral_rationale": null
-    },
-    {
-      "id": "CC2-PARITY-CODEX-PROXY-NETWORK",
-      "source_anchor": "https://github.com/openai/codex/issues/22623 and #3032",
-      "source_type": "external_issue_and_local_issue",
-      "title": "Provider/network diagnostics include proxy behavior",
-      "release_bucket": "beta_adoption",
-      "lifecycle_status": "open",
-      "dependencies": ["HTTP client proxy detection", "provider diagnostics playbook"],
-      "verification_required": ["diagnostics report whether proxy env/config is honored for provider calls"],
-      "deferral_rationale": null
-    },
-    {
-      "id": "CC2-PARITY-CODEX-CLI-AGENT-FLAG",
-      "source_anchor": "https://github.com/openai/codex/issues/22615 and ROADMAP.md#10-typed-task-packet-format",
-      "source_type": "external_issue_and_roadmap",
-      "title": "CLI flag for agent/subagent mode mapped to Claw typed task packets",
-      "release_bucket": "ga_ecosystem",
-      "lifecycle_status": "deferred_with_rationale",
-      "dependencies": ["typed task packet", "session control API", "policy-scoped worker launch"],
-      "verification_required": ["CLI agent mode cannot bypass task policy or evidence requirements"],
-      "deferral_rationale": "Implement only after core task/session control contracts are stable."
-    }
-  ],
-  "coverage": {
-    "required_latest_open_range_3028_3038": [3028, 3029, 3030, 3031, 3032, 3033, 3034, 3035, 3036, 3037, 3038],
-    "required_existing_issue_numbers": [3007, 3006, 3020, 3005, 3003, 2997, 3023, 3004],
-    "issue_rows_expected": 19,
-    "parity_rows_expected_minimum": 6
-  }
-}

.omx/cc2/issue-parity-intake.md

@@ -1,47 +0,0 @@
-# CC2 Issue / Parity Intake Mapping
-
-Generated by `worker-2` for team task 3 (`G001 issue/parity intake mapping`). This is a board-integration fragment for Stream 0; it intentionally does **not** mutate `.omx/ultragoal`.
-
-## Covered local issue clusters
-
-| Issue | Theme | Bucket | Lifecycle | Board anchor |
-|---:|---|---|---|---|
-| #3007 | security/path-scope | `alpha_blocker` | `active` | Policy engine + green-ness contract |
-| #3020 | provider/model-routing | `beta_adoption` | `open` | Provider routing/model source status |
-| #3006 | windows/install | `beta_adoption` | `open` | Immediate backlog / install readiness |
-| #3005 | provider/response-shape | `beta_adoption` | `open` | Failure taxonomy / provider diagnostics |
-| #3004 | ide/acp | `ga_ecosystem` | `deferred_with_rationale` | Plugin/MCP lifecycle maturity |
-| #3003 | session-hygiene/gitignore | `beta_adoption` | `open` | Green-ness / recovery hygiene |
-| #2997 | docs/license | `beta_adoption` | `open` | Adoption docs/license readiness |
-| #3023 | repo-hygiene/anti-slop | `beta_adoption` | `open` | Immediate backlog / PR quality gate |
-| #3028 | docs/navigation-context | `beta_adoption` | `open` | Human UX leaks into claw workflows |
-| #3029 | install/distribution | `beta_adoption` | `open` | Cross-platform release quickstart |
-| #3030 | provider/setup-profiles | `beta_adoption` | `open` | Boot preflight / structured session control |
-| #3031 | session-recovery/context-window | `beta_adoption` | `open` | Recovery recipes / compaction event |
-| #3032 | provider/diagnostics-docs | `beta_adoption` | `open` | Failure taxonomy |
-| #3033 | engine-api/control-plane | `ga_ecosystem` | `deferred_with_rationale` | Structured session control API |
-| #3034 | sdlc/evidence-handoff | `post_2_0_research` | `deferred_with_rationale` | Event/report/task contract input |
-| #3035 | session-resume/discoverability | `beta_adoption` | `open` | Recovery recipes / session enumeration |
-| #3036 | provider/local-docs | `beta_adoption` | `open` | Provider setup and diagnostics docs |
-| #3037 | docs/product-positioning | `beta_adoption` | `open` | Goal / definition of clawable |
-| #3038 | plugin-marketplace/ecosystem | `ga_ecosystem` | `deferred_with_rationale` | Plugin/MCP lifecycle maturity |
-
-## Parity intake rows
-
-| Row | Source | Bucket | Lifecycle | Adaptation rule |
-|---|---|---|---|---|
-| `CC2-PARITY-OPENCODE-PLUGIN-ECOSYSTEM` | opencode repo + #3038 | `ga_ecosystem` | `deferred_with_rationale` | Inventory Claw extension points before marketplace work. |
-| `CC2-PARITY-OPENCODE-PERMISSION-PRESETS` | opencode #27464 | `beta_adoption` | `open` | Permission preset UX must not bypass Claw path-scope policy. |
-| `CC2-PARITY-OPENCODE-CUSTOM-PROVIDER-PARAMS` | opencode #27462 + #3030/#3032 | `beta_adoption` | `open` | Custom provider params need schema validation, redaction, and provenance. |
-| `CC2-PARITY-OPENCODE-TODOWRITE-AUTOCOMPLETE` | opencode #27453 | `ga_ecosystem` | `deferred_with_rationale` | Auto-complete task UX follows typed task lifecycle/evidence gates. |
-| `CC2-PARITY-OPENCODE-WINDOWS-DISTRIBUTION` | opencode #27476/#27459/#27470 + #3006/#3029 | `beta_adoption` | `open` | Use external pain as release-matrix and diagnostics evidence. |
-| `CC2-PARITY-CODEX-GRANULAR-PERMISSIONS` | Codex #22595 + docs | `alpha_blocker` | `active` | Adapt granular permissions only through Claw policy engine and approval tokens. |
-| `CC2-PARITY-CODEX-SESSION-RECOVERY` | Codex #22619/#22597/#22593 + #3035 | `beta_adoption` | `open` | Session discovery/recovery must avoid storage amplification. |
-| `CC2-PARITY-CODEX-PROXY-NETWORK` | Codex #22623 + #3032 | `beta_adoption` | `open` | Provider diagnostics should expose proxy behavior. |
-| `CC2-PARITY-CODEX-CLI-AGENT-FLAG` | Codex #22615 | `ga_ecosystem` | `deferred_with_rationale` | CLI agent mode waits for typed task/session control contracts. |
-
-Validation command:
-
-```bash
-python3 .omx/cc2/validate_issue_parity_intake.py
-```

.omx/cc2/render_board_md.py

@@ -1,250 +0,0 @@
-#!/usr/bin/env python3
-"""Render the Claw Code 2.0 canonical board JSON as a human-readable Markdown board."""
-from __future__ import annotations
-
-import argparse
-import json
-import sys
-from collections import Counter, defaultdict
-from pathlib import Path
-from typing import Any
-
-STATUS_DESCRIPTIONS = {
-    "context": "Context-only heading or evidence anchor; not an implementation work item.",
-    "active": "Current Claw Code 2.0 implementation surface that should remain visible on the board.",
-    "open": "Actionable unresolved work that needs implementation or acceptance evidence.",
-    "done_verify": "Marked as done upstream but retained for verification against current CC2 behavior.",
-    "stale_done": "Historically completed or merged work that may be stale and needs freshness checks before relying on it.",
-    "superseded": "Replaced by a newer item; keep as traceability context only.",
-    "deferred_with_rationale": "Intentionally deferred; rationale must be present in the board item.",
-    "rejected_not_claw": "Excluded because it is not Claw Code product work.",
-}
-
-BUCKET_DESCRIPTIONS = {
-    "alpha_blocker": "Must be resolved before alpha-quality autonomous coding lanes are dependable.",
-    "beta_adoption": "Important for broader dogfood/adoption once alpha blockers are controlled.",
-    "ga_ecosystem": "Required for mature plugin/MCP/provider ecosystem behavior.",
-    "2.x_intake": "Post-2.0 intake or follow-up candidate retained for sequencing.",
-    "post_2_0_research": "Research-oriented item not required for the CC2 board cut.",
-    "context": "Non-actionable roadmap context.",
-    "rejected_not_claw": "Explicit non-Claw rejection bucket.",
-}
-
-LANE_TITLES = {
-    "stream_0_governance": "Stream 0 — Governance, intake, and cross-cutting roadmap triage",
-    "stream_1_worker_boot_session_control": "Stream 1 — Worker boot and session control",
-    "stream_2_event_reporting_contracts": "Stream 2 — Event/reporting contracts",
-    "stream_3_branch_test_recovery": "Stream 3 — Branch/test recovery",
-    "stream_4_claws_first_execution": "Stream 4 — Claws-first task execution",
-    "stream_5_plugin_mcp_lifecycle": "Stream 5 — Plugin/MCP lifecycle",
-    "adoption_overlay": "Adoption overlay — user-visible parity and release polish",
-    "parity_overlay": "Parity overlay — opencode/codex comparison context",
-}
-
-REQUIRED_ITEM_FIELDS = [
-    "id",
-    "title",
-    "source_anchor",
-    "source_type",
-    "release_bucket",
-    "lifecycle_status",
-    "dependencies",
-    "verification_required",
-    "deferral_rationale",
-]
-
-
-def load_board(path: Path) -> dict[str, Any]:
-    with path.open() as f:
-        board = json.load(f)
-    if not isinstance(board, dict):
-        raise ValueError("board JSON root must be an object")
-    items = board.get("items")
-    if not isinstance(items, list):
-        raise ValueError("board JSON must contain an items array")
-    return board
-
-
-def validate_board(board: dict[str, Any]) -> list[str]:
-    errors: list[str] = []
-    coverage = board.get("coverage", {})
-    if coverage.get("unmapped_roadmap_heading_lines"):
-        errors.append(f"unmapped roadmap heading lines: {coverage['unmapped_roadmap_heading_lines']}")
-    if coverage.get("roadmap_headings_mapped") != coverage.get("roadmap_headings_total"):
-        errors.append("roadmap heading coverage is incomplete")
-    if coverage.get("roadmap_actions_mapped") != coverage.get("roadmap_actions_total"):
-        errors.append("roadmap ordered-action coverage is incomplete")
-
-    allowed_status = set(board.get("generation_policy", {}).get("status_values", []))
-    allowed_buckets = set(board.get("generation_policy", {}).get("release_buckets", []))
-    seen_ids: set[str] = set()
-    for index, item in enumerate(board["items"], 1):
-        for field in REQUIRED_ITEM_FIELDS:
-            if field not in item:
-                errors.append(f"item {index} missing required field {field}")
-        item_id = item.get("id")
-        if item_id in seen_ids:
-            errors.append(f"duplicate item id {item_id}")
-        seen_ids.add(item_id)
-        status = item.get("lifecycle_status")
-        bucket = item.get("release_bucket")
-        if allowed_status and status not in allowed_status:
-            errors.append(f"{item_id} has unknown lifecycle_status {status!r}")
-        if allowed_buckets and bucket not in allowed_buckets:
-            errors.append(f"{item_id} has unknown release_bucket {bucket!r}")
-        if status == "deferred_with_rationale" and not str(item.get("deferral_rationale", "")).strip():
-            errors.append(f"{item_id} is deferred without deferral_rationale")
-    return errors
-
-
-def table(headers: list[str], rows: list[list[Any]]) -> list[str]:
-    out = ["| " + " | ".join(headers) + " |", "| " + " | ".join("---" for _ in headers) + " |"]
-    for row in rows:
-        out.append("| " + " | ".join(str(cell) for cell in row) + " |")
-    return out
-
-
-def fmt_list(value: Any) -> str:
-    if not value:
-        return "none"
-    if isinstance(value, list):
-        return ", ".join(f"`{v}`" for v in value) if value else "none"
-    return f"`{value}`"
-
-
-def render(board: dict[str, Any]) -> str:
-    items: list[dict[str, Any]] = board["items"]
-    summary = board.get("summary", {})
-    coverage = board.get("coverage", {})
-    sources = board.get("sources", {})
-    policy = board.get("generation_policy", {})
-    by_lane = Counter(item.get("owner_lane", "unassigned") for item in items)
-    by_status = Counter(item.get("lifecycle_status", "unknown") for item in items)
-    by_bucket = Counter(item.get("release_bucket", "unknown") for item in items)
-    by_source = Counter(item.get("source_type", "unknown") for item in items)
-
-    lines: list[str] = []
-    lines.append("# Claw Code 2.0 Canonical Board")
-    lines.append("")
-    lines.append(f"Generated from board schema: `{board.get('generated_at', 'unknown')}`")
-    lines.append(f"Schema version: `{board.get('schema_version', 'unknown')}`")
-    lines.append("Ultragoal mutation policy: `.omx/ultragoal` is leader-owned and was not modified by this rendering task.")
-    lines.append("")
-
-    lines.append("## Evidence Freeze")
-    lines.append("")
-    roadmap = sources.get("roadmap", {})
-    research = sources.get("research", {})
-    plan = sources.get("approved_plan", {})
-    lines.extend(table(["Source", "Frozen evidence"], [
-        ["Roadmap", f"`{roadmap.get('path', 'ROADMAP.md')}` sha256 prefix `{roadmap.get('sha256_prefix', 'unknown')}`; {roadmap.get('heading_count', '?')} headings; {roadmap.get('ordered_action_count', '?')} ordered actions"],
-        ["Approved plan", f"`{plan.get('path', '.omx/plans/claw-code-2-0-adaptive-plan.md')}` sha256 prefix `{plan.get('sha256_prefix', 'unknown')}`"],
-        ["Research bundle", f"root `{research.get('root', '.omx/research')}`; latest open issues {research.get('claw_open_latest_count', '?')}; issue corpus {research.get('claw_issues_count', '?')}; codex/opencode clone metadata included"],
-    ]))
-    lines.append("")
-
-    lines.append("## Roadmap Coverage Summary")
-    lines.append("")
-    heading_total = coverage.get("roadmap_headings_total", 0)
-    heading_mapped = coverage.get("roadmap_headings_mapped", 0)
-    action_total = coverage.get("roadmap_actions_total", 0)
-    action_mapped = coverage.get("roadmap_actions_mapped", 0)
-    lines.extend(table(["Coverage gate", "Mapped", "Total", "Status"], [
-        ["ROADMAP headings", heading_mapped, heading_total, "PASS" if heading_mapped == heading_total and not coverage.get("unmapped_roadmap_heading_lines") else "FAIL"],
-        ["ROADMAP ordered actions", action_mapped, action_total, "PASS" if action_mapped == action_total else "FAIL"],
-        ["Duplicate heading lines", len(coverage.get("duplicate_roadmap_heading_lines", [])), 0, "PASS" if not coverage.get("duplicate_roadmap_heading_lines") else "WARN"],
-    ]))
-    lines.append("")
-    lines.append(f"Total canonical board items: **{len(items)}**")
-    lines.append("")
-
-    lines.append("## Lifecycle Enum Reference")
-    lines.append("")
-    status_rows = []
-    for status in policy.get("status_values", sorted(by_status)):
-        status_rows.append([f"`{status}`", by_status.get(status, 0), STATUS_DESCRIPTIONS.get(status, "Board-defined lifecycle status.")])
-    lines.extend(table(["Lifecycle", "Count", "Meaning"], status_rows))
-    lines.append("")
-
-    lines.append("## Release Bucket Reference")
-    lines.append("")
-    bucket_rows = []
-    for bucket in policy.get("release_buckets", sorted(by_bucket)):
-        bucket_rows.append([f"`{bucket}`", by_bucket.get(bucket, 0), BUCKET_DESCRIPTIONS.get(bucket, "Board-defined release bucket.")])
-    lines.extend(table(["Bucket", "Count", "Meaning"], bucket_rows))
-    lines.append("")
-
-    lines.append("## Stream Summaries")
-    lines.append("")
-    lane_rows = []
-    for lane, count in sorted(by_lane.items()):
-        lane_items = [item for item in items if item.get("owner_lane") == lane]
-        lane_status = Counter(item.get("lifecycle_status") for item in lane_items)
-        open_like = lane_status.get("active", 0) + lane_status.get("open", 0) + lane_status.get("done_verify", 0)
-        lane_rows.append([
-            LANE_TITLES.get(lane, lane),
-            count,
-            open_like,
-            ", ".join(f"`{k}` {v}" for k, v in sorted(lane_status.items())),
-        ])
-    lines.extend(table(["Stream / lane", "Items", "Active+open+verify", "Lifecycle mix"], lane_rows))
-    lines.append("")
-
-    lines.append("## Source-Type Mix")
-    lines.append("")
-    lines.extend(table(["Source type", "Items"], [[f"`{k}`", v] for k, v in sorted(by_source.items())]))
-    lines.append("")
-
-    lines.append("## Board Items by Stream")
-    lines.append("")
-    for lane in sorted(by_lane):
-        lane_items = [item for item in items if item.get("owner_lane") == lane]
-        lines.append(f"### {LANE_TITLES.get(lane, lane)}")
-        lines.append("")
-        lines.extend(table(
-            ["ID", "Title", "Source", "Bucket", "Lifecycle", "Verification", "Dependencies", "Deferral"],
-            [[
-                f"`{item.get('id')}`",
-                str(item.get("title", "")).replace("|", "\\|"),
-                f"`{item.get('source_anchor')}` / `{item.get('source_type')}`",
-                f"`{item.get('release_bucket')}`",
-                f"`{item.get('lifecycle_status')}`",
-                f"`{item.get('verification_required')}`",
-                fmt_list(item.get("dependencies")),
-                str(item.get("deferral_rationale") or "—").replace("|", "\\|"),
-            ] for item in lane_items]
-        ))
-        lines.append("")
-
-    return "\n".join(lines).rstrip() + "\n"
-
-
-def main() -> int:
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("board_json", type=Path)
-    parser.add_argument("board_md", type=Path)
-    parser.add_argument("--check", action="store_true", help="fail if board_md is not up to date")
-    args = parser.parse_args()
-
-    board = load_board(args.board_json)
-    errors = validate_board(board)
-    if errors:
-        for error in errors:
-            print(f"ERROR: {error}", file=sys.stderr)
-        return 1
-    rendered = render(board)
-    if args.check:
-        existing = args.board_md.read_text() if args.board_md.exists() else ""
-        if existing != rendered:
-            print(f"ERROR: {args.board_md} is not up to date", file=sys.stderr)
-            return 1
-        print(f"PASS: {args.board_md} is up to date and roadmap coverage is complete")
-        return 0
-    args.board_md.parent.mkdir(parents=True, exist_ok=True)
-    args.board_md.write_text(rendered)
-    print(f"wrote {args.board_md}")
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

.omx/cc2/validate_issue_parity_intake.py

@@ -1,58 +0,0 @@
-#!/usr/bin/env python3
-"""Validate the worker-2 CC2 issue/parity intake fragment."""
-from __future__ import annotations
-
-import json
-from pathlib import Path
-
-ROOT = Path(__file__).resolve().parents[2]
-INTAKE = ROOT / ".omx" / "cc2" / "issue-parity-intake.json"
-REQUIRED_ISSUES = set(range(3028, 3039)) | {3007, 3006, 3020, 3005, 3003, 2997, 3023, 3004}
-ALLOWED_STATUS = {
-    "context",
-    "active",
-    "open",
-    "done_verify",
-    "stale_done",
-    "superseded",
-    "deferred_with_rationale",
-    "rejected_not_claw",
-}
-ALLOWED_BUCKETS = {"alpha_blocker", "beta_adoption", "ga_ecosystem", "post_2_0_research"}
-
-
-def require(condition: bool, message: str) -> None:
-    if not condition:
-        raise SystemExit(f"FAIL: {message}")
-
-
-def main() -> None:
-    data = json.loads(INTAKE.read_text())
-    issue_rows = data.get("issue_clusters", [])
-    parity_rows = data.get("parity_rows", [])
-
-    seen = {row.get("source_number") for row in issue_rows}
-    missing = sorted(REQUIRED_ISSUES - seen)
-    extra = sorted(seen - REQUIRED_ISSUES)
-    require(not missing, f"missing required issue rows: {missing}")
-    require(not extra, f"unexpected issue rows in scoped intake: {extra}")
-    require(len(issue_rows) == len(REQUIRED_ISSUES), "duplicate or missing issue row count")
-
-    ids = [row.get("id") for row in issue_rows + parity_rows]
-    require(len(ids) == len(set(ids)), "duplicate ids present")
-
-    for row in issue_rows + parity_rows:
-        row_id = row.get("id")
-        for field in ["source_anchor", "source_type", "release_bucket", "lifecycle_status", "dependencies", "verification_required"]:
-            require(row.get(field) not in (None, "", []), f"{row_id} missing {field}")
-        require(row["release_bucket"] in ALLOWED_BUCKETS, f"{row_id} invalid release_bucket {row['release_bucket']}")
-        require(row["lifecycle_status"] in ALLOWED_STATUS, f"{row_id} invalid lifecycle_status {row['lifecycle_status']}")
-        if row["lifecycle_status"] == "deferred_with_rationale":
-            require(row.get("deferral_rationale"), f"{row_id} deferred without rationale")
-
-    require(len(parity_rows) >= data["coverage"]["parity_rows_expected_minimum"], "not enough parity rows")
-    print(f"PASS issue/parity intake: {len(issue_rows)} issue rows, {len(parity_rows)} parity rows")
-
-
-if __name__ == "__main__":
-    main()

.port_sessions/b035f648d5b549aa836ea01f6727ec62.json

@@ -1,8 +0,0 @@
-{
-  "session_id": "b035f648d5b549aa836ea01f6727ec62",
-  "messages": [
-    "review MCP tool"
-  ],
-  "input_tokens": 3,
-  "output_tokens": 13
-}

.port_sessions/b234acb1eb8c486e80544ddc7e13e6d8.json

@@ -1,9 +0,0 @@
-{
-  "session_id": "b234acb1eb8c486e80544ddc7e13e6d8",
-  "messages": [
-    "review MCP tool",
-    "review MCP tool"
-  ],
-  "input_tokens": 6,
-  "output_tokens": 32
-}

.port_sessions/b67e062748f04e10ac5770df9285e4bd.json

@@ -1,9 +0,0 @@
-{
-  "session_id": "b67e062748f04e10ac5770df9285e4bd",
-  "messages": [
-    "review MCP tool",
-    "review MCP tool"
-  ],
-  "input_tokens": 6,
-  "output_tokens": 32
-}

.port_sessions/bb88fd20433840a8b19237e3f306c6e3.json

@@ -1,9 +0,0 @@
-{
-  "session_id": "bb88fd20433840a8b19237e3f306c6e3",
-  "messages": [
-    "review MCP tool",
-    "review MCP tool"
-  ],
-  "input_tokens": 6,
-  "output_tokens": 32
-}

CLAUDE.md

@@ -7,7 +7,7 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 - Frameworks: none detected from the supported starter markers.
 
 ## Verification
-- Run Rust verification from repo root: `scripts/fmt.sh --check`; for formatting use `scripts/fmt.sh`. Run Rust clippy/tests from `rust/`: `cargo clippy --workspace --all-targets -- -D warnings`, `cargo test --workspace`
+- Run Rust verification from `rust/`: `cargo fmt`, `cargo clippy --workspace --all-targets -- -D warnings`, `cargo test --workspace`
 - `src/` and `tests/` are both present; update both surfaces together when behavior changes.
 
 ## Repository shape

Containerfile

@@ -1,13 +0,0 @@
-FROM rust:bookworm
-
-RUN apt-get update \
-    && apt-get install -y --no-install-recommends \
-        ca-certificates \
-        git \
-        libssl-dev \
-        pkg-config \
-    && rm -rf /var/lib/apt/lists/*
-
-ENV CARGO_TERM_COLOR=always
-WORKDIR /workspace
-CMD ["bash"]

PARITY.md

@@ -1,187 +1,214 @@
-# Parity Status — claw-code Rust Port
+# PARITY GAP ANALYSIS
 
-Last updated: 2026-04-03
+Scope: read-only comparison between the original TypeScript source at `/home/bellman/Workspace/claude-code/src/` and the Rust port under `rust/crates/`.
 
-## Summary
+Method: compared feature surfaces, registries, entrypoints, and runtime plumbing only. No TypeScript source was copied.
 
-- 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`.
+## Executive summary
 
-## Mock parity harness — milestone 1
+The Rust port has a good foundation for:
+- Anthropic API/OAuth basics
+- local conversation/session state
+- a core tool loop
+- MCP stdio/bootstrap support
+- CLAUDE.md discovery
+- a small but usable built-in tool set
 
-- [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`
+It is **not feature-parity** with the TypeScript CLI.
 
-## Mock parity harness — milestone 2 (behavioral expansion)
+Largest gaps:
+- **plugins** are effectively absent in Rust
+- **hooks** are parsed but not executed in Rust
+- **CLI breadth** is much narrower in Rust
+- **skills** are local-file only in Rust, without the TS registry/bundled pipeline
+- **assistant orchestration** lacks TS hook-aware orchestration and remote/structured transports
+- **services** beyond core API/OAuth/MCP are mostly missing in Rust
 
-- [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
+## tools/
 
-Canonical scenario map: `rust/mock_parity_scenarios.json`
+### TS exists
+Evidence:
+- `src/tools/` contains broad tool families including `AgentTool`, `AskUserQuestionTool`, `BashTool`, `ConfigTool`, `FileReadTool`, `FileWriteTool`, `GlobTool`, `GrepTool`, `LSPTool`, `ListMcpResourcesTool`, `MCPTool`, `McpAuthTool`, `ReadMcpResourceTool`, `RemoteTriggerTool`, `ScheduleCronTool`, `SkillTool`, `Task*`, `Team*`, `TodoWriteTool`, `ToolSearchTool`, `WebFetchTool`, `WebSearchTool`.
+- Tool execution/orchestration is split across `src/services/tools/StreamingToolExecutor.ts`, `src/services/tools/toolExecution.ts`, `src/services/tools/toolHooks.ts`, and `src/services/tools/toolOrchestration.ts`.
 
-- Multi-tool assistant turns
-- Bash flow roundtrips
-- Permission enforcement across tool paths
-- Plugin tool execution path
-- File tools — harness-validated flows
-- Streaming response support validated by the mock parity harness
+### Rust exists
+Evidence:
+- Tool registry is centralized in `rust/crates/tools/src/lib.rs` via `mvp_tool_specs()`.
+- Current built-ins include shell/file/search/web/todo/skill/agent/config/notebook/repl/powershell primitives.
+- Runtime execution is wired through `rust/crates/tools/src/lib.rs` and `rust/crates/runtime/src/conversation.rs`.
 
-## 9-lane checkpoint
+### Missing or broken in Rust
+- No Rust equivalents for major TS tools such as `AskUserQuestionTool`, `LSPTool`, `ListMcpResourcesTool`, `MCPTool`, `McpAuthTool`, `ReadMcpResourceTool`, `RemoteTriggerTool`, `ScheduleCronTool`, `Task*`, `Team*`, and several workflow/system tools.
+- Rust tool surface is still explicitly an MVP registry, not a parity registry.
+- Rust lacks TS’s layered tool orchestration split.
 
-| 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`) |
+**Status:** partial core only.
 
-## Lane details
+---
 
-### Lane 1 — Bash validation
+## hooks/
 
-- **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.
+### TS exists
+Evidence:
+- Hook command surface under `src/commands/hooks/`.
+- Runtime hook machinery in `src/services/tools/toolHooks.ts` and `src/services/tools/toolExecution.ts`.
+- TS supports `PreToolUse`, `PostToolUse`, and broader hook-driven behaviors configured through settings and documented in `src/skills/bundled/updateConfig.ts`.
 
-### Bash tool — upstream has 18 submodules, Rust has 1:
+### Rust exists
+Evidence:
+- Hook config is parsed and merged in `rust/crates/runtime/src/config.rs`.
+- Hook config can be inspected via Rust config reporting in `rust/crates/commands/src/lib.rs` and `rust/crates/rusty-claude-cli/src/main.rs`.
+- Prompt guidance mentions hooks in `rust/crates/runtime/src/prompt.rs`.
 
-- 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`.
+### Missing or broken in Rust
+- No actual hook execution pipeline in `rust/crates/runtime/src/conversation.rs`.
+- No PreToolUse/PostToolUse mutation/deny/rewrite/result-hook behavior.
+- No Rust `/hooks` parity command.
 
-### Lane 2 — CI fix
+**Status:** config-only; runtime behavior missing.
 
-- **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.
+---
 
-### Lane 3 — File-tool
+## plugins/
 
-- **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.
+### TS exists
+Evidence:
+- Built-in plugin scaffolding in `src/plugins/builtinPlugins.ts` and `src/plugins/bundled/index.ts`.
+- Plugin lifecycle/services in `src/services/plugins/PluginInstallationManager.ts` and `src/services/plugins/pluginOperations.ts`.
+- CLI/plugin command surface under `src/commands/plugin/` and `src/commands/reload-plugins/`.
 
-### File tools — harness-validated flows
+### Rust exists
+Evidence:
+- No dedicated plugin subsystem appears under `rust/crates/`.
+- Repo-wide Rust references to plugins are effectively absent beyond text/help mentions.
 
-- `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.
+### Missing or broken in Rust
+- No plugin loader.
+- No marketplace install/update/enable/disable flow.
+- No `/plugin` or `/reload-plugins` parity.
+- No plugin-provided hook/tool/command/MCP extension path.
 
-### Lane 4 — TaskRegistry
+**Status:** missing.
 
-- **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.
+---
 
-### Lane 5 — Task wiring
+## skills/ and CLAUDE.md discovery
 
-- **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()`.
+### TS exists
+Evidence:
+- Skill loading/registry pipeline in `src/skills/loadSkillsDir.ts`, `src/skills/bundledSkills.ts`, and `src/skills/mcpSkillBuilders.ts`.
+- Bundled skills under `src/skills/bundled/`.
+- Skills command surface under `src/commands/skills/`.
 
-### Lane 6 — Team+Cron
+### Rust exists
+Evidence:
+- `Skill` tool in `rust/crates/tools/src/lib.rs` resolves and reads local `SKILL.md` files.
+- CLAUDE.md discovery is implemented in `rust/crates/runtime/src/prompt.rs`.
+- Rust supports `/memory` and `/init` via `rust/crates/commands/src/lib.rs` and `rust/crates/rusty-claude-cli/src/main.rs`.
 
-- **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.
+### Missing or broken in Rust
+- No bundled skill registry equivalent.
+- No `/skills` command.
+- No MCP skill-builder pipeline.
+- No TS-style live skill discovery/reload/change handling.
+- No comparable session-memory / team-memory integration around skills.
 
-### Lane 7 — MCP lifecycle
+**Status:** basic local skill loading only.
 
-- **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
+## cli/
 
-- **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.
+### TS exists
+Evidence:
+- Large command surface under `src/commands/` including `agents`, `hooks`, `mcp`, `memory`, `model`, `permissions`, `plan`, `plugin`, `resume`, `review`, `skills`, `tasks`, and many more.
+- Structured/remote transport stack in `src/cli/structuredIO.ts`, `src/cli/remoteIO.ts`, and `src/cli/transports/*`.
+- CLI handler split in `src/cli/handlers/*`.
 
-### Lane 9 — Permission enforcement
+### Rust exists
+Evidence:
+- Shared slash command registry in `rust/crates/commands/src/lib.rs`.
+- Rust slash commands currently cover `help`, `status`, `compact`, `model`, `permissions`, `clear`, `cost`, `resume`, `config`, `memory`, `init`, `diff`, `version`, `export`, `session`.
+- Main CLI/repl/prompt handling lives in `rust/crates/rusty-claude-cli/src/main.rs`.
 
-- **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.
+### Missing or broken in Rust
+- Missing major TS command families: `/agents`, `/hooks`, `/mcp`, `/plugin`, `/skills`, `/plan`, `/review`, `/tasks`, and many others.
+- No Rust equivalent to TS structured IO / remote transport layers.
+- No TS-style handler decomposition for auth/plugins/MCP/agents.
+- JSON prompt mode is improved on this branch, but still not clean transport parity: empirical verification shows tool-capable JSON output can emit human-readable tool-result lines before the final JSON object.
 
-### Permission enforcement across tool paths
+**Status:** functional local CLI core, much narrower than TS.
 
-- 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`
+## assistant/ (agentic loop, streaming, tool calling)
 
-- `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()`.
+### TS exists
+Evidence:
+- Assistant/session surface at `src/assistant/sessionHistory.ts`.
+- Tool orchestration in `src/services/tools/StreamingToolExecutor.ts`, `src/services/tools/toolExecution.ts`, `src/services/tools/toolOrchestration.ts`.
+- Remote/structured streaming layers in `src/cli/structuredIO.ts` and `src/cli/remoteIO.ts`.
 
-### Still limited or intentionally shallow
+### Rust exists
+Evidence:
+- Core loop in `rust/crates/runtime/src/conversation.rs`.
+- Stream/tool event translation in `rust/crates/rusty-claude-cli/src/main.rs`.
+- Session persistence in `rust/crates/runtime/src/session.rs`.
 
-- `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.
+### Missing or broken in Rust
+- No TS-style hook-aware orchestration layer.
+- No TS structured/remote assistant transport stack.
+- No richer TS assistant/session-history/background-task integration.
+- JSON output path is no longer single-turn only on this branch, but output cleanliness still lags TS transport expectations.
 
-## Reconciled from the older PARITY checklist
+**Status:** strong core loop, missing orchestration layers.
 
-- [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
+## services/ (API client, auth, models, MCP)
 
-- [ ] End-to-end MCP runtime lifecycle beyond the registry bridge now on `main`
-- [x] 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
+### TS exists
+Evidence:
+- API services under `src/services/api/*`.
+- OAuth services under `src/services/oauth/*`.
+- MCP services under `src/services/mcp/*`.
+- Additional service layers for analytics, prompt suggestion, session memory, plugin operations, settings sync, policy limits, team memory sync, notifier, voice, and more under `src/services/*`.
 
-## Migration Readiness
+### Rust exists
+Evidence:
+- Core Anthropic API client in `rust/crates/api/src/{client,error,sse,types}.rs`.
+- OAuth support in `rust/crates/runtime/src/oauth.rs`.
+- MCP config/bootstrap/client support in `rust/crates/runtime/src/{config,mcp,mcp_client,mcp_stdio}.rs`.
+- Usage accounting in `rust/crates/runtime/src/usage.rs`.
+- Remote upstream-proxy support in `rust/crates/runtime/src/remote.rs`.
 
-- [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
-- [ ] CI green on every commit
-- [x] Codebase shape clean enough for handoff documentation
+### Missing or broken in Rust
+- Most TS service ecosystem beyond core messaging/auth/MCP is absent.
+- No TS-equivalent plugin service layer.
+- No TS-equivalent analytics/settings-sync/policy-limit/team-memory subsystems.
+- No TS-style MCP connection-manager/UI layer.
+- Model/provider ergonomics remain thinner than TS.
+
+**Status:** core foundation exists; broader service ecosystem missing.
+
+---
+
+## Critical bug status in this worktree
+
+### Fixed
+- **Prompt mode tools enabled**
+  - `rust/crates/rusty-claude-cli/src/main.rs` now constructs prompt mode with `LiveCli::new(model, true, ...)`.
+- **Default permission mode = DangerFullAccess**
+  - Runtime default now resolves to `DangerFullAccess` in `rust/crates/rusty-claude-cli/src/main.rs`.
+  - Clap default also uses `DangerFullAccess` in `rust/crates/rusty-claude-cli/src/args.rs`.
+  - Init template writes `dontAsk` in `rust/crates/rusty-claude-cli/src/init.rs`.
+- **Streaming `{}` tool-input prefix bug**
+  - `rust/crates/rusty-claude-cli/src/main.rs` now strips the initial empty object only for streaming tool input, while preserving legitimate `{}` in non-stream responses.
+- **Unlimited max_iterations**
+  - Verified at `rust/crates/runtime/src/conversation.rs` with `usize::MAX`.
+
+### Remaining notable parity issue
+- **JSON prompt output cleanliness**
+  - Tool-capable JSON mode now loops, but empirical verification still shows pre-JSON human-readable tool-result output when tools fire.

PHILOSOPHY.md

@@ -1,114 +0,0 @@
-# Claw Code Philosophy
-
-## Stop Staring at the Files
-
-If you only look at the generated files in this repository, you are looking at the wrong layer.
-
-The Python rewrite was a byproduct. The Rust rewrite was also a byproduct. The real thing worth studying is the **system that produced them**: a clawhip-based coordination loop where humans give direction and autonomous claws execute the work.
-
-Claw Code is not just a codebase. It is a public demonstration of what happens when:
-
-- a human provides clear direction,
-- multiple coding agents coordinate in parallel,
-- notification routing is pushed out of the agent context window,
-- planning, execution, review, and retry loops are automated,
-- and the human does **not** sit in a terminal micromanaging every step.
-
-## The Human Interface Is Discord
-
-The important interface here is not tmux, Vim, SSH, or a terminal multiplexer.
-
-The real human interface is a Discord channel.
-
-A person can type a sentence from a phone, walk away, sleep, or do something else. The claws read the directive, break it into tasks, assign roles, write code, run tests, argue over failures, recover, and push when the work passes.
-
-That is the philosophy: **humans set direction; claws perform the labor.**
-
-## The Three-Part System
-
-### 1. OmX (`oh-my-codex`)
-[oh-my-codex](https://github.com/Yeachan-Heo/oh-my-codex) provides the workflow layer.
-
-It turns short directives into structured execution:
-- planning keywords
-- execution modes
-- persistent verification loops
-- parallel multi-agent workflows
-
-This is the layer that converts a sentence into a repeatable work protocol.
-
-### 2. clawhip
-[clawhip](https://github.com/Yeachan-Heo/clawhip) is the event and notification router.
-
-It watches:
-- git commits
-- tmux sessions
-- GitHub issues and PRs
-- agent lifecycle events
-- channel delivery
-
-Its job is to keep monitoring and delivery **outside** the coding agent's context window so the agents can stay focused on implementation instead of status formatting and notification routing.
-
-### 3. OmO (`oh-my-openagent`)
-[oh-my-openagent](https://github.com/code-yeongyu/oh-my-openagent) handles multi-agent coordination.
-
-This is where planning, handoffs, disagreement resolution, and verification loops happen across agents.
-
-When Architect, Executor, and Reviewer disagree, OmO provides the structure for that loop to converge instead of collapse.
-
-## The Real Bottleneck Changed
-
-The bottleneck is no longer typing speed.
-
-When agent systems can rebuild a codebase in hours, the scarce resource becomes:
-- architectural clarity
-- task decomposition
-- judgment
-- taste
-- conviction about what is worth building
-- knowing which parts can be parallelized and which parts must stay constrained
-
-A fast agent team does not remove the need for thinking. It makes clear thinking even more valuable.
-
-## What Claw Code Demonstrates
-
-Claw Code demonstrates that a repository can be:
-
-- **autonomously built in public**
-- coordinated by claws/lobsters rather than human pair-programming alone
-- operated through a chat interface
-- continuously improved by structured planning/execution/review loops
-- maintained as a showcase of the coordination layer, not just the output files
-
-The code is evidence.
-The coordination system is the product lesson.
-
-## What Still Matters
-
-As coding intelligence gets cheaper and more available, the durable differentiators are not raw coding output.
-
-What still matters:
-- product taste
-- direction
-- system design
-- human trust
-- operational stability
-- judgment about what to build next
-
-In that world, the job of the human is not to out-type the machine.
-The job of the human is to decide what deserves to exist.
-
-## Short Version
-
-**Claw Code is a demo of autonomous software development.**
-
-Humans provide direction.
-Claws coordinate, build, test, recover, and push.
-The repository is the artifact.
-The philosophy is the system behind it.
-
-## Related explanation
-
-For the longer public explanation behind this philosophy, see:
-
-- https://x.com/realsigridjin/status/2039472968624185713

README.md

@@ -1,211 +1,191 @@
-# Claw Code
+# Rewriting Project Claw Code
 
 <p align="center">
-  <a href="https://github.com/ultraworkers/claw-code">ultraworkers/claw-code</a>
-  ·
-  <a href="./USAGE.md">Usage</a>
-  ·
-  <a href="./rust/README.md">Rust workspace</a>
-  ·
-  <a href="./PARITY.md">Parity</a>
-  ·
-  <a href="./ROADMAP.md">Roadmap</a>
-  ·
-  <a href="https://discord.gg/5TUQKqFWd">UltraWorkers Discord</a>
+  <strong>⭐ The fastest repo in history to surpass 50K stars, reaching the milestone in just 2 hours after publication ⭐</strong>
 </p>
 
 <p align="center">
-  <a href="https://star-history.com/#ultraworkers/claw-code&Date">
+  <a href="https://star-history.com/#instructkr/claw-code&Date">
     <picture>
-      <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/svg?repos=ultraworkers/claw-code&type=Date&theme=dark" />
-      <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/svg?repos=ultraworkers/claw-code&type=Date" />
-      <img alt="Star history for ultraworkers/claw-code" src="https://api.star-history.com/svg?repos=ultraworkers/claw-code&type=Date" width="600" />
+      <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/svg?repos=instructkr/claw-code&type=Date&theme=dark" />
+      <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/svg?repos=instructkr/claw-code&type=Date" />
+      <img alt="Star History Chart" src="https://api.star-history.com/svg?repos=instructkr/claw-code&type=Date" width="600" />
     </picture>
   </a>
 </p>
 
 <p align="center">
-  <img src="assets/claw-hero.jpeg" alt="Claw Code" width="300" />
+  <img src="assets/clawd-hero.jpeg" alt="Claw" width="300" />
 </p>
 
-Claw Code is the public Rust implementation of the `claw` CLI agent harness.
-The canonical implementation lives in [`rust/`](./rust), and the current source of truth for this repository is **ultraworkers/claw-code**.
+<p align="center">
+  <strong>Better Harness Tools, not merely storing the archive of leaked Claude Code</strong>
+</p>
+
+<p align="center">
+  <a href="https://github.com/sponsors/instructkr"><img src="https://img.shields.io/badge/Sponsor-%E2%9D%A4-pink?logo=github&style=for-the-badge" alt="Sponsor on GitHub" /></a>
+</p>
 
 > [!IMPORTANT]
-> Start with [`USAGE.md`](./USAGE.md) for build, auth, CLI, session, and parity-harness workflows. Make `claw doctor` your first health check after building, use [`rust/README.md`](./rust/README.md) for crate-level details, read [`PARITY.md`](./PARITY.md) for the current Rust-port checkpoint, and see [`docs/container.md`](./docs/container.md) for the container-first workflow.
+> **Rust port is now in progress** on the [`dev/rust`](https://github.com/instructkr/claw-code/tree/dev/rust) branch and is expected to be merged into main today. The Rust implementation aims to deliver a faster, memory-safe harness runtime. Stay tuned — this will be the definitive version of the project.
+
+> If you find this work useful, consider [sponsoring @instructkr on GitHub](https://github.com/sponsors/instructkr) to support continued open-source harness engineering research.
+
+---
+
+## Backstory
+
+At 4 AM on March 31, 2026, I woke up to my phone blowing up with notifications. The Claude Code source had been exposed, and the entire dev community was in a frenzy. My girlfriend in Korea was genuinely worried I might face legal action from Anthropic just for having the code on my machine — so I did what any engineer would do under pressure: I sat down, ported the core features to Python from scratch, and pushed it before the sun came up.
+
+The whole thing was orchestrated end-to-end using [oh-my-codex (OmX)](https://github.com/Yeachan-Heo/oh-my-codex) by [@bellman_ych](https://x.com/bellman_ych) — a workflow layer built on top of OpenAI's Codex ([@OpenAIDevs](https://x.com/OpenAIDevs)). I used `$team` mode for parallel code review and `$ralph` mode for persistent execution loops with architect-level verification. The entire porting session — from reading the original harness structure to producing a working Python tree with tests — was driven through OmX orchestration.
+
+The result is a clean-room Python rewrite that captures the architectural patterns of Claude Code's agent harness without copying any proprietary source. I'm now actively collaborating with [@bellman_ych](https://x.com/bellman_ych) — the creator of OmX himself — to push this further. The basic Python foundation is already in place and functional, but we're just getting started. **Stay tuned — a much more capable version is on the way.**
+
+https://github.com/instructkr/claw-code
+
+![Tweet screenshot](assets/tweet-screenshot.png)
+
+## The Creators Featured in Wall Street Journal For Avid Claude Code Fans
+
+I've been deeply interested in **harness engineering** — studying how agent systems wire tools, orchestrate tasks, and manage runtime context. This isn't a sudden thing. The Wall Street Journal featured my work earlier this month, documenting how I've been one of the most active power users exploring these systems:
+
+> AI startup worker Sigrid Jin, who attended the Seoul dinner, single-handedly used 25 billion of Claude Code tokens last year. At the time, usage limits were looser, allowing early enthusiasts to reach tens of billions of tokens at a very low cost.
 >
-> **ACP / Zed status:** `claw-code` does not ship an ACP/Zed daemon entrypoint yet. Run `claw acp` (or `claw --acp`) for the current status instead of guessing from source layout; `claw acp serve` is currently a discoverability alias only, and real ACP support remains tracked separately in `ROADMAP.md`.
+> Despite his countless hours with Claude Code, Jin isn't faithful to any one AI lab. The tools available have different strengths and weaknesses, he said. Codex is better at reasoning, while Claude Code generates cleaner, more shareable code.
+>
+> Jin flew to San Francisco in February for Claude Code's first birthday party, where attendees waited in line to compare notes with Cherny. The crowd included a practicing cardiologist from Belgium who had built an app to help patients navigate care, and a California lawyer who made a tool for automating building permit approvals using Claude Code.
+>
+> "It was basically like a sharing party," Jin said. "There were lawyers, there were doctors, there were dentists. They did not have software engineering backgrounds."
+>
+> — *The Wall Street Journal*, March 21, 2026, [*"The Trillion Dollar Race to Automate Our Entire Lives"*](https://lnkd.in/gs9td3qd)
 
-## Current repository shape
+![WSJ Feature](assets/wsj-feature.png)
 
-- **`rust/`** — canonical Rust workspace and the `claw` CLI binary
-- **`USAGE.md`** — task-oriented usage guide for the current product surface
-- **`PARITY.md`** — Rust-port parity status and migration notes
-- **`ROADMAP.md`** — active roadmap and cleanup backlog
-- **`PHILOSOPHY.md`** — project intent and system-design framing
-- **`src/` + `tests/`** — companion Python/reference workspace and audit helpers; not the primary runtime surface
+---
 
-## Quick start
+## Porting Status
 
-> [!NOTE]
-> [!WARNING]
-> **`cargo install claw-code` installs the wrong thing.** The `claw-code` crate on crates.io is a deprecated stub that places `claw-code-deprecated.exe` — not `claw`. Running it only prints `"claw-code has been renamed to agent-code"`. **Do not use `cargo install claw-code`.** Either build from source (this repo) or install the upstream binary:
-> ```bash
-> cargo install agent-code   # upstream binary — installs 'agent.exe' (Windows) / 'agent' (Unix), NOT 'agent-code'
-> ```
-> This repo (`ultraworkers/claw-code`) is **build-from-source only** — follow the steps below.
+The main source tree is now Python-first.
 
-```bash
-# 1. Clone and build
-git clone https://github.com/ultraworkers/claw-code
-cd claw-code/rust
-cargo build --workspace
+- `src/` contains the active Python porting workspace
+- `tests/` verifies the current Python workspace
+- the exposed snapshot is no longer part of the tracked repository state
 
-# 2. Set your API key (Anthropic API key — not a Claude subscription)
-export ANTHROPIC_API_KEY="sk-ant-..."
+The current Python workspace is not yet a complete one-to-one replacement for the original system, but the primary implementation surface is now Python.
 
-# 3. Verify everything is wired correctly
-./target/debug/claw doctor
+## Why this rewrite exists
 
-# 4. Run a prompt
-./target/debug/claw prompt "say hello"
+I originally studied the exposed codebase to understand its harness, tool wiring, and agent workflow. After spending more time with the legal and ethical questions—and after reading the essay linked below—I did not want the exposed snapshot itself to remain the main tracked source tree.
+
+This repository now focuses on Python porting work instead.
+
+## Repository Layout
+
+```text
+.
+├── src/                                # Python porting workspace
+│   ├── __init__.py
+│   ├── commands.py
+│   ├── main.py
+│   ├── models.py
+│   ├── port_manifest.py
+│   ├── query_engine.py
+│   ├── task.py
+│   └── tools.py
+├── tests/                              # Python verification
+├── assets/omx/                         # OmX workflow screenshots
+├── 2026-03-09-is-legal-the-same-as-legitimate-ai-reimplementation-and-the-erosion-of-copyleft.md
+└── README.md
 ```
 
-> [!NOTE]
-> **Windows (PowerShell):** the binary is `claw.exe`, not `claw`. Use `.\target\debug\claw.exe` or run `cargo run -- prompt "say hello"` to skip the path lookup.
+## Python Workspace Overview
 
-### Windows setup
+The new Python `src/` tree currently provides:
 
-**PowerShell is a supported Windows path.** Use whichever shell works for you. The common onboarding issues on Windows are:
+- **`port_manifest.py`** — summarizes the current Python workspace structure
+- **`models.py`** — dataclasses for subsystems, modules, and backlog state
+- **`commands.py`** — Python-side command port metadata
+- **`tools.py`** — Python-side tool port metadata
+- **`query_engine.py`** — renders a Python porting summary from the active workspace
+- **`main.py`** — a CLI entrypoint for manifest and summary output
 
-1. **Install Rust first** — download from <https://rustup.rs/> and run the installer. Close and reopen your terminal when it finishes.
-2. **Verify Rust is on PATH:**
-   ```powershell
-   cargo --version
-   ```
-   If this fails, reopen your terminal or run the PATH setup from the Rust installer output, then retry.
-3. **Clone and build** (works in PowerShell, Git Bash, or WSL):
-   ```powershell
-   git clone https://github.com/ultraworkers/claw-code
-   cd claw-code/rust
-   cargo build --workspace
-   ```
-4. **Run** (PowerShell — note `.exe` and backslash):
-   ```powershell
-   $env:ANTHROPIC_API_KEY = "sk-ant-..."
-   .\target\debug\claw.exe prompt "say hello"
-   ```
+## Quickstart
 
-**Git Bash / WSL** are optional alternatives, not requirements. If you prefer bash-style paths (`/c/Users/you/...` instead of `C:\Users\you\...`), Git Bash (ships with Git for Windows) works well. In Git Bash, the `MINGW64` prompt is expected and normal — not a broken install.
-
-## Post-build: locate the binary and verify
-
-After running `cargo build --workspace`, the `claw` binary is built but **not** automatically installed to your system. Here's where to find it and how to verify the build succeeded.
-
-### Binary location
-
-After `cargo build --workspace` in `claw-code/rust/`:
-
-**Debug build (default, faster compile):**
-- **macOS/Linux:** `rust/target/debug/claw`
-- **Windows:** `rust/target/debug/claw.exe`
-
-**Release build (optimized, slower compile):**
-- **macOS/Linux:** `rust/target/release/claw`
-- **Windows:** `rust/target/release/claw.exe`
-
-If you ran `cargo build` without `--release`, the binary is in the `debug/` folder.
-
-### Verify the build succeeded
-
-Test the binary directly using its path:
+Render the Python porting summary:
 
 ```bash
-# macOS/Linux (debug build)
-./rust/target/debug/claw --help
-./rust/target/debug/claw doctor
-
-# Windows PowerShell (debug build)
-.\rust\target\debug\claw.exe --help
-.\rust\target\debug\claw.exe doctor
+python3 -m src.main summary
 ```
 
-If these commands succeed, the build is working. `claw doctor` is your first health check — it validates your API key, model access, and tool configuration.
-
-### Optional: Add to PATH
-
-If you want to run `claw` from any directory without the full path, choose one of these approaches:
-
-**Option 1: Symlink (macOS/Linux)**
-```bash
-ln -s $(pwd)/rust/target/debug/claw /usr/local/bin/claw
-```
-Then reload your shell and test:
-```bash
-claw --help
-```
-
-**Option 2: Use `cargo install` (all platforms)**
-
-Build and install to Cargo's default location (`~/.cargo/bin/`, which is usually on PATH):
-```bash
-# From the claw-code/rust/ directory
-cargo install --path . --force
-
-# Then from anywhere
-claw --help
-```
-
-**Option 3: Update shell profile (bash/zsh)**
-
-Add this line to `~/.bashrc` or `~/.zshrc`:
-```bash
-export PATH="$(pwd)/rust/target/debug:$PATH"
-```
-
-Reload your shell:
-```bash
-source ~/.bashrc  # or source ~/.zshrc
-claw --help
-```
-
-### Troubleshooting
-
-- **"command not found: claw"** — The binary is in `rust/target/debug/claw`, but it's not on your PATH. Use the full path `./rust/target/debug/claw` or symlink/install as above.
-- **"permission denied"** — On macOS/Linux, you may need `chmod +x rust/target/debug/claw` if the executable bit isn't set (rare).
-- **Debug vs. release** — If the build is slow, you're in debug mode (default). Add `--release` to `cargo build` for faster runtime, but the build itself will take 5–10 minutes.
-
-> [!NOTE]
-> **Auth:** claw requires an **API key** (`ANTHROPIC_API_KEY`, `OPENAI_API_KEY`, etc.) — Claude subscription login is not a supported auth path.
-
-Run the workspace test suite after verifying the binary works:
+Print the current Python workspace manifest:
 
 ```bash
-cd rust
-cargo test --workspace
+python3 -m src.main manifest
 ```
 
-## Documentation map
+List the current Python modules:
 
-- [`USAGE.md`](./USAGE.md) — quick commands, auth, sessions, config, parity harness
-- [`rust/README.md`](./rust/README.md) — crate map, CLI surface, features, workspace layout
-- [`PARITY.md`](./PARITY.md) — parity status for the Rust port
-- [`rust/MOCK_PARITY_HARNESS.md`](./rust/MOCK_PARITY_HARNESS.md) — deterministic mock-service harness details
-- [`ROADMAP.md`](./ROADMAP.md) — active roadmap and open cleanup work
-- [`docs/g004-events-reports-contract.md`](./docs/g004-events-reports-contract.md) — Stream 2 lane event/report contract guidance for consumers
-- [`PHILOSOPHY.md`](./PHILOSOPHY.md) — why the project exists and how it is operated
+```bash
+python3 -m src.main subsystems --limit 16
+```
 
-## Ecosystem
+Run verification:
 
-Claw Code is built in the open alongside the broader UltraWorkers toolchain:
+```bash
+python3 -m unittest discover -s tests -v
+```
 
-- [clawhip](https://github.com/Yeachan-Heo/clawhip)
-- [oh-my-openagent](https://github.com/code-yeongyu/oh-my-openagent)
-- [oh-my-claudecode](https://github.com/Yeachan-Heo/oh-my-claudecode)
-- [oh-my-codex](https://github.com/Yeachan-Heo/oh-my-codex)
-- [UltraWorkers Discord](https://discord.gg/5TUQKqFWd)
+Run the parity audit against the local ignored archive (when present):
 
-## Ownership / affiliation disclaimer
+```bash
+python3 -m src.main parity-audit
+```
+
+Inspect mirrored command/tool inventories:
+
+```bash
+python3 -m src.main commands --limit 10
+python3 -m src.main tools --limit 10
+```
+
+## Current Parity Checkpoint
+
+The port now mirrors the archived root-entry file surface, top-level subsystem names, and command/tool inventories much more closely than before. However, it is **not yet** a full runtime-equivalent replacement for the original TypeScript system; the Python tree still contains fewer executable runtime slices than the archived source.
+
+
+## Built with `oh-my-codex`
+
+The restructuring and documentation work on this repository was AI-assisted and orchestrated with Yeachan Heo's [oh-my-codex (OmX)](https://github.com/Yeachan-Heo/oh-my-codex), layered on top of Codex.
+
+- **`$team` mode:** used for coordinated parallel review and architectural feedback
+- **`$ralph` mode:** used for persistent execution, verification, and completion discipline
+- **Codex-driven workflow:** used to turn the main `src/` tree into a Python-first porting workspace
+
+### OmX workflow screenshots
+
+![OmX workflow screenshot 1](assets/omx/omx-readme-review-1.png)
+
+*Ralph/team orchestration view while the README and essay context were being reviewed in terminal panes.*
+
+![OmX workflow screenshot 2](assets/omx/omx-readme-review-2.png)
+
+*Split-pane review and verification flow during the final README wording pass.*
+
+## Community
+
+<p align="center">
+  <a href="https://instruct.kr/"><img src="assets/instructkr.png" alt="instructkr" width="400" /></a>
+</p>
+
+Join the [**instructkr Discord**](https://instruct.kr/) — the best Korean language model community. Come chat about LLMs, harness engineering, agent workflows, and everything in between.
+
+[![Discord](https://img.shields.io/badge/Join%20Discord-instruct.kr-5865F2?logo=discord&style=for-the-badge)](https://instruct.kr/)
+
+## Star History
+
+See the chart at the top of this README.
+
+## Ownership / Affiliation Disclaimer
 
 - This repository does **not** claim ownership of the original Claude Code source material.
 - This repository is **not affiliated with, endorsed by, or maintained by Anthropic**.

USAGE.md

@@ -1,473 +0,0 @@
-# Claw Code Usage
-
-This guide covers the current Rust workspace under `rust/` and the `claw` CLI binary. If you are brand new, make the doctor health check your first run: start `claw`, then run `/doctor`.
-
-## Quick-start health check
-
-Run this before prompts, sessions, or automation:
-
-```bash
-cd rust
-cargo build --workspace
-./target/debug/claw
-# first command inside the REPL
-/doctor
-```
-
-`/doctor` is the built-in setup and preflight diagnostic. Once you have a saved session, you can rerun it with `./target/debug/claw --resume latest /doctor`.
-
-## Prerequisites
-
-- Rust toolchain with `cargo`
-- One of:
-  - `ANTHROPIC_API_KEY` for direct API access
-  - `ANTHROPIC_AUTH_TOKEN` for bearer-token auth
-- Optional: `ANTHROPIC_BASE_URL` when targeting a proxy or local service
-
-## Install / build the workspace
-
-```bash
-cd rust
-cargo build --workspace
-```
-
-The CLI binary is available at `rust/target/debug/claw` after a debug build. Make the doctor check above your first post-build step.
-
-## Quick start
-
-### First-run doctor check
-
-```bash
-cd rust
-./target/debug/claw
-/doctor
-```
-
-Or run doctor directly with JSON output for scripting:
-
-```bash
-cd rust
-./target/debug/claw doctor --output-format json
-```
-
-**Note:** Diagnostic verbs (`doctor`, `status`, `sandbox`, `version`) support `--output-format json` for machine-readable output. Invalid suffix arguments (e.g., `--json`) are now rejected at parse time rather than falling through to prompt dispatch.
-
-### Initialize a repository
-
-Set up a new repository with `.claw` config, `.claw.json`, `.gitignore` entries, and a `CLAUDE.md` guidance file:
-
-```bash
-cd /path/to/your/repo
-./target/debug/claw init
-```
-
-Text mode (human-readable) shows artifact creation summary with project path and next steps. Idempotent — running multiple times in the same repo marks already-created files as "skipped".
-
-JSON mode for scripting:
-```bash
-./target/debug/claw init --output-format json
-```
-
-Returns structured output with `project_path`, `created[]`, `updated[]`, `skipped[]` arrays (one per artifact), and `artifacts[]` carrying each file's `name` and machine-stable `status` tag. The legacy `message` field preserves backward compatibility.
-
-**Why structured fields matter:** Claws can detect per-artifact state (`created` vs `updated` vs `skipped`) without substring-matching human prose. Use the `created[]`, `updated[]`, and `skipped[]` arrays for conditional follow-up logic (e.g., only commit if files were actually created, not just updated).
-
-### Interactive REPL
-
-```bash
-cd rust
-./target/debug/claw
-```
-
-### One-shot prompt
-
-```bash
-cd rust
-./target/debug/claw prompt "summarize this repository"
-```
-
-### Shorthand prompt mode
-
-```bash
-cd rust
-./target/debug/claw "explain rust/crates/runtime/src/lib.rs"
-```
-
-### JSON output for scripting
-
-```bash
-cd rust
-./target/debug/claw --output-format json prompt "status"
-```
-
-### Inspect worker state
-
-The `claw state` command reads `.claw/worker-state.json`, which is written by the interactive REPL or a one-shot prompt when a worker executes a task. This file contains the worker ID, session reference, model, and permission mode.
-
-Prerequisite: You must run `claw` (interactive REPL) or `claw prompt <text>` at least once in the repository to produce the worker state file.
-
-```bash
-cd rust
-./target/debug/claw state
-```
-
-JSON mode:
-```bash
-./target/debug/claw state --output-format json
-```
-
-If you run `claw state` before any worker has executed, you will see a helpful error:
-```
-error: no worker state file found at .claw/worker-state.json
-  Hint: worker state is written by the interactive REPL or a non-interactive prompt.
-  Run:   claw               # start the REPL (writes state on first turn)
-  Or:    claw prompt <text> # run one non-interactive turn
-  Then rerun: claw state [--output-format json]
-```
-
-## Advanced slash commands (Interactive REPL only)
-
-These commands are available inside the interactive REPL (`claw` with no args). They extend the assistant with workspace analysis, planning, and navigation features.
-
-### `/ultraplan` — Deep planning with multi-step reasoning
-
-**Purpose:** Break down a complex task into steps using extended reasoning.
-
-```bash
-# Start the REPL
-claw
-
-# Inside the REPL
-/ultraplan refactor the auth module to use async/await
-/ultraplan design a caching layer for database queries
-/ultraplan analyze this module for performance bottlenecks
-```
-
-Output: A structured plan with numbered steps, reasoning for each step, and expected outcomes. Use this when you want the assistant to think through a problem in detail before coding.
-
-### `/teleport` — Jump to a file or symbol
-
-**Purpose:** Quickly navigate to a file, function, class, or struct by name.
-
-```bash
-# Jump to a symbol
-/teleport UserService
-/teleport authenticate_user
-/teleport RequestHandler
-
-# Jump to a file
-/teleport src/auth.rs
-/teleport crates/runtime/lib.rs
-/teleport ./ARCHITECTURE.md
-```
-
-Output: The file content, with the requested symbol highlighted or the file fully loaded. Useful for exploring the codebase without manually navigating directories. If multiple matches exist, the assistant shows the top candidates.
-
-### `/bughunter` — Scan for likely bugs and issues
-
-**Purpose:** Analyze code for common pitfalls, anti-patterns, and potential bugs.
-
-```bash
-# Scan the entire workspace
-/bughunter
-
-# Scan a specific directory or file
-/bughunter src/handlers
-/bughunter rust/crates/runtime
-/bughunter src/auth.rs
-```
-
-Output: A list of suspicious patterns with explanations (e.g., "unchecked unwrap()", "potential race condition", "missing error handling"). Each finding includes the file, line number, and suggested fix. Use this as a first pass before a full code review.
-
-## Model and permission controls
-
-```bash
-cd rust
-./target/debug/claw --model sonnet prompt "review this diff"
-./target/debug/claw --permission-mode read-only prompt "summarize Cargo.toml"
-./target/debug/claw --permission-mode workspace-write prompt "update README.md"
-./target/debug/claw --allowedTools read,glob "inspect the runtime crate"
-```
-
-Supported permission modes:
-
-- `read-only`
-- `workspace-write`
-- `danger-full-access`
-
-Model aliases currently supported by the CLI:
-
-- `opus` → `claude-opus-4-6`
-- `sonnet` → `claude-sonnet-4-6`
-- `haiku` → `claude-haiku-4-5-20251213`
-
-## Authentication
-
-### API key
-
-```bash
-export ANTHROPIC_API_KEY="sk-ant-..."
-```
-
-### OAuth
-
-```bash
-cd rust
-export ANTHROPIC_AUTH_TOKEN="anthropic-oauth-or-proxy-bearer-token"
-```
-
-### Which env var goes where
-
-`claw` accepts two Anthropic credential env vars and they are **not interchangeable** — the HTTP header Anthropic expects differs per credential shape. Putting the wrong value in the wrong slot is the most common 401 we see.
-
-| Credential shape | Env var | HTTP header | Typical source |
-|---|---|---|---|
-| `sk-ant-*` API key | `ANTHROPIC_API_KEY` | `x-api-key: sk-ant-...` | [console.anthropic.com](https://console.anthropic.com) |
-| OAuth access token (opaque) | `ANTHROPIC_AUTH_TOKEN` | `Authorization: Bearer ...` | an Anthropic-compatible proxy or OAuth flow that mints bearer tokens |
-| OpenRouter key (`sk-or-v1-*`) | `OPENAI_API_KEY` + `OPENAI_BASE_URL=https://openrouter.ai/api/v1` | `Authorization: Bearer ...` | [openrouter.ai/keys](https://openrouter.ai/keys) |
-
-**Why this matters:** if you paste an `sk-ant-*` key into `ANTHROPIC_AUTH_TOKEN`, Anthropic's API will return `401 Invalid bearer token` because `sk-ant-*` keys are rejected over the Bearer header. The fix is a one-line env var swap — move the key to `ANTHROPIC_API_KEY`. Recent `claw` builds detect this exact shape (401 + `sk-ant-*` in the Bearer slot) and append a hint to the error message pointing at the fix.
-
-**If you meant a different provider:** if `claw` reports missing Anthropic credentials but you already have `OPENAI_API_KEY`, `XAI_API_KEY`, or `DASHSCOPE_API_KEY` exported, you most likely forgot to prefix the model name with the provider's routing prefix. Use `--model openai/gpt-4.1-mini` (OpenAI-compat / OpenRouter / Ollama), `--model grok` (xAI), or `--model qwen-plus` (DashScope) and the prefix router will select the right backend regardless of the ambient credentials. The error message now includes a hint that names the detected env var.
-
-## Local Models
-
-`claw` can talk to local servers and provider gateways through either Anthropic-compatible or OpenAI-compatible endpoints. Use `ANTHROPIC_BASE_URL` with `ANTHROPIC_AUTH_TOKEN` for Anthropic-compatible services, or `OPENAI_BASE_URL` with `OPENAI_API_KEY` for OpenAI-compatible services.
-
-### Anthropic-compatible endpoint
-
-```bash
-export ANTHROPIC_BASE_URL="http://127.0.0.1:8080"
-export ANTHROPIC_AUTH_TOKEN="local-dev-token"
-
-cd rust
-./target/debug/claw --model "claude-sonnet-4-6" prompt "reply with the word ready"
-```
-
-### OpenAI-compatible endpoint
-
-```bash
-export OPENAI_BASE_URL="http://127.0.0.1:8000/v1"
-export OPENAI_API_KEY="local-dev-token"
-
-cd rust
-./target/debug/claw --model "qwen2.5-coder" prompt "reply with the word ready"
-```
-
-### Ollama
-
-```bash
-export OPENAI_BASE_URL="http://127.0.0.1:11434/v1"
-unset OPENAI_API_KEY
-
-cd rust
-./target/debug/claw --model "llama3.2" prompt "summarize this repository in one sentence"
-```
-
-### OpenRouter
-
-```bash
-export OPENAI_BASE_URL="https://openrouter.ai/api/v1"
-export OPENAI_API_KEY="sk-or-v1-..."
-
-cd rust
-./target/debug/claw --model "openai/gpt-4.1-mini" prompt "summarize this repository in one sentence"
-```
-
-### Alibaba DashScope (Qwen)
-
-For Qwen models via Alibaba's native DashScope API (higher rate limits than OpenRouter):
-
-```bash
-export DASHSCOPE_API_KEY="sk-..."
-
-cd rust
-./target/debug/claw --model "qwen/qwen-max" prompt "hello"
-# or bare:
-./target/debug/claw --model "qwen-plus" prompt "hello"
-```
-
-Model names starting with `qwen/` or `qwen-` are automatically routed to the DashScope compatible-mode endpoint (`https://dashscope.aliyuncs.com/compatible-mode/v1`). You do **not** need to set `OPENAI_BASE_URL` or unset `ANTHROPIC_API_KEY` — the model prefix wins over the ambient credential sniffer.
-
-Reasoning variants (`qwen-qwq-*`, `qwq-*`, `*-thinking`) automatically strip `temperature`/`top_p`/`frequency_penalty`/`presence_penalty` before the request hits the wire (these params are rejected by reasoning models).
-
-## Supported Providers & Models
-
-`claw` has three built-in provider backends. The provider is selected automatically based on the model name, falling back to whichever credential is present in the environment.
-
-### Provider matrix
-
-| Provider | Protocol | Auth env var(s) | Base URL env var | Default base URL |
-|---|---|---|---|---|
-| **Anthropic** (direct) | Anthropic Messages API | `ANTHROPIC_API_KEY` or `ANTHROPIC_AUTH_TOKEN` | `ANTHROPIC_BASE_URL` | `https://api.anthropic.com` |
-| **xAI** | OpenAI-compatible | `XAI_API_KEY` | `XAI_BASE_URL` | `https://api.x.ai/v1` |
-| **OpenAI-compatible** | OpenAI Chat Completions | `OPENAI_API_KEY` | `OPENAI_BASE_URL` | `https://api.openai.com/v1` |
-| **DashScope** (Alibaba) | OpenAI-compatible | `DASHSCOPE_API_KEY` | `DASHSCOPE_BASE_URL` | `https://dashscope.aliyuncs.com/compatible-mode/v1` |
-
-The OpenAI-compatible backend also serves as the gateway for **OpenRouter**, **Ollama**, and any other service that speaks the OpenAI `/v1/chat/completions` wire format — just point `OPENAI_BASE_URL` at the service.
-
-**Model-name prefix routing:** If a model name starts with `openai/`, `gpt-`, `qwen/`, or `qwen-`, the provider is selected by the prefix regardless of which env vars are set. This prevents accidental misrouting to Anthropic when multiple credentials exist in the environment.
-
-### Tested models and aliases
-
-These are the models registered in the built-in alias table with known token limits:
-
-| Alias | Resolved model name | Provider | Max output tokens | Context window |
-|---|---|---|---|---|
-| `opus` | `claude-opus-4-6` | Anthropic | 32 000 | 200 000 |
-| `sonnet` | `claude-sonnet-4-6` | Anthropic | 64 000 | 200 000 |
-| `haiku` | `claude-haiku-4-5-20251213` | Anthropic | 64 000 | 200 000 |
-| `grok` / `grok-3` | `grok-3` | xAI | 64 000 | 131 072 |
-| `grok-mini` / `grok-3-mini` | `grok-3-mini` | xAI | 64 000 | 131 072 |
-| `grok-2` | `grok-2` | xAI | — | — |
-
-Any model name that does not match an alias is passed through verbatim. This is how you use OpenRouter model slugs (`openai/gpt-4.1-mini`), Ollama tags (`llama3.2`), or full Anthropic model IDs (`claude-sonnet-4-20250514`).
-
-### User-defined aliases
-
-You can add custom aliases in any settings file (`~/.claw/settings.json`, `.claw/settings.json`, or `.claw/settings.local.json`):
-
-```json
-{
-  "aliases": {
-    "fast": "claude-haiku-4-5-20251213",
-    "smart": "claude-opus-4-6",
-    "cheap": "grok-3-mini"
-  }
-}
-```
-
-Local project settings override user-level settings. Aliases resolve through the built-in table, so `"fast": "haiku"` also works.
-
-### How provider detection works
-
-1. If the resolved model name starts with `claude` → Anthropic.
-2. If it starts with `grok` → xAI.
-3. Otherwise, `claw` checks which credential is set: `ANTHROPIC_API_KEY`/`ANTHROPIC_AUTH_TOKEN` first, then `OPENAI_API_KEY`, then `XAI_API_KEY`.
-4. If nothing matches, it defaults to Anthropic.
-
-## FAQ
-
-### What about Codex?
-
-The name "codex" appears in the Claw Code ecosystem but it does **not** refer to OpenAI Codex (the code-generation model). Here is what it means in this project:
-
-- **`oh-my-codex` (OmX)** is the workflow and plugin layer that sits on top of `claw`. It provides planning modes, parallel multi-agent execution, notification routing, and other automation features. See [PHILOSOPHY.md](./PHILOSOPHY.md) and the [oh-my-codex repo](https://github.com/Yeachan-Heo/oh-my-codex).
-- **`.codex/` directories** (e.g. `.codex/skills`, `.codex/agents`, `.codex/commands`) are legacy lookup paths that `claw` still scans alongside the primary `.claw/` directories.
-- **`CODEX_HOME`** is an optional environment variable that points to a custom root for user-level skill and command lookups.
-
-`claw` does **not** support OpenAI Codex sessions, the Codex CLI, or Codex session import/export. If you need to use OpenAI models (like GPT-4.1), configure the OpenAI-compatible provider as shown above in the [OpenAI-compatible endpoint](#openai-compatible-endpoint) and [OpenRouter](#openrouter) sections.
-
-## HTTP proxy support
-
-`claw` honours the standard `HTTP_PROXY`, `HTTPS_PROXY`, and `NO_PROXY` environment variables (both upper- and lower-case spellings are accepted) when issuing outbound requests to Anthropic, OpenAI-, and xAI-compatible endpoints. Set them before launching the CLI and the underlying `reqwest` client will be configured automatically.
-
-### Environment variables
-
-```bash
-export HTTPS_PROXY="http://proxy.corp.example:3128"
-export HTTP_PROXY="http://proxy.corp.example:3128"
-export NO_PROXY="localhost,127.0.0.1,.corp.example"
-
-cd rust
-./target/debug/claw prompt "hello via the corporate proxy"
-```
-
-### Programmatic `proxy_url` config option
-
-As an alternative to per-scheme environment variables, the `ProxyConfig` type exposes a `proxy_url` field that acts as a single catch-all proxy for both HTTP and HTTPS traffic. When `proxy_url` is set it takes precedence over the separate `http_proxy` and `https_proxy` fields.
-
-```rust
-use api::{build_http_client_with, ProxyConfig};
-
-// From a single unified URL (config file, CLI flag, etc.)
-let config = ProxyConfig::from_proxy_url("http://proxy.corp.example:3128");
-let client = build_http_client_with(&config).expect("proxy client");
-
-// Or set the field directly alongside NO_PROXY
-let config = ProxyConfig {
-    proxy_url: Some("http://proxy.corp.example:3128".to_string()),
-    no_proxy: Some("localhost,127.0.0.1".to_string()),
-    ..ProxyConfig::default()
-};
-let client = build_http_client_with(&config).expect("proxy client");
-```
-
-### Notes
-
-- When both `HTTPS_PROXY` and `HTTP_PROXY` are set, the secure proxy applies to `https://` URLs and the plain proxy applies to `http://` URLs.
-- `proxy_url` is a unified alternative: when set, it applies to both `http://` and `https://` destinations, overriding the per-scheme fields.
-- `NO_PROXY` accepts a comma-separated list of host suffixes (for example `.corp.example`) and IP literals.
-- Empty values are treated as unset, so leaving `HTTPS_PROXY=""` in your shell will not enable a proxy.
-- If a proxy URL cannot be parsed, `claw` falls back to a direct (no-proxy) client so existing workflows keep working; double-check the URL if you expected the request to be tunnelled.
-
-## Common operational commands
-
-```bash
-cd rust
-./target/debug/claw status
-./target/debug/claw sandbox
-./target/debug/claw agents
-./target/debug/claw mcp
-./target/debug/claw skills
-./target/debug/claw system-prompt --cwd .. --date 2026-04-04
-```
-
-## Session management
-
-REPL turns are persisted under `.claw/sessions/` in the current workspace.
-
-```bash
-cd rust
-./target/debug/claw --resume latest
-./target/debug/claw --resume latest /status /diff
-```
-
-Useful interactive commands include `/help`, `/status`, `/cost`, `/config`, `/session`, `/model`, `/permissions`, and `/export`.
-
-## Config file resolution order
-
-Runtime config is loaded in this order, with later entries overriding earlier ones:
-
-1. `~/.claw.json`
-2. `~/.config/claw/settings.json`
-3. `<repo>/.claw.json`
-4. `<repo>/.claw/settings.json`
-5. `<repo>/.claw/settings.local.json`
-
-## Mock parity harness
-
-The workspace includes a deterministic Anthropic-compatible mock service and parity harness.
-
-```bash
-cd rust
-./scripts/run_mock_parity_harness.sh
-```
-
-Manual mock service startup:
-
-```bash
-cd rust
-cargo run -p mock-anthropic-service -- --bind 127.0.0.1:0
-```
-
-## Verification
-
-```bash
-cd rust
-cargo test --workspace
-```
-
-## Workspace overview
-
-Current Rust crates:
-
-- `api`
-- `commands`
-- `compat-harness`
-- `mock-anthropic-service`
-- `plugins`
-- `runtime`
-- `rusty-claude-cli`
-- `telemetry`
-- `tools`

docs/MODEL_COMPATIBILITY.md

@@ -1,236 +0,0 @@
-# Model Compatibility Guide
-
-This document describes model-specific handling in the OpenAI-compatible provider. When adding new models or providers, review this guide to ensure proper compatibility.
-
-## Table of Contents
-
-- [Overview](#overview)
-- [Model-Specific Handling](#model-specific-handling)
-  - [Kimi Models (is_error Exclusion)](#kimi-models-is_error-exclusion)
-  - [Reasoning Models (Tuning Parameter Stripping)](#reasoning-models-tuning-parameter-stripping)
-  - [GPT-5 (max_completion_tokens)](#gpt-5-max_completion_tokens)
-  - [Qwen Models (DashScope Routing)](#qwen-models-dashscope-routing)
-- [Implementation Details](#implementation-details)
-- [Adding New Models](#adding-new-models)
-- [Testing](#testing)
-
-## Overview
-
-The `openai_compat.rs` provider translates Claude Code's internal message format to OpenAI-compatible chat completion requests. Different models have varying requirements for:
-
-- Tool result message fields (`is_error`)
-- Sampling parameters (temperature, top_p, etc.)
-- Token limit fields (`max_tokens` vs `max_completion_tokens`)
-- Base URL routing
-
-## Model-Specific Handling
-
-### Kimi Models (is_error Exclusion)
-
-**Affected models:** `kimi-k2.5`, `kimi-k1.5`, `kimi-moonshot`, and any model with `kimi` in the name (case-insensitive)
-
-**Behavior:** The `is_error` field is **excluded** from tool result messages.
-
-**Rationale:** Kimi models (via Moonshot AI and DashScope) reject the `is_error` field with a 400 Bad Request error:
-```json
-{
-  "error": {
-    "type": "invalid_request_error",
-    "message": "Unknown field: is_error"
-  }
-}
-```
-
-**Detection:**
-```rust
-fn model_rejects_is_error_field(model: &str) -> bool {
-    let lowered = model.to_ascii_lowercase();
-    let canonical = lowered.rsplit('/').next().unwrap_or(lowered.as_str());
-    canonical.starts_with("kimi-")
-}
-```
-
-**Testing:** See `model_rejects_is_error_field_detects_kimi_models` and related tests in `openai_compat.rs`.
-
----
-
-### Reasoning Models (Tuning Parameter Stripping)
-
-**Affected models:**
-- OpenAI: `o1`, `o1-*`, `o3`, `o3-*`, `o4`, `o4-*`
-- xAI: `grok-3-mini`
-- Alibaba DashScope: `qwen-qwq-*`, `qwq-*`, `qwen3-*-thinking`
-
-**Behavior:** The following tuning parameters are **stripped** from requests:
-- `temperature`
-- `top_p`
-- `frequency_penalty`
-- `presence_penalty`
-
-**Rationale:** Reasoning/chain-of-thought models use fixed sampling strategies and reject these parameters with 400 errors.
-
-**Exception:** `reasoning_effort` is included for compatible models when explicitly set.
-
-**Detection:**
-```rust
-fn is_reasoning_model(model: &str) -> bool {
-    let canonical = model.to_ascii_lowercase()
-        .rsplit('/')
-        .next()
-        .unwrap_or(model);
-    canonical.starts_with("o1")
-        || canonical.starts_with("o3")
-        || canonical.starts_with("o4")
-        || canonical == "grok-3-mini"
-        || canonical.starts_with("qwen-qwq")
-        || canonical.starts_with("qwq")
-        || (canonical.starts_with("qwen3") && canonical.contains("-thinking"))
-}
-```
-
-**Testing:** See `reasoning_model_strips_tuning_params`, `grok_3_mini_is_reasoning_model`, and `qwen_reasoning_variants_are_detected` tests.
-
----
-
-### GPT-5 (max_completion_tokens)
-
-**Affected models:** All models starting with `gpt-5`
-
-**Behavior:** Uses `max_completion_tokens` instead of `max_tokens` in the request payload.
-
-**Rationale:** GPT-5 models require the `max_completion_tokens` field. Legacy `max_tokens` causes request validation failures:
-```json
-{
-  "error": {
-    "message": "Unknown field: max_tokens"
-  }
-}
-```
-
-**Implementation:**
-```rust
-let max_tokens_key = if wire_model.starts_with("gpt-5") {
-    "max_completion_tokens"
-} else {
-    "max_tokens"
-};
-```
-
-**Testing:** See `gpt5_uses_max_completion_tokens_not_max_tokens` and `non_gpt5_uses_max_tokens` tests.
-
----
-
-### Qwen Models (DashScope Routing)
-
-**Affected models:** All models with `qwen` prefix
-
-**Behavior:** Routed to DashScope (`https://dashscope.aliyuncs.com/compatible-mode/v1`) rather than default providers.
-
-**Rationale:** Qwen models are hosted by Alibaba Cloud's DashScope service, not OpenAI or Anthropic.
-
-**Configuration:**
-```rust
-pub const DEFAULT_DASHSCOPE_BASE_URL: &str = "https://dashscope.aliyuncs.com/compatible-mode/v1";
-```
-
-**Authentication:** Uses `DASHSCOPE_API_KEY` environment variable.
-
-**Note:** Some Qwen models are also reasoning models (see [Reasoning Models](#reasoning-models-tuning-parameter-stripping) above) and receive both treatments.
-
-## Implementation Details
-
-### File Location
-All model-specific logic is in:
-```
-rust/crates/api/src/providers/openai_compat.rs
-```
-
-### Key Functions
-
-| Function | Purpose |
-|----------|---------|
-| `model_rejects_is_error_field()` | Detects models that don't support `is_error` in tool results |
-| `is_reasoning_model()` | Detects reasoning models that need tuning param stripping |
-| `translate_message()` | Converts internal messages to OpenAI format (applies `is_error` logic) |
-| `build_chat_completion_request()` | Constructs full request payload (applies all model-specific logic) |
-
-### Provider Prefix Handling
-
-All model detection functions strip provider prefixes (e.g., `dashscope/kimi-k2.5` → `kimi-k2.5`) before matching:
-
-```rust
-let canonical = model.to_ascii_lowercase()
-    .rsplit('/')
-    .next()
-    .unwrap_or(model);
-```
-
-This ensures consistent detection regardless of whether models are referenced with or without provider prefixes.
-
-## Adding New Models
-
-When adding support for new models:
-
-1. **Check if the model is a reasoning model**
-   - Does it reject temperature/top_p parameters?
-   - Add to `is_reasoning_model()` detection
-
-2. **Check tool result compatibility**
-   - Does it reject the `is_error` field?
-   - Add to `model_rejects_is_error_field()` detection
-
-3. **Check token limit field**
-   - Does it require `max_completion_tokens` instead of `max_tokens`?
-   - Update the `max_tokens_key` logic
-
-4. **Add tests**
-   - Unit test for detection function
-   - Integration test in `build_chat_completion_request`
-
-5. **Update this documentation**
-   - Add the model to the affected lists
-   - Document any special behavior
-
-## Testing
-
-### Running Model-Specific Tests
-
-```bash
-# All OpenAI compatibility tests
-cargo test --package api providers::openai_compat
-
-# Specific test categories
-cargo test --package api model_rejects_is_error_field
-cargo test --package api reasoning_model
-cargo test --package api gpt5
-cargo test --package api qwen
-```
-
-### Test Files
-
-- Unit tests: `rust/crates/api/src/providers/openai_compat.rs` (in `mod tests`)
-- Integration tests: `rust/crates/api/tests/openai_compat_integration.rs`
-
-### Verifying Model Detection
-
-To verify a model is detected correctly without making API calls:
-
-```rust
-#[test]
-fn my_new_model_is_detected() {
-    // is_error handling
-    assert!(model_rejects_is_error_field("my-model"));
-    
-    // Reasoning model detection
-    assert!(is_reasoning_model("my-model"));
-    
-    // Provider prefix handling
-    assert!(model_rejects_is_error_field("provider/my-model"));
-}
-```
-
----
-
-*Last updated: 2026-04-16*
-
-For questions or updates, see the implementation in `rust/crates/api/src/providers/openai_compat.rs`.

docs/container.md

@@ -1,132 +0,0 @@
-# Container-first claw-code workflows
-
-This repo already had **container detection** in the Rust runtime before this document was added:
-
-- `rust/crates/runtime/src/sandbox.rs` detects Docker/Podman/container markers such as `/.dockerenv`, `/run/.containerenv`, matching env vars, and `/proc/1/cgroup` hints.
-- `rust/crates/rusty-claude-cli/src/main.rs` exposes that state through the `claw sandbox` / `cargo run -p rusty-claude-cli -- sandbox` report.
-- `.github/workflows/rust-ci.yml` runs on `ubuntu-latest`, but it does **not** define a Docker or Podman container job.
-- Before this change, the repo did **not** have a checked-in `Dockerfile`, `Containerfile`, or `.devcontainer/` config.
-
-This document adds a small checked-in `Containerfile` so Docker and Podman users have one canonical container workflow.
-
-## What the checked-in container image is for
-
-The root [`../Containerfile`](../Containerfile) gives you a reusable Rust build/test shell with the extra packages this workspace commonly needs (`git`, `pkg-config`, `libssl-dev`, certificates).
-
-It does **not** copy the repository into the image. Instead, the recommended flow is to bind-mount your checkout into `/workspace` so edits stay on the host.
-
-## Build the image
-
-From the repository root:
-
-### Docker
-
-```bash
-docker build -t claw-code-dev -f Containerfile .
-```
-
-### Podman
-
-```bash
-podman build -t claw-code-dev -f Containerfile .
-```
-
-## Run `cargo test --workspace` in the container
-
-These commands mount the repo, keep Cargo build artifacts out of the working tree, and run from the Rust workspace at `rust/`.
-
-### Docker
-
-```bash
-docker run --rm -it \
-  -v "$PWD":/workspace \
-  -e CARGO_TARGET_DIR=/tmp/claw-target \
-  -w /workspace/rust \
-  claw-code-dev \
-  cargo test --workspace
-```
-
-### Podman
-
-```bash
-podman run --rm -it \
-  -v "$PWD":/workspace:Z \
-  -e CARGO_TARGET_DIR=/tmp/claw-target \
-  -w /workspace/rust \
-  claw-code-dev \
-  cargo test --workspace
-```
-
-If you want a fully clean rebuild, add `cargo clean &&` before `cargo test --workspace`.
-
-## Open a shell in the container
-
-### Docker
-
-```bash
-docker run --rm -it \
-  -v "$PWD":/workspace \
-  -e CARGO_TARGET_DIR=/tmp/claw-target \
-  -w /workspace/rust \
-  claw-code-dev
-```
-
-### Podman
-
-```bash
-podman run --rm -it \
-  -v "$PWD":/workspace:Z \
-  -e CARGO_TARGET_DIR=/tmp/claw-target \
-  -w /workspace/rust \
-  claw-code-dev
-```
-
-Inside the shell:
-
-```bash
-cargo build --workspace
-cargo test --workspace
-cargo run -p rusty-claude-cli -- --help
-cargo run -p rusty-claude-cli -- sandbox
-```
-
-The `sandbox` command is a useful sanity check: inside Docker or Podman it should report `In container true` and list the markers the runtime detected.
-
-## Bind-mount this repo and another repo at the same time
-
-If you want to run `claw` against a second checkout while keeping `claw-code` itself mounted read-write:
-
-### Docker
-
-```bash
-docker run --rm -it \
-  -v "$PWD":/workspace \
-  -v "$HOME/src/other-repo":/repo \
-  -e CARGO_TARGET_DIR=/tmp/claw-target \
-  -w /workspace/rust \
-  claw-code-dev
-```
-
-### Podman
-
-```bash
-podman run --rm -it \
-  -v "$PWD":/workspace:Z \
-  -v "$HOME/src/other-repo":/repo:Z \
-  -e CARGO_TARGET_DIR=/tmp/claw-target \
-  -w /workspace/rust \
-  claw-code-dev
-```
-
-Then, for example:
-
-```bash
-cargo run -p rusty-claude-cli -- prompt "summarize /repo"
-```
-
-## Notes
-
-- Docker and Podman use the same checked-in `Containerfile`.
-- The `:Z` suffix in the Podman examples is for SELinux relabeling; keep it on Fedora/RHEL-class hosts.
-- Running with `CARGO_TARGET_DIR=/tmp/claw-target` avoids leaving container-owned `target/` artifacts in your bind-mounted checkout.
-- For non-container local development, keep using [`../USAGE.md`](../USAGE.md) and [`../rust/README.md`](../rust/README.md).

docs/g002-security-verification-map.md

@@ -1,185 +0,0 @@
-# G002 alpha security map and verification plan
-
-Generated by `worker-4` for OMX team task 5 on 2026-05-14.
-
-## Scope and coordination
-
-- Active goal context: `G002-alpha-security` / Stream 6 day-one security and permissions gate.
-- Worker ownership: `worker-1` owns minimal implementation changes for workspace/path enforcement. `worker-4` owns this repository map, integration verification plan, changed-file/commit report, and exact verification evidence.
-- Boundary: this report does not mutate `.omx/ultragoal` and does not edit shared security/path tests.
-- Parallel probe status: three native subagents were spawned for repository map, test probe, and change-slice probe, but all failed before returning findings with `429 Too Many Requests`; local mapping below is based on direct repository inspection.
-
-## Current permission and path enforcement map
-
-### Runtime permission policy and enforcer
-
-- `rust/crates/runtime/src/permissions.rs`
-  - Owns the `PermissionMode` ordering and `PermissionPolicy` authorization contract.
-  - Existing tests cover read-only denial, workspace-write escalation, prompt approvals/denials, danger-full-access allowance, override recording, and required-mode reporting.
-  - Integration risk: any new dynamic file/path rule must preserve the existing `PermissionPolicy::authorize` semantics so prompt/override audit events remain stable.
-
-- `rust/crates/runtime/src/permission_enforcer.rs`
-  - `PermissionEnforcer::check`, `check_with_required_mode`, `check_file_write`, and `check_bash` convert policy outcomes into structured `EnforcementResult` payloads.
-  - `check_file_write` currently has the direct write gate for workspace-write mode.
-  - `is_within_workspace` is a string-prefix boundary check after simple relative-path joining; it does not canonicalize symlinks, `..`, Windows drive prefixes, or case variants.
-  - Existing tests cover read-only denial, workspace-write inside/outside paths, trailing slashes, root equality, bash read-only heuristics, prompt-mode denial payloads, and structured denied fields.
-
-### File tool path handling
-
-- `rust/crates/runtime/src/file_ops.rs`
-  - `read_file`, `write_file`, and `edit_file` normalize paths before filesystem operations but do not themselves require a workspace root.
-  - `read_file_in_workspace`, `write_file_in_workspace`, and `edit_file_in_workspace` exist as boundary-enforced wrappers.
-  - `validate_workspace_boundary` canonicalizes through the caller-provided resolved path and checks `starts_with(workspace_root)`.
-  - `is_symlink_escape` detects direct symlink escapes by comparing canonical target to canonical workspace root.
-  - Search tools (`glob_search`, `grep_search`) derive walk roots and prune heavy directories, but they are separate from the write enforcement path.
-  - Existing tests cover oversized/binary reads, workspace-boundary read rejection, symlink escape detection, glob brace expansion, ignored directories, and grep/glob behavior.
-
-### Bash command validation
-
-- `rust/crates/runtime/src/bash_validation.rs`
-  - `validate_command` runs mode validation, sed validation, destructive warning checks, then path validation.
-  - `validate_read_only` blocks write-like commands, state-modifying commands, write redirects, and mutating git subcommands in read-only mode.
-  - `validate_mode` warns when workspace-write commands appear to target hard-coded system paths.
-  - `validate_paths` warns for `../`, `~/`, and `$HOME` references; it is intentionally heuristic and does not resolve shell expansion or canonical targets.
-  - Existing tests cover read-only blockers, destructive warnings, sed in-place blocking, path traversal/home warnings, command classification, and full pipeline allow/block/warn outcomes.
-
-### Sandbox and diagnostics surfaces
-
-- `rust/crates/runtime/src/sandbox.rs`
-  - Owns container/sandbox status detection and workspace-only sandbox command construction.
-  - Relevant for day-one security because sandbox status must not overstate filesystem isolation.
-
-- `rust/crates/rusty-claude-cli/src/main.rs`
-  - Owns CLI permission-mode parsing, direct JSON/text diagnostic output, `/permissions`, `/status`, `/doctor`, and command dispatch paths.
-  - Existing CLI integration tests under `rust/crates/rusty-claude-cli/tests/` cover permission prompt scenarios and output-format contracts.
-
-- `rust/crates/rusty-claude-cli/tests/mock_parity_harness.rs`
-  - End-to-end harness includes `bash_permission_prompt_approved`, `bash_permission_prompt_denied`, read/write file allow/deny, and plugin workspace-write scenarios.
-
-## Existing G002-adjacent coverage
-
-- Unit-level permission coverage:
-  - `cargo test -p runtime permissions::tests`
-  - `cargo test -p runtime permission_enforcer::tests`
-  - `cargo test -p runtime bash_validation::tests`
-  - `cargo test -p runtime file_ops::tests`
-
-- CLI and integration coverage:
-  - `cargo test -p rusty-claude-cli --test mock_parity_harness`
-  - `cargo test -p rusty-claude-cli --test output_format_contract`
-  - `cargo test -p rusty-claude-cli --test cli_flags_and_config_defaults`
-
-- Board/report validation coverage:
-  - `python3 scripts/validate_cc2_board.py --board .omx/cc2/board.json`
-  - `python3 .omx/cc2/validate_issue_parity_intake.py .omx/cc2/issue-parity-intake.json`
-
-## Recommended safe work slices
-
-### Implementation lane (owned by worker-1 unless re-scoped)
-
-1. Replace string-prefix workspace boundary checks with canonical path comparison in the runtime enforcement path.
-   - Primary files: `rust/crates/runtime/src/permission_enforcer.rs`, possibly shared helper extraction from `rust/crates/runtime/src/file_ops.rs`.
-   - Regression cases: `../` traversal, symlink escape, root prefix collision (`/workspace` vs `/workspacex`), relative paths, trailing slash root equality.
-
-2. Ensure direct file tools call workspace-aware wrappers when active permission mode is `workspace-write`.
-   - Primary files: likely `rust/crates/runtime/src/mcp_tool_bridge.rs` and/or the runtime tool execution bridge that calls `file_ops`.
-   - Regression cases: direct read/write paths, missing parent creation, symlink parent escape, and error payload stability.
-
-3. Keep bash validation as a warning/classification layer unless a real shell-expansion resolver is introduced.
-   - Primary files: `rust/crates/runtime/src/bash_validation.rs`, `rust/crates/runtime/src/bash.rs`.
-   - Risk: heuristic parsing cannot faithfully resolve shell expansion, globs, aliases, or platform-specific path rules; avoid claiming hard enforcement unless execution sandbox or command resolver proves it.
-
-### Test lane (coordinate with worker-3/worker-1 before editing)
-
-1. Add unit regressions close to each enforcement function before changing behavior.
-   - `permission_enforcer.rs`: canonical path boundary and Windows-shaped path cases.
-   - `file_ops.rs`: write/edit workspace wrappers with symlink parent escapes and missing file parent canonicalization.
-   - `bash_validation.rs`: shell expansion/glob/path warnings remain warnings unless a resolver is introduced.
-
-2. Add at least one integration test proving the runtime bridge actually routes file tools through workspace enforcement, not only helper functions.
-   - Candidate: `rust/crates/rusty-claude-cli/tests/mock_parity_harness.rs` for direct write denial and no file created outside workspace.
-
-3. Preserve existing prompt/event visibility tests.
-   - Candidate surfaces: permission prompt scenarios in `mock_parity_harness.rs`, status/doctor JSON in `output_format_contract.rs`.
-
-### Docs/reporting lane (owned by worker-4)
-
-1. Keep this file as the integration handoff artifact for G002 mapping and verification.
-2. Report changed files and commits relative to `origin/main` so the leader can integrate worker branches deterministically.
-3. Include exact command evidence in the task lifecycle result.
-
-## Changed files relative to `origin/main` at map time
-
-The worktree currently contains these files added relative to `origin/main` before this task report:
-
-- `.omx/cc2/board.json`
-- `.omx/cc2/board.md`
-- `.omx/cc2/issue-parity-intake.json`
-- `.omx/cc2/issue-parity-intake.md`
-- `.omx/cc2/render_board_md.py`
-- `.omx/cc2/validate_issue_parity_intake.py`
-- `scripts/cc2_board.py`
-- `scripts/generate_cc2_board.py`
-- `scripts/validate_cc2_board.py`
-
-This task adds:
-
-- `docs/g002-security-verification-map.md`
-
-## Commits relative to `origin/main` at map time
-
-- `8311655` — `omx(team): auto-checkpoint worker-1 [1]`
-- `c6e2a7d` — `omx(team): merge worker-1`
-- `481585f` — `omx(team): auto-checkpoint worker-1 [1]`
-- `74bbf4b` — `omx(team): auto-checkpoint worker-4 [unknown]`
-- `5c77896` — `omx(team): auto-checkpoint worker-1 [1]`
-- `07dad88` — `Classify issue and parity intake for CC2 board integration`
-- `424825f` — `task: G001 human board and docs rendering`
-- `d15268e` — `Create a canonical CC2 board so every frozen ROADMAP heading is verifiably mapped`
-- `45b43b5` — `Make the CC2 board schema executable for G001`
-
-## Verification checklist for leader integration
-
-Run these from the repository root unless noted:
-
-1. Python board/schema validation:
-   - `python3 scripts/validate_cc2_board.py --board .omx/cc2/board.json`
-   - `python3 .omx/cc2/validate_issue_parity_intake.py .omx/cc2/issue-parity-intake.json`
-
-2. Rust formatting and lint/type checks:
-   - `scripts/fmt.sh --check`
-   - `(cd rust && cargo check --workspace)`
-   - `(cd rust && cargo clippy --workspace --all-targets -- -D warnings)`
-
-3. Targeted G002 security tests:
-   - `(cd rust && cargo test -p runtime permissions::tests permission_enforcer::tests bash_validation::tests file_ops::tests)`
-   - `(cd rust && cargo test -p rusty-claude-cli --test mock_parity_harness)`
-
-4. Full regression:
-   - `(cd rust && cargo test --workspace)`
-
-
-## Worker-4 verification evidence (2026-05-14)
-
-PASS:
-
-- `python3 scripts/validate_cc2_board.py --board .omx/cc2/board.json` → `PASS cc2 board validation`; 729 items; ROADMAP headings `124/124`; ROADMAP actions `542/542`.
-- `python3 .omx/cc2/validate_issue_parity_intake.py .omx/cc2/issue-parity-intake.json` → `PASS issue/parity intake: 19 issue rows, 9 parity rows`.
-- `scripts/fmt.sh --check` → no output and zero exit before Rust checks continued.
-- `(cd rust && cargo check --workspace)` → `Finished dev profile` successfully.
-- `(cd rust && cargo test -p runtime permissions::tests)` → 9 passed.
-- `(cd rust && cargo test -p runtime permission_enforcer::tests)` → 21 passed.
-- `(cd rust && cargo test -p runtime bash_validation::tests)` → 32 passed.
-- `(cd rust && cargo test -p runtime file_ops::tests)` → 14 passed.
-- `(cd rust && cargo test -p rusty-claude-cli --test mock_parity_harness)` → 1 passed.
-
-FAIL / integration blockers observed on this worktree:
-
-- `(cd rust && cargo clippy --workspace --all-targets -- -D warnings)` failed in existing runtime code, not this docs-only task:
-  - `rust/crates/runtime/src/compact.rs:215` / `:216`: `clippy::match_same_arms`.
-  - `rust/crates/runtime/src/policy_engine.rs:5`: `clippy::duration-suboptimal-units`.
-  - `rust/crates/runtime/src/sandbox.rs:295-302`: `clippy::map_unwrap_or`.
-- `(cd rust && cargo test --workspace)` failed after broad success in API/commands/plugins/runtime tests because `rusty-claude-cli` unit test `tests::session_lifecycle_prefers_running_process_over_idle_shell` asserted `RunningProcess` but observed `IdleShell`.
-- Rerun of the specific failing test confirmed deterministic failure: `(cd rust && cargo test -p rusty-claude-cli --bin claw tests::session_lifecycle_prefers_running_process_over_idle_shell -- --exact --nocapture)` → 0 passed, 1 failed with the same `IdleShell` vs `RunningProcess` assertion.
-
-Recommended owner for failures: not `worker-4` unless re-scoped. These failures are outside the docs/report artifact and touch shared runtime/CLI implementation files.

docs/g003-boot-session-verification-map.md

@@ -1,96 +0,0 @@
-# G003 boot/session/preflight verification map
-
-Generated by `worker-1` for OMX team task 2 on 2026-05-14.
-
-## Scope and coordination
-
-- Active goal context: `G003-boot-session` / Stream 1 reliable worker boot and session control.
-- Boundary: this artifact is an audit/integration map only. It does not mutate `.omx/ultragoal` and it does not change shared implementation or tests.
-- Current worker split from leader mailbox:
-  - `worker-1`: task 1 worker boot / prompt SLA plus this task 2 audit map.
-  - `worker-2`: default trusted roots / trust resolver.
-  - `worker-3`: startup-no-evidence classifier.
-  - `worker-4`: session control plus preflight/doctor JSON surfaces.
-- Native subagent probes were attempted for Task 2 (`test probe` and `debug/root-cause probe`) but both failed before returning findings with `429 Too Many Requests`; the map below is based on direct repository inspection.
-
-## Implementation surface map
-
-### Worker boot lifecycle and prompt SLA
-
-- `rust/crates/runtime/src/worker_boot.rs`
-  - Core state types: `WorkerStatus`, `WorkerFailureKind`, `WorkerEventKind`, `WorkerEventPayload`, `StartupFailureClassification`, `StartupEvidenceBundle`, `WorkerTaskReceipt`, and `WorkerReadySnapshot`.
-  - Control plane: `WorkerRegistry::{create,get,observe,resolve_trust,send_prompt,await_ready,restart,terminate,observe_completion,observe_startup_timeout}`.
-  - Lifecycle states currently covered in code: `spawning`, `trust_required`, `tool_permission_required`, `ready_for_prompt`, `running`, `finished`, and `failed`.
-  - Prompt delivery semantics currently use `Running` events and fields `prompt_in_flight`, `last_prompt`, `expected_receipt`, `replay_prompt`, and `prompt_delivery_attempts`.
-  - Startup-no-evidence surface: `observe_startup_timeout` builds `StartupEvidenceBundle` and classifies trust, tool permission, prompt acceptance timeout, prompt misdelivery, transport death, worker crash, or unknown.
-  - File observability surface: `emit_state_file` writes `.claw/worker-state.json` with status, readiness, trust state, prompt-in-flight flag, last event, and update age.
-
-- `rust/crates/tools/src/lib.rs`
-  - Tool APIs expose the worker control plane through `WorkerCreate`, `WorkerGet`, `WorkerObserve`, `WorkerResolveTrust`, `WorkerAwaitReady`, `WorkerSendPrompt`, `WorkerRestart`, `WorkerTerminate`, and `WorkerObserveCompletion`.
-  - `WorkerCreate` merges `ConfigLoader::trusted_roots()` with per-call `trusted_roots` before calling `WorkerRegistry::create`.
-  - Tool-level tests exercise worker create/observe/send/restart/terminate/completion and state-file transitions.
-
-### Trust resolver and default trusted roots
-
-- `rust/crates/runtime/src/trust_resolver.rs`
-  - `TrustConfig`, `TrustAllowlistEntry`, and `TrustResolver` model trust prompts, allowlist/denylist policy, auto-trust, manual approval, and emitted trust events.
-  - `path_matches_trusted_root` and internal `path_matches` canonicalize paths when possible.
-  - Hazard: prefix matching must avoid accidental sibling matches such as `/tmp/work` matching `/tmp/work-evil`; worker-2 owns any changes here.
-
-- `rust/crates/runtime/src/config.rs`
-  - `trustedRoots` is parsed by `parse_optional_trusted_roots` and exposed through `RuntimeConfig::trusted_roots()` / feature config accessors.
-  - Current default is empty when unset; any project default roots work belongs to worker-2.
-
-### Session control
-
-- `rust/crates/runtime/src/session_control.rs`
-  - `SessionStore` namespaces sessions by canonical workspace fingerprint.
-  - Key API: `from_cwd`, `from_data_dir`, `create_handle`, `resolve_reference`, `resolve_managed_path`, `list_sessions`, `latest_session`, `load_session`, and `fork_session`.
-  - Guardrail: `validate_loaded_session` rejects cross-workspace sessions and allows legacy sessions only when their path remains inside the current workspace.
-  - Worker-4 owns changes to this lane.
-
-### CLI doctor/status/preflight and bootstrap-adjacent surfaces
-
-- `rust/crates/commands/src/lib.rs`
-  - Slash command definitions include `/status`, `/sandbox`, and `/doctor`.
-  - JSON rendering for command surfaces exists through handler functions and tests in the same module.
-
-- `rust/crates/tools/src/lib.rs`
-  - Bash and PowerShell tool runners include `workspace_test_branch_preflight`, which returns structured output with `return_code_interpretation: preflight_blocked:branch_divergence` for broad workspace tests on stale branches.
-  - Tests around `bash_workspace_tests_are_blocked_when_branch_is_behind_main` and targeted-test skipping protect this preflight behavior.
-
-## Existing focused verification commands
-
-Run from `rust/` unless noted.
-
-- Worker boot runtime contract:
-  - `cargo test -p runtime worker_boot -- --nocapture`
-- Worker tool API contract:
-  - `cargo test -p tools worker_ -- --nocapture`
-- Session control contract:
-  - `cargo test -p runtime session_control -- --nocapture`
-- Trust resolver/config trusted roots:
-  - `cargo test -p runtime trust_resolver -- --nocapture`
-  - `cargo test -p runtime config::tests::parses_trusted_roots_from_settings config::tests::trusted_roots_default_is_empty_when_unset -- --nocapture`
-- Preflight/tool branch guardrails:
-  - `cargo test -p tools bash_workspace_tests_are_blocked_when_branch_is_behind_main bash_targeted_tests_skip_branch_preflight -- --nocapture`
-- Formatting/type/lint baseline:
-  - `../scripts/fmt.sh --check`
-  - `cargo check -p runtime -p tools -p commands`
-  - `cargo clippy -p runtime -p tools -p commands --all-targets --no-deps -- -D warnings`
-
-## Gaps and hazards for leader integration
-
-- Prompt SLA event naming is partially implicit: `send_prompt` emits `WorkerEventKind::Running`; it does not expose separate `prompt.sent`, `prompt.accepted`, `prompt.acceptance_delayed`, or `prompt.acceptance_timeout` event names. The current equivalent evidence is `prompt_in_flight`, `Running`, `observe_completion`, and startup-timeout classification.
-- `StartupFailureClassification::PromptAcceptanceTimeout` is covered in `worker_boot` tests; full terminal/transport integration should still be verified by the leader or worker-3 if a real pane watcher exists outside the in-memory registry.
-- Default trusted roots are parsed and merged into `WorkerCreate`, but unset config currently means no default roots. Worker-2 owns any change to default root selection.
-- Session control protects workspace fingerprints at load/fork time; worker-4 owns CLI/doctor/preflight JSON contract changes.
-- Full-workspace clippy currently has known unrelated runtime findings observed during task 1 verification; do not block this docs-only map on those unless leader re-scopes cleanup.
-
-## Recommended safe integration order
-
-1. Integrate worker boot / prompt SLA changes first and run `cargo test -p runtime worker_boot -- --nocapture` plus `cargo test -p tools worker_ -- --nocapture`.
-2. Integrate trust-root changes and rerun trust/config tests plus the worker create config merge test.
-3. Integrate startup-no-evidence classifier changes and rerun `cargo test -p runtime worker_boot -- --nocapture`.
-4. Integrate session control / preflight / doctor JSON changes and rerun session-control, commands JSON, and preflight tests.
-5. Run final formatting, targeted cargo check/clippy, then broader workspace tests with known full-workspace failures documented separately.

docs/g004-events-reports-contract.md

@@ -1,67 +0,0 @@
-# G004 event and report contract guidance
-
-Captured: 2026-05-14 during the Stream 2 `G004-events-reports` team run.
-
-Purpose: keep the user/developer-facing contract guidance for ROADMAP Phase 2 in one tracked source that points back to the code and roadmap anchors. This document is intentionally not the implementation map for task 5; it describes the interoperability contract consumers should rely on as the lane-event, report-schema, approval-token, and capability-negotiation lanes land.
-
-## Source-of-truth anchors
-
-| Contract family | Roadmap anchor | Current implementation / owner-facing anchor | Consumer guidance |
-| --- | --- | --- | --- |
-| Canonical lane events | `ROADMAP.md` Phase 2 §4, §4.5, §4.6, §4.7 | `rust/crates/runtime/src/lane_events.rs` (`LaneEventName`, `LaneEventStatus`, `LaneEventMetadata`, terminal reconciliation helpers) | Consume `event`, `status`, `emittedAt`, and `metadata` fields as the canonical state stream; do not infer lane state from terminal text when a structured event is present. |
-| Report schema v1 and projections | `ROADMAP.md` §4.25-§4.34 | Stream 2 report-schema lane / fixtures as they land | Treat a report as a versioned canonical payload plus derived projections. A projection may omit or transform fields only with explicit provenance: compatibility downgrade, redaction policy, truncation, or source absence. |
-| Policy-blocked handoff and approval-token chain | `ROADMAP.md` §4.37-§4.39 | Stream 2 approval-token lane as it lands | Treat policy blocks and owner approvals as typed artifacts, not prose. Execute an exception only when the approval token matches actor, policy, action, repo/branch/commit scope, expiry, and one-time-use state. |
-| Capability negotiation | `ROADMAP.md` §4.25, §4.26, §4.32, §4.34 | Report-schema/projection fixtures and consumer conformance cases as they land | Consumers must advertise supported schema versions, optional field families, projection views, redaction semantics, and downgrade handling before relying on reduced payloads. |
-
-## Lane event contract
-
-The lane-event stream is the first machine-trustworthy surface for Stream 2. Consumers should expect these invariants when reading `LaneEvent` payloads:
-
-- `event` is a typed event name, currently including the core lane lifecycle (`lane.started`, `lane.ready`, `lane.blocked`, `lane.red`, `lane.green`, `lane.finished`, `lane.failed`), branch health (`branch.stale_against_main`, `branch.workspace_mismatch`), reconciliation (`lane.reconciled`, `lane.superseded`, `lane.closed`), and ship provenance (`ship.prepared`, `ship.commits_selected`, `ship.merged`, `ship.pushed_main`).
-- `status` is the normalized state for the event; consumers should prefer it over freeform `detail` text for automation.
-- `metadata.seq`, `metadata.timestamp_ms`, and terminal fingerprints are the ordering/deduplication hooks. Consumers should use terminal reconciliation output rather than double-reporting contradictory terminal bursts.
-- `metadata.provenance`, `metadata.environment_label`, `metadata.emitter_identity`, and `metadata.confidence_level` tell consumers whether an event is live lane truth, test traffic, healthcheck/replay output, or transport-layer evidence.
-- `metadata.session_identity` and `metadata.ownership` bind a lane event to the session, workspace, workflow scope, owner, and watcher action. A watcher should not act on events whose ownership says `observe` or `ignore`.
-
-Minimal consumer rule: if a structured event exists, pane text is supporting evidence only. Pane scraping must not override a higher-confidence typed event with matching session/workflow ownership.
-
-## Report schema v1 contract
-
-A Stream 2 report should be treated as a canonical fact record with optional projections. Consumers should preserve these semantics even when they receive only a downgraded view:
-
-- Every report payload declares a schema version and a stable report identity/content hash for the full-fidelity canonical payload.
-- Assertions are labeled as `fact`, `hypothesis`, or another declared evidence class, with confidence and source references. Negative evidence is first-class: `not observed`, `checked and absent`, and `redacted` are distinct states.
-- Field deltas name the field, previous value/state, new value/state, attribution, and whether the delta came from source content, projection, downgrade, or redaction policy.
-- Projections carry lineage back to the canonical report id/content hash and name the projection view, capability set, schema version, redaction policy, and deterministic rendering inputs.
-- Redaction provenance is explicit. A missing field without a redaction/downgrade/source-absence reason is not enough evidence for an automated consumer to conclude the underlying fact is absent.
-
-Minimal consumer rule: store the canonical identity and projection metadata together. Do not compare two projections as state changes unless their canonical content hash or declared projection inputs differ.
-
-## Approval-token and policy-blocked contract
-
-Policy-blocked actions and owner-approved exceptions belong in the same structured event/report family:
-
-- A policy block names the typed reason, policy source, actor scope, blocked action, and safe fallback path.
-- An approval token names the approving actor, policy exception, action, repository/worktree/branch/commit scope, expiry, and allowed use count.
-- Token consumption records the exact action and scope that spent the token. Replays, scope expansion, expired tokens, and revoked tokens should surface typed policy errors.
-- Delegation traceability stays attached when another worker/lane executes the approved action; the executor must be able to prove which approval artifact authorized the exception.
-
-Minimal consumer rule: prose such as "approved" is not an executable approval. Require the structured token and verify that it is unconsumed and scoped to the exact action before proceeding.
-
-## Capability negotiation and conformance
-
-Mixed-version consumers are expected during Stream 2 rollout. Producers and consumers should negotiate instead of silently dropping fields:
-
-- Consumers advertise supported report schema versions, field families, projection views, redaction states, downgrade semantics, and fixture/conformance suite version.
-- Producers preserve one canonical full-fidelity report and emit downgraded projections only with `downgraded_for_compatibility` metadata.
-- Deterministic projection inputs include schema version, consumer capability set, projection policy version, redaction policy version, and canonical content hash.
-- Consumer conformance should distinguish syntax acceptance from semantic correctness, especially for `redacted` vs `missing`, stale vs current projections, negative evidence, and approval-token replay states.
-
-Minimal consumer rule: an older consumer may accept a downgraded projection, but it must surface the downgrade as a capability limitation rather than treating omitted fields as canonical absence.
-
-## Documentation maintenance rules
-
-- Keep ROADMAP Phase 2 as the product requirement source and this file as the contract-reading guide.
-- Keep Rust type names and event names aligned with `rust/crates/runtime/src/lane_events.rs`; update this document in the same change when public event names or metadata semantics change.
-- Keep report-schema examples/fixtures aligned with this guide once the schema lane lands; fixture updates should explain intentional schema or projection changes.
-- Do not mutate `.omx/ultragoal` from worker lanes. Leader-owned Ultragoal checkpointing consumes commits and verification evidence from task results.

docs/g004-events-reports-verification-map.md

@@ -1,57 +0,0 @@
-# G004 events/reports verification map
-
-Scope source: OMX team `g004-events-reports-u-e61d2271`, worker-1 tasks 1, 2, 4, 5. Workers must not mutate `.omx/ultragoal`; leader owns aggregate checkpoints.
-
-## Ownership boundaries
-
-- **Lane events / event identity / terminal reconciliation** — `rust/crates/runtime/src/lane_events.rs`, exported through `rust/crates/runtime/src/lib.rs`; tool-manifest consumers in `rust/crates/tools/src/lib.rs` write `LaneEvent` vectors.
-- **Report schema v1 / projection / redaction / capability negotiation** — `rust/crates/runtime/src/report_schema.rs`, exported through `rust/crates/runtime/src/lib.rs`; fixture note at `rust/crates/runtime/tests/fixtures/report_schema_v1/README.md`.
-- **Approval-token chain** — ROADMAP §§4.38-4.40; owned by worker-2 for this team split. Worker-1 did not edit it.
-- **Pinpoint closure batch** — runtime hygiene across compact/search-parser/policy/sandbox/integration-test surfaces: `rust/crates/runtime/src/compact.rs`, `rust/crates/runtime/src/file_ops.rs`, `rust/crates/runtime/src/policy_engine.rs`, `rust/crates/runtime/src/sandbox.rs`, `rust/crates/runtime/tests/integration_tests.rs`.
-- **Regression harness / docs alignment** — worker-3/worker-4 lanes per leader split. Coordinate before editing shared docs/tests.
-
-## Relevant symbols and files
-
-- `LaneEventName`, `LaneEventStatus`, `LaneEventMetadata`, `LaneEventBuilder`, `compute_event_fingerprint`, `dedupe_terminal_events`, `reconcile_terminal_events` in `runtime/src/lane_events.rs`.
-- `CanonicalReportV1`, `ReportClaim`, `NegativeEvidence`, `FieldDelta`, `ConsumerCapabilities`, `ReportProjectionV1`, `canonicalize_report`, `project_report`, `report_schema_v1_registry` in `runtime/src/report_schema.rs`.
-- `AgentOutput.lane_events`, `persist_agent_terminal_state`, `write_agent_manifest`, `maybe_commit_provenance` in `tools/src/lib.rs`.
-- Search/parser closure helpers: `summarize_messages` in `compact.rs`, `grep_search_impl` / `build_grep_content_output` in `file_ops.rs`.
-
-## Completed worker-1 commits
-
-- `f45f05e` / task 1 auto-checkpoint — terminal event fingerprints use stable SHA-256-derived canonical JSON, and production convenience terminal events attach/refresh fingerprints after payload changes.
-- `3989fc0` — report schema v1 contract, deterministic projection/redaction provenance, capability negotiation, and fixture note.
-- `7fff4c4` / task 4 auto-checkpoint — strict runtime clippy closure batch across compact/file_ops/policy/sandbox/integration tests.
-
-## Current verification evidence
-
-Run from `rust/` unless noted:
-
-- `cargo test -p runtime lane_events -- --nocapture` — PASS, 46 lane-event tests.
-- `cargo test -p runtime report_schema -- --nocapture` — PASS, 4 report-schema tests.
-- `cargo check -p runtime` — PASS.
-- `cargo clippy -p runtime --all-targets -- -D warnings` — PASS after task 4 closure batch.
-- `cargo test -p runtime -- --nocapture` — PASS, 531 unit tests, 12 integration tests, doc-tests pass.
-- `cargo test -p tools lane_event_schema_serializes_to_canonical_names -- --nocapture` — PASS, 1 targeted tools contract test.
-
-## Leader integration verification plan
-
-1. Inspect worker commits: `git log --oneline --decorate --max-count=8`.
-2. Re-run focused contracts:
-   - `cd rust && cargo test -p runtime lane_events -- --nocapture`
-   - `cd rust && cargo test -p runtime report_schema -- --nocapture`
-   - `cd rust && cargo test -p tools lane_event_schema_serializes_to_canonical_names -- --nocapture`
-3. Re-run runtime quality gate:
-   - `cd rust && cargo check -p runtime`
-   - `cd rust && cargo clippy -p runtime --all-targets -- -D warnings`
-   - `cd rust && cargo test -p runtime -- --nocapture`
-4. If merging with worker-2 approval-token work, additionally run the worker-2 focused approval-token tests and check for export conflicts in `runtime/src/lib.rs`.
-5. If merging with worker-3/4 docs or harness work, re-run their named regression harnesses plus `git diff --check`.
-
-## Integration hazards
-
-- `runtime/src/lib.rs` export blocks are shared; resolve conflicts by keeping both lane-event and report-schema exports sorted enough to remain readable.
-- `tools/src/lib.rs` serializes lane events into agent manifests; terminal fingerprint changes intentionally affect `metadata.event_fingerprint` for finished/failed/superseded/merged/closed events with payloads.
-- `report_schema.rs` currently defines the reusable contract and in-code deterministic fixtures; it does not yet wire report emission into CLI/status surfaces.
-- ROADMAP approval-token §§4.38-4.40 remain a separate lane; do not treat worker-1 report schema as an approval artifact.
-- Full workspace checks may include unrelated slow/provider-dependent tests; the verified local gate for this stream is runtime + targeted tools tests above.

docs/pr-issue-resolution-gate.md

@@ -1,42 +0,0 @@
-# Claw Code 2.0 PR and Issue Resolution Gate
-
-This gate was added to the Claw Code 2.0 Ultragoal after the explicit requirement:
-
-> all PRs should be merged and all issues should be resolved if resolvable and correct.
-
-## Scope
-
-Before the Claw Code 2.0 Ultragoal can be marked complete:
-
-1. Every open GitHub PR at the current final-gate snapshot must be triaged.
-2. PRs that are correct, compatible with Claw Code 2.0 direction, and pass required verification must be merged.
-3. PRs that are stale, incorrect, duplicative, unsafe, spam, or outside Claw Code scope must not be merged; each needs a recorded rationale.
-4. Every open GitHub issue at the current final-gate snapshot must be triaged.
-5. Issues that are resolvable and correct must be fixed or explicitly linked to a merged fix.
-6. Issues that are spam, duplicates, incorrect, unactionable, externally blocked, or not Claw Code work must be closed or labeled/commented with rationale when repository policy allows.
-7. The final completion audit must use a fresh GitHub snapshot, not only the planning snapshot.
-
-## Current live snapshot
-
-A live snapshot was captured locally during G002 execution:
-
-- PR snapshot: `.omx/research/github-live/open-prs.json`
-- Issue snapshot: `.omx/research/github-live/open-issues.json`
-- Captured on: 2026-05-14 during the active Ultragoal run.
-- Observed counts: 50 open PR records and 1000 open issue records from GitHub CLI list calls.
-
-These local `.omx/research/github-live/*` files are evidence inputs, not final proof. The final gate must refresh them and compare deltas.
-
-## Required final evidence
-
-The final report must include:
-
-- Fresh `gh pr list --state open` and `gh issue list --state open` snapshots.
-- A PR ledger with one row per PR: merge / reject / defer, reason, verification, commit/merge reference.
-- An issue ledger with one row per issue: fixed / duplicate / spam / invalid / deferred-with-rationale / externally-blocked, reason, and linked evidence.
-- Verification that no correct, mergeable PR remains unmerged without rationale.
-- Verification that no resolvable, correct issue remains open without a fix or rationale.
-
-## Non-goals
-
-This gate does not require merging unsafe, unverified, incompatible, spam, or incorrect contributions. It requires explicit evidence-backed triage and action for everything that is correct and resolvable.

docs/roadmap-pr-goals.md

@@ -1,58 +0,0 @@
-# Roadmap PR goal intake
-
-Captured: 2026-05-14 (Asia/Seoul) during the Claw Code 2.0 Ultragoal run.
-
-Purpose: make the user's follow-up requirement durable: all roadmap PRs should be merged when correct/resolvable, and unresolved roadmap deltas should become Ultragoal work rather than being lost. This file is a tracked companion to the leader-owned `.omx/ultragoal/goals.json` and `.omx/ultragoal/ledger.jsonl` artifacts.
-
-## Merge policy
-
-- Merge only PRs that are still relevant to Claw Code 2.0, are non-draft, target `main`, and are conflict-free after a fresh mergeability refresh.
-- Prefer squash merges with a Lore-style body when GitHub allows a direct PR merge.
-- If a PR is documentation-only but adds a real roadmap gap, merging it is acceptable once checks/conflicts are clean.
-- If a PR is stale, duplicated by already-landed work, or not product-aligned, do not force-merge; record the rationale and map any still-correct requirement into G011/G012.
-- After merging roadmap PRs, refresh generated board artifacts (`.omx/cc2/board.json`, `.omx/cc2/board.md`) so Stream 0 coverage stays current.
-
-## Open roadmap PRs with green historical checks
-
-These are first-pass merge candidates, pending fresh mergeability and conflict checks against current `main`.
-
-| PR | Title | Branch | Checks | Mergeable | URL |
-| --- | --- | --- | --- | --- | --- |
-| #2848 | docs(roadmap): add #333 — no in-session settings inspect command | `docs/roadmap-333-no-settings-inspect-command` -> `main` | 4/4 checks successful | UNKNOWN | https://github.com/ultraworkers/claw-code/pull/2848 |
-| #2846 | docs(roadmap): add #331 — export silently overwrites on repeated invocations | `docs/roadmap-331-export-filename-collision` -> `main` | 4/4 checks successful | UNKNOWN | https://github.com/ultraworkers/claw-code/pull/2846 |
-| #2869 | docs(roadmap): add #358 — history entries missing role field, no pagination | `docs/roadmap-348-history-entries-missing-role` -> `main` | 4/4 checks successful | UNKNOWN | https://github.com/ultraworkers/claw-code/pull/2869 |
-| #2850 | docs(roadmap): add #335 — session list omits created_at_ms field | `docs/roadmap-335-session-list-no-created-at` -> `main` | 4/4 checks successful | UNKNOWN | https://github.com/ultraworkers/claw-code/pull/2850 |
-| #2868 | docs(roadmap): add #356 — session list title always null; no rename command | `docs/roadmap-347-session-list-title-always-null` -> `main` | 4/4 checks successful | UNKNOWN | https://github.com/ultraworkers/claw-code/pull/2868 |
-| #2865 | docs(roadmap): add #362 — doctor auth false-positive: misses CLI session tokens | `docs/roadmap-345-doctor-auth-check-incomplete` -> `main` | 4/4 checks successful | UNKNOWN | https://github.com/ultraworkers/claw-code/pull/2865 |
-| #2864 | docs(roadmap): add #364 — /cost returns no cost_usd; identical to /stats | `docs/roadmap-344-cost-command-no-dollar-amount` -> `main` | 4/4 checks successful | UNKNOWN | https://github.com/ultraworkers/claw-code/pull/2864 |
-| #2867 | docs(roadmap): add #368 — export always appends .txt; response.file reflects mangled path | `docs/roadmap-346-export-forces-txt-extension` -> `main` | 4/4 checks successful | UNKNOWN | https://github.com/ultraworkers/claw-code/pull/2867 |
-| #2862 | docs(roadmap): add #342 — status json omits active session ID, workspace counters ambiguous | `docs/roadmap-342-v2` -> `main` | 4/4 checks successful | UNKNOWN | https://github.com/ultraworkers/claw-code/pull/2862 |
-| #2876 | docs(roadmap): add #354 — /cwd suggests itself in did-you-mean; self-referential loop | `docs/roadmap-354-cwd-self-referential-suggestion` -> `main` | 4/4 checks successful | UNKNOWN | https://github.com/ultraworkers/claw-code/pull/2876 |
-| #2872 | docs(roadmap): add #360 — /tokens, /stats, /cost identical output; no context-window or cost_usd | `docs/roadmap-349-tokens-stats-cost-identical` -> `main` | 4/4 checks successful | UNKNOWN | https://github.com/ultraworkers/claw-code/pull/2872 |
-
-## Open roadmap PRs needing local validation or CI refresh
-
-These have no check rollup in the live snapshot; validate locally or refresh CI before merging.
-
-| PR | Title | Branch | Checks | Mergeable | URL |
-| --- | --- | --- | --- | --- | --- |
-| #2858 | docs(roadmap): add #343 — session subcommand resume-safety inconsistently enforced | `docs/roadmap-340-session-resume-safe-inconsistent` -> `main` | no checks reported | UNKNOWN | https://github.com/ultraworkers/claw-code/pull/2858 |
-| #2839 | docs(roadmap): add #330 — resume mode stats/cost always zero | `docs/roadmap-324-resume-stats-zero` -> `main` | no checks reported | UNKNOWN | https://github.com/ultraworkers/claw-code/pull/2839 |
-| #2841 | docs(roadmap): add #332 — doctor json missing top-level status field | `docs/roadmap-325-doctor-no-status-field` -> `main` | no checks reported | UNKNOWN | https://github.com/ultraworkers/claw-code/pull/2841 |
-| #2844 | docs(roadmap): add #336 — session subcommand resume inconsistency and type/kind error mismatch | `docs/roadmap-329-session-subcommand-resume-inconsistency` -> `main` | no checks reported | UNKNOWN | https://github.com/ultraworkers/claw-code/pull/2844 |
-| #2842 | docs(roadmap): add #334 — version json omits build_date and uses short sha only | `docs/roadmap-328-version-json-incomplete` -> `main` | no checks reported | UNKNOWN | https://github.com/ultraworkers/claw-code/pull/2842 |
-
-## Product-fit review before merge
-
-These may be broader than the Claw Code 2.0 roadmap scope and need a product-fit decision before merge.
-
-| PR | Title | Branch | Checks | Mergeable | URL |
-| --- | --- | --- | --- | --- | --- |
-| #2824 | docs: personal assistant roadmap | `pr/docs-personal-assistant-roadmap` -> `main` | no checks reported | UNKNOWN | https://github.com/ultraworkers/claw-code/pull/2824 |
-
-## Ultragoal mapping
-
-- G003-G010: close implementation gaps that overlap a roadmap PR title if the requirement belongs to the active stream.
-- G011: reconcile ecosystem/ops/UX roadmap PRs and unresolved correct issues that do not fit earlier streams.
-- G012: final release gate must prove that every open roadmap PR was merged, closed as duplicate/obsolete, or converted into an explicit remaining goal with evidence.
-

install.sh

@@ -1,394 +0,0 @@
-#!/usr/bin/env bash
-# Claw Code installer
-#
-# Detects the host OS, verifies the Rust toolchain (rustc + cargo),
-# builds the `claw` binary from the `rust/` workspace, and runs a
-# post-install verification step. Supports Linux, macOS, and WSL.
-#
-# Usage:
-#   ./install.sh                # debug build (fast, default)
-#   ./install.sh --release      # optimized release build
-#   ./install.sh --no-verify    # skip post-install verification
-#   ./install.sh --help         # print usage
-#
-# Environment overrides:
-#   CLAW_BUILD_PROFILE=debug|release   same as --release toggle
-#   CLAW_SKIP_VERIFY=1                 same as --no-verify
-
-set -euo pipefail
-
-# ---------------------------------------------------------------------------
-# Pretty printing
-# ---------------------------------------------------------------------------
-
-if [ -t 1 ] && command -v tput >/dev/null 2>&1 && [ "$(tput colors 2>/dev/null || echo 0)" -ge 8 ]; then
-    COLOR_RESET="$(tput sgr0)"
-    COLOR_BOLD="$(tput bold)"
-    COLOR_DIM="$(tput dim)"
-    COLOR_RED="$(tput setaf 1)"
-    COLOR_GREEN="$(tput setaf 2)"
-    COLOR_YELLOW="$(tput setaf 3)"
-    COLOR_BLUE="$(tput setaf 4)"
-    COLOR_CYAN="$(tput setaf 6)"
-else
-    COLOR_RESET=""
-    COLOR_BOLD=""
-    COLOR_DIM=""
-    COLOR_RED=""
-    COLOR_GREEN=""
-    COLOR_YELLOW=""
-    COLOR_BLUE=""
-    COLOR_CYAN=""
-fi
-
-CURRENT_STEP=0
-TOTAL_STEPS=6
-
-step() {
-    CURRENT_STEP=$((CURRENT_STEP + 1))
-    printf '\n%s[%d/%d]%s %s%s%s\n' \
-        "${COLOR_BLUE}" "${CURRENT_STEP}" "${TOTAL_STEPS}" "${COLOR_RESET}" \
-        "${COLOR_BOLD}" "$1" "${COLOR_RESET}"
-}
-
-info()  { printf '%s  ->%s %s\n' "${COLOR_CYAN}" "${COLOR_RESET}" "$1"; }
-ok()    { printf '%s  ok%s %s\n' "${COLOR_GREEN}" "${COLOR_RESET}" "$1"; }
-warn()  { printf '%s  warn%s %s\n' "${COLOR_YELLOW}" "${COLOR_RESET}" "$1"; }
-error() { printf '%s  error%s %s\n' "${COLOR_RED}" "${COLOR_RESET}" "$1" 1>&2; }
-
-print_banner() {
-    printf '%s' "${COLOR_BOLD}"
-    cat <<'EOF'
-   ____  _                   ____          _
-  / ___|| |  __ _ __      __ / ___|___   __| | ___
- | |    | | / _` |\ \ /\ / /| |   / _ \ / _` |/ _ \
- | |___ | || (_| | \ V  V / | |__| (_) | (_| |  __/
-  \____||_| \__,_|  \_/\_/   \____\___/ \__,_|\___|
-EOF
-    printf '%s\n' "${COLOR_RESET}"
-    printf '%sClaw Code installer%s\n' "${COLOR_DIM}" "${COLOR_RESET}"
-}
-
-print_usage() {
-    cat <<'EOF'
-Usage: ./install.sh [options]
-
-Options:
-  --release       Build the optimized release profile (slower, smaller binary).
-  --debug         Build the debug profile (default, faster compile).
-  --no-verify     Skip the post-install verification step.
-  -h, --help      Show this help text and exit.
-
-Environment overrides:
-  CLAW_BUILD_PROFILE   debug | release
-  CLAW_SKIP_VERIFY     set to 1 to skip verification
-EOF
-}
-
-# ---------------------------------------------------------------------------
-# Argument parsing
-# ---------------------------------------------------------------------------
-
-BUILD_PROFILE="${CLAW_BUILD_PROFILE:-debug}"
-SKIP_VERIFY="${CLAW_SKIP_VERIFY:-0}"
-
-while [ "$#" -gt 0 ]; do
-    case "$1" in
-        --release)
-            BUILD_PROFILE="release"
-            ;;
-        --debug)
-            BUILD_PROFILE="debug"
-            ;;
-        --no-verify)
-            SKIP_VERIFY="1"
-            ;;
-        -h|--help)
-            print_usage
-            exit 0
-            ;;
-        *)
-            error "unknown argument: $1"
-            print_usage
-            exit 2
-            ;;
-    esac
-    shift
-done
-
-case "${BUILD_PROFILE}" in
-    debug|release) ;;
-    *)
-        error "invalid build profile: ${BUILD_PROFILE} (expected debug or release)"
-        exit 2
-        ;;
-esac
-
-# ---------------------------------------------------------------------------
-# Troubleshooting hints
-# ---------------------------------------------------------------------------
-
-print_troubleshooting() {
-    cat <<EOF
-
-${COLOR_BOLD}Troubleshooting${COLOR_RESET}
-${COLOR_DIM}---------------${COLOR_RESET}
-
-  ${COLOR_BOLD}1. Rust toolchain missing${COLOR_RESET}
-     Install Rust via rustup:
-       curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
-     Then reload your shell or run:
-       source "\$HOME/.cargo/env"
-
-  ${COLOR_BOLD}2. Linux: missing system packages${COLOR_RESET}
-     The build needs git, pkg-config, and OpenSSL headers.
-     Debian/Ubuntu:
-       sudo apt-get update && sudo apt-get install -y \\
-         git pkg-config libssl-dev ca-certificates build-essential
-     Fedora/RHEL:
-       sudo dnf install -y git pkgconf-pkg-config openssl-devel gcc
-     Arch:
-       sudo pacman -S --needed git pkgconf openssl base-devel
-
-  ${COLOR_BOLD}3. macOS: missing Xcode CLT${COLOR_RESET}
-     Install the command line tools:
-       xcode-select --install
-
-  ${COLOR_BOLD}4. Windows users${COLOR_RESET}
-     Run this script from inside a WSL distro (Ubuntu/Debian recommended).
-     Native Windows builds are not supported by this installer.
-
-  ${COLOR_BOLD}5. Build fails partway through${COLOR_RESET}
-     Try a clean build:
-       cd rust && cargo clean && cargo build --workspace
-     If the failure mentions ring/openssl, double check step 2.
-
-  ${COLOR_BOLD}6. 'claw' not found after install${COLOR_RESET}
-     The binary lives at:
-       rust/target/${BUILD_PROFILE}/claw
-     Add it to your PATH or invoke it with the full path.
-
-EOF
-}
-
-trap 'rc=$?; if [ "$rc" -ne 0 ]; then error "installation failed (exit ${rc})"; print_troubleshooting; fi' EXIT
-
-# ---------------------------------------------------------------------------
-# Helpers
-# ---------------------------------------------------------------------------
-
-require_cmd() {
-    command -v "$1" >/dev/null 2>&1
-}
-
-# ---------------------------------------------------------------------------
-# Step 1: detect OS / arch / WSL
-# ---------------------------------------------------------------------------
-
-print_banner
-step "Detecting host environment"
-
-UNAME_S="$(uname -s 2>/dev/null || echo unknown)"
-UNAME_M="$(uname -m 2>/dev/null || echo unknown)"
-OS_FAMILY="unknown"
-IS_WSL="0"
-
-case "${UNAME_S}" in
-    Linux*)
-        OS_FAMILY="linux"
-        if grep -qiE 'microsoft|wsl' /proc/version 2>/dev/null; then
-            IS_WSL="1"
-        fi
-        ;;
-    Darwin*)
-        OS_FAMILY="macos"
-        ;;
-    MINGW*|MSYS*|CYGWIN*)
-        OS_FAMILY="windows-shell"
-        ;;
-esac
-
-info "uname:        ${UNAME_S} ${UNAME_M}"
-info "os family:    ${OS_FAMILY}"
-if [ "${IS_WSL}" = "1" ]; then
-    info "wsl:          yes"
-fi
-
-case "${OS_FAMILY}" in
-    linux|macos)
-        ok "supported platform detected"
-        ;;
-    windows-shell)
-        error "Detected a native Windows shell (MSYS/Cygwin/MinGW)."
-        error "Please re-run this script from inside a WSL distribution."
-        exit 1
-        ;;
-    *)
-        error "Unsupported or unknown OS: ${UNAME_S}"
-        error "Supported: Linux, macOS, and Windows via WSL."
-        exit 1
-        ;;
-esac
-
-# ---------------------------------------------------------------------------
-# Step 2: locate the Rust workspace
-# ---------------------------------------------------------------------------
-
-step "Locating the Rust workspace"
-
-SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-RUST_DIR="${SCRIPT_DIR}/rust"
-
-if [ ! -d "${RUST_DIR}" ]; then
-    error "Could not find rust/ workspace next to install.sh"
-    error "Expected: ${RUST_DIR}"
-    exit 1
-fi
-
-if [ ! -f "${RUST_DIR}/Cargo.toml" ]; then
-    error "Missing ${RUST_DIR}/Cargo.toml — repository layout looks unexpected."
-    exit 1
-fi
-
-ok "workspace at ${RUST_DIR}"
-
-# ---------------------------------------------------------------------------
-# Step 3: prerequisite checks
-# ---------------------------------------------------------------------------
-
-step "Checking prerequisites"
-
-MISSING_PREREQS=0
-
-if require_cmd rustc; then
-    RUSTC_VERSION="$(rustc --version 2>/dev/null || echo 'unknown')"
-    ok "rustc found: ${RUSTC_VERSION}"
-else
-    error "rustc not found in PATH"
-    MISSING_PREREQS=1
-fi
-
-if require_cmd cargo; then
-    CARGO_VERSION="$(cargo --version 2>/dev/null || echo 'unknown')"
-    ok "cargo found: ${CARGO_VERSION}"
-else
-    error "cargo not found in PATH"
-    MISSING_PREREQS=1
-fi
-
-if require_cmd git; then
-    ok "git found:  $(git --version 2>/dev/null || echo 'unknown')"
-else
-    warn "git not found — some workflows (login, session export) may degrade"
-fi
-
-if [ "${OS_FAMILY}" = "linux" ]; then
-    if require_cmd pkg-config; then
-        ok "pkg-config found"
-    else
-        warn "pkg-config not found — may be required for OpenSSL-linked crates"
-    fi
-fi
-
-if [ "${OS_FAMILY}" = "macos" ]; then
-    if ! require_cmd cc && ! xcode-select -p >/dev/null 2>&1; then
-        warn "Xcode command line tools not detected — run: xcode-select --install"
-    fi
-fi
-
-if [ "${MISSING_PREREQS}" -ne 0 ]; then
-    error "Missing required tools. See troubleshooting below."
-    exit 1
-fi
-
-# ---------------------------------------------------------------------------
-# Step 4: build the workspace
-# ---------------------------------------------------------------------------
-
-step "Building the claw workspace (${BUILD_PROFILE})"
-
-CARGO_FLAGS=("build" "--workspace")
-if [ "${BUILD_PROFILE}" = "release" ]; then
-    CARGO_FLAGS+=("--release")
-fi
-
-info "running: cargo ${CARGO_FLAGS[*]}"
-info "this may take a few minutes on the first build"
-
-(
-    cd "${RUST_DIR}"
-    CARGO_TERM_COLOR="${CARGO_TERM_COLOR:-always}" cargo "${CARGO_FLAGS[@]}"
-)
-
-CLAW_BIN="${RUST_DIR}/target/${BUILD_PROFILE}/claw"
-
-if [ ! -x "${CLAW_BIN}" ]; then
-    error "Expected binary not found at ${CLAW_BIN}"
-    error "The build reported success but the binary is missing — check cargo output above."
-    exit 1
-fi
-
-ok "built ${CLAW_BIN}"
-
-# ---------------------------------------------------------------------------
-# Step 5: post-install verification
-# ---------------------------------------------------------------------------
-
-step "Verifying the installed binary"
-
-if [ "${SKIP_VERIFY}" = "1" ]; then
-    warn "verification skipped (--no-verify or CLAW_SKIP_VERIFY=1)"
-else
-    info "running: claw --version"
-    if VERSION_OUT="$("${CLAW_BIN}" --version 2>&1)"; then
-        ok "claw --version -> ${VERSION_OUT}"
-    else
-        error "claw --version failed:"
-        printf '%s\n' "${VERSION_OUT}" 1>&2
-        exit 1
-    fi
-
-    info "running: claw --help (smoke test)"
-    if "${CLAW_BIN}" --help >/dev/null 2>&1; then
-        ok "claw --help responded"
-    else
-        error "claw --help failed"
-        exit 1
-    fi
-fi
-
-# ---------------------------------------------------------------------------
-# Step 6: next steps
-# ---------------------------------------------------------------------------
-
-step "Next steps"
-
-cat <<EOF
-${COLOR_GREEN}Claw Code is built and ready.${COLOR_RESET}
-
-  Binary:  ${COLOR_BOLD}${CLAW_BIN}${COLOR_RESET}
-  Profile: ${BUILD_PROFILE}
-
-Try it out:
-
-  ${COLOR_DIM}# interactive REPL${COLOR_RESET}
-  ${CLAW_BIN}
-
-  ${COLOR_DIM}# one-shot prompt${COLOR_RESET}
-  ${CLAW_BIN} prompt "summarize this repository"
-
-  ${COLOR_DIM}# health check (run /doctor inside the REPL)${COLOR_RESET}
-  ${CLAW_BIN}
-  /doctor
-
-Authentication:
-
-  export ANTHROPIC_API_KEY="sk-ant-..."
-  ${COLOR_DIM}# or use OAuth:${COLOR_RESET}
-  ${CLAW_BIN} login
-
-For deeper docs, see USAGE.md and rust/README.md.
-EOF
-
-# clear the failure trap on clean exit
-trap - EXIT

prd.json

@@ -1,356 +0,0 @@
-{
-  "version": "1.0",
-  "description": "Clawable Coding Harness - Clear roadmap stories and commit each",
-  "stories": [
-    {
-      "id": "US-001",
-      "title": "Phase 1.6 - startup-no-evidence evidence bundle + classifier",
-      "description": "When startup times out, emit typed worker.startup_no_evidence event with evidence bundle including last known worker lifecycle state, pane command, prompt-send timestamp, prompt-acceptance state, trust-prompt detection result, and transport/MCP health summary. Classifier should down-rank into specific failure classes.",
-      "acceptanceCriteria": [
-        "worker.startup_no_evidence event emitted on startup timeout with evidence bundle",
-        "Evidence bundle includes: last lifecycle state, pane command, prompt-send timestamp, prompt-acceptance state, trust-prompt detection, transport/MCP health",
-        "Classifier attempts to categorize into: trust_required, prompt_misdelivery, prompt_acceptance_timeout, transport_dead, worker_crashed, or unknown",
-        "Tests verify evidence bundle structure and classifier behavior"
-      ],
-      "passes": true,
-      "priority": "P0"
-    },
-    {
-      "id": "US-002",
-      "title": "Phase 2 - Canonical lane event schema (4.x series)",
-      "description": "Define typed events for lane lifecycle: 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. Also implement event ordering, reconciliation, provenance, deduplication, and projection contracts.",
-      "acceptanceCriteria": [
-        "LaneEvent enum with all required variants defined",
-        "Event ordering with monotonic sequence metadata attached",
-        "Event provenance labels (live_lane, test, healthcheck, replay, transport)",
-        "Session identity completeness at creation (title, workspace, purpose)",
-        "Duplicate terminal-event suppression with fingerprinting",
-        "Lane ownership/scope binding in events",
-        "Nudge acknowledgment with dedupe contract",
-        "clawhip consumes typed lane events instead of pane scraping"
-      ],
-      "passes": true,
-      "priority": "P0"
-    },
-    {
-      "id": "US-003",
-      "title": "Phase 3 - Stale-branch detection before broad verification",
-      "description": "Before broad test runs, compare current branch to main and detect if known fixes are missing. Emit branch.stale_against_main event and suggest/auto-run rebase/merge-forward.",
-      "acceptanceCriteria": [
-        "Branch freshness comparison against main implemented",
-        "branch.stale_against_main event emitted when behind",
-        "Auto-rebase/merge-forward policy integration",
-        "Avoid misclassifying stale-branch failures as new regressions"
-      ],
-      "passes": true,
-      "priority": "P1"
-    },
-    {
-      "id": "US-004",
-      "title": "Phase 3 - Recovery recipes with ledger",
-      "description": "Encode automatic recoveries for common failures (trust prompt, prompt misdelivery, stale branch, compile red, MCP startup). Expose recovery attempt ledger with recipe id, attempt count, state, timestamps, failure summary.",
-      "acceptanceCriteria": [
-        "Recovery recipes defined for: trust_prompt_unresolved, prompt_delivered_to_shell, stale_branch, compile_red_after_refactor, MCP_handshake_failure, partial_plugin_startup",
-        "Recovery attempt ledger with: recipe id, attempt count, state, timestamps, failure summary, escalation reason",
-        "One automatic recovery attempt before escalation",
-        "Ledger emitted as structured event data"
-      ],
-      "passes": true,
-      "priority": "P1"
-    },
-    {
-      "id": "US-005",
-      "title": "Phase 4 - Typed task packet format",
-      "description": "Define structured task packet with fields: objective, scope, repo/worktree, branch policy, acceptance tests, commit policy, reporting contract, escalation policy.",
-      "acceptanceCriteria": [
-        "TaskPacket struct with all required fields",
-        "TaskScope resolution (workspace/module/single-file/custom)",
-        "Validation and serialization support",
-        "Integration into tools/src/lib.rs"
-      ],
-      "passes": true,
-      "priority": "P1"
-    },
-    {
-      "id": "US-006",
-      "title": "Phase 4 - Policy engine for autonomous coding",
-      "description": "Encode automation rules: 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.",
-      "acceptanceCriteria": [
-        "Policy rules engine implemented",
-        "Rules: green + scoped diff + review -> merge",
-        "Rules: stale branch -> merge-forward before tests",
-        "Rules: startup blocked -> recover once, then escalate",
-        "Rules: lane completed -> closeout and cleanup"
-      ],
-      "passes": true,
-      "priority": "P2"
-    },
-    {
-      "id": "US-007",
-      "title": "Phase 5 - Plugin/MCP lifecycle maturity",
-      "description": "First-class plugin/MCP lifecycle contract: config validation, startup healthcheck, discovery result, degraded-mode behavior, shutdown/cleanup. Close gaps in end-to-end lifecycle.",
-      "acceptanceCriteria": [
-        "Plugin/MCP config validation contract",
-        "Startup healthcheck with structured results",
-        "Discovery result reporting",
-        "Degraded-mode behavior documented and implemented",
-        "Shutdown/cleanup contract",
-        "Partial startup and per-server failures reported structurally"
-      ],
-      "passes": true,
-      "priority": "P2"
-    },
-    {
-      "id": "US-008",
-      "title": "Fix kimi-k2.5 model API compatibility",
-      "description": "The kimi-k2.5 model (and other kimi models) reject API requests containing the is_error field in tool result messages. The OpenAI-compatible provider currently always includes is_error for all models. Need to make this field conditional based on model support.",
-      "acceptanceCriteria": [
-        "translate_message function accepts model parameter",
-        "is_error field excluded for kimi models (kimi-k2.5, kimi-k1.5, etc.)",
-        "is_error field included for models that support it (openai, grok, xai, etc.)",
-        "build_chat_completion_request passes model to translate_message",
-        "Tests verify is_error presence/absence based on model",
-        "cargo test passes",
-        "cargo clippy passes",
-        "cargo fmt passes"
-      ],
-      "passes": true,
-      "priority": "P0"
-    },
-    {
-      "id": "US-009",
-      "title": "Add unit tests for kimi model compatibility fix",
-      "description": "During dogfooding we discovered the existing test coverage for model-specific is_error handling is insufficient. Need to add dedicated tests for model_rejects_is_error_field function and translate_message behavior with different models.",
-      "acceptanceCriteria": [
-        "Test model_rejects_is_error_field identifies kimi-k2.5, kimi-k1.5, dashscope/kimi-k2.5",
-        "Test translate_message includes is_error for gpt-4, grok-3, claude models",
-        "Test translate_message excludes is_error for kimi models",
-        "Test build_chat_completion_request produces correct payload for kimi vs non-kimi",
-        "All new tests pass",
-        "cargo test --package api passes"
-      ],
-      "passes": true,
-      "priority": "P1"
-    },
-    {
-      "id": "US-010",
-      "title": "Add model compatibility documentation",
-      "description": "Document which models require special handling (is_error exclusion, reasoning model tuning param stripping, etc.) in a MODEL_COMPATIBILITY.md file for operators and contributors.",
-      "acceptanceCriteria": [
-        "MODEL_COMPATIBILITY.md created in docs/ or repo root",
-        "Document kimi models is_error exclusion",
-        "Document reasoning models (o1, o3, grok-3-mini) tuning param stripping",
-        "Document gpt-5 max_completion_tokens requirement",
-        "Document qwen model routing through dashscope",
-        "Cross-reference with existing code comments"
-      ],
-      "passes": true,
-      "priority": "P2"
-    },
-    {
-      "id": "US-011",
-      "title": "Performance optimization: reduce API request serialization overhead",
-      "description": "The translate_message function creates intermediate JSON Value objects that could be optimized. Profile and optimize the hot path for API request building, especially for conversations with many tool results.",
-      "acceptanceCriteria": [
-        "Profile current request building with criterion or similar",
-        "Identify bottlenecks in translate_message and build_chat_completion_request",
-        "Implement optimizations (Vec pre-allocation, reduced cloning, etc.)",
-        "Benchmark before/after showing improvement",
-        "No functional changes or API breakage"
-      ],
-      "passes": true,
-      "priority": "P2"
-    },
-    {
-      "id": "US-012",
-      "title": "Trust prompt resolver with allowlist auto-trust",
-      "description": "Add allowlisted auto-trust behavior for known repos/worktrees. Trust prompts currently block TUI startup and require manual intervention. Implement automatic trust resolution for pre-approved repositories.",
-      "acceptanceCriteria": [
-        "TrustAllowlist config structure with repo patterns",
-        "Auto-trust behavior for allowlisted repos/worktrees",
-        "trust_required event emitted when trust prompt detected",
-        "trust_resolved event emitted when trust is granted",
-        "Non-allowlisted repos remain gated (manual trust required)",
-        "Integration with worker boot lifecycle",
-        "Tests for allowlist matching and event emission"
-      ],
-      "passes": true,
-      "priority": "P1"
-    },
-    {
-      "id": "US-013",
-      "title": "Phase 2 - Session event ordering + terminal-state reconciliation",
-      "description": "When the same session emits contradictory lifecycle events (idle, error, completed, transport/server-down) in close succession, expose deterministic final truth. Attach monotonic sequence/causal ordering metadata, classify terminal vs advisory events, reconcile duplicate/out-of-order terminal events into one canonical lane outcome.",
-      "acceptanceCriteria": [
-        "Monotonic sequence / causal ordering metadata attached to session lifecycle events",
-        "Terminal vs advisory event classification implemented",
-        "Reconcile duplicate or out-of-order terminal events into one canonical outcome",
-        "Distinguish 'session terminal state unknown because transport died' from real 'completed'",
-        "Tests verify reconciliation behavior with out-of-order event bursts"
-      ],
-      "passes": true,
-      "priority": "P1"
-    },
-    {
-      "id": "US-014",
-      "title": "Phase 2 - Event provenance / environment labeling",
-      "description": "Every emitted event should declare its source (live_lane, test, healthcheck, replay, transport) so claws do not mistake test noise for production truth. Include environment/channel label, emitter identity, and confidence/trust level.",
-      "acceptanceCriteria": [
-        "EventProvenance enum with live_lane, test, healthcheck, replay, transport variants",
-        "Environment/channel label attached to all events",
-        "Emitter identity field on events",
-        "Confidence/trust level field for downstream automation",
-        "Tests verify provenance labeling and filtering"
-      ],
-      "passes": true,
-      "priority": "P1"
-    },
-    {
-      "id": "US-015",
-      "title": "Phase 2 - Session identity completeness at creation time",
-      "description": "A newly created session should emit stable title, workspace/worktree path, and lane/session purpose at creation time. If any field is not yet known, emit explicit typed placeholder reason rather than bare unknown string.",
-      "acceptanceCriteria": [
-        "Session creation emits stable title, workspace/worktree path, purpose immediately",
-        "Explicit typed placeholder when fields unknown (not bare 'unknown' strings)",
-        "Later-enriched metadata reconciles onto same session identity without ambiguity",
-        "Tests verify session identity completeness and placeholder handling"
-      ],
-      "passes": true,
-      "priority": "P1"
-    },
-    {
-      "id": "US-016",
-      "title": "Phase 2 - Duplicate terminal-event suppression",
-      "description": "When the same session emits repeated completed/failed/terminal notifications, collapse duplicates before they trigger repeated downstream reactions. Attach canonical terminal-event fingerprint per lane/session outcome.",
-      "acceptanceCriteria": [
-        "Canonical terminal-event fingerprint attached per lane/session outcome",
-        "Suppress/coalesce repeated terminal notifications within reconciliation window",
-        "Preserve raw event history for audit while exposing one actionable outcome downstream",
-        "Surface when later duplicate materially differs from original terminal payload",
-        "Tests verify deduplication and material difference detection"
-      ],
-      "passes": true,
-      "priority": "P2"
-    },
-    {
-      "id": "US-017",
-      "title": "Phase 2 - Lane ownership / scope binding",
-      "description": "Each session and lane event should declare who owns it and what workflow scope it belongs to. Attach owner/assignee identity, workflow scope (claw-code-dogfood, external-git-maintenance, infra-health, manual-operator), and mark whether watcher is expected to act, observe only, or ignore.",
-      "acceptanceCriteria": [
-        "Owner/assignee identity attached to sessions and lane events",
-        "Workflow scope field (claw-code-dogfood, external-git-maintenance, etc.)",
-        "Watcher action expectation field (act, observe-only, ignore)",
-        "Preserve scope through session restarts, resumes, and late terminal events",
-        "Tests verify ownership and scope binding"
-      ],
-      "passes": true,
-      "priority": "P2"
-    },
-    {
-      "id": "US-018",
-      "title": "Phase 2 - Nudge acknowledgment / dedupe contract",
-      "description": "Periodic clawhip nudges should carry nudge id/cycle id and delivery timestamp. Expose whether claw has already acknowledged or responded for that cycle. Distinguish new nudge, retry nudge, and stale duplicate.",
-      "acceptanceCriteria": [
-        "Nudge id / cycle id and delivery timestamp attached",
-        "Acknowledgment state exposed (already acknowledged or not)",
-        "Distinguish new nudge vs retry nudge vs stale duplicate",
-        "Allow downstream summaries to bind reported pinpoint back to triggering nudge id",
-        "Tests verify nudge deduplication and acknowledgment tracking"
-      ],
-      "passes": true,
-      "priority": "P2"
-    },
-    {
-      "id": "US-019",
-      "title": "Phase 2 - Stable roadmap-id assignment for newly filed pinpoints",
-      "description": "When a claw records a new pinpoint/follow-up, assign or expose a stable tracking id immediately. Expose that id in structured event/report payload and preserve across edits, reorderings, and summary compression.",
-      "acceptanceCriteria": [
-        "Canonical roadmap id assigned at filing time",
-        "Roadmap id exposed in structured event/report payload",
-        "Same id preserved across edits, reorderings, summary compression",
-        "Distinguish 'new roadmap filing' from 'update to existing roadmap item'",
-        "Tests verify stable id assignment and update detection"
-      ],
-      "passes": true,
-      "priority": "P2"
-    },
-    {
-      "id": "US-020",
-      "title": "Phase 2 - Roadmap item lifecycle state contract",
-      "description": "Each roadmap pinpoint should carry machine-readable lifecycle state (filed, acknowledged, in_progress, blocked, done, superseded). Attach last state-change timestamp and preserve lineage when one pinpoint supersedes or merges into another.",
-      "acceptanceCriteria": [
-        "Lifecycle state enum with filed, acknowledged, in_progress, blocked, done, superseded",
-        "Last state-change timestamp attached",
-        "New report can declare first filing, status update, or closure",
-        "Preserve lineage when one pinpoint supersedes or merges into another",
-        "Tests verify lifecycle state transitions"
-      ],
-      "passes": true,
-      "priority": "P2"
-    },
-    {
-      "id": "US-021",
-      "title": "Request body size pre-flight check for OpenAI-compatible provider",
-      "description": "Implement pre-flight request body size estimation to prevent 400 Bad Request errors from API gateways with size limits. Based on dogfood findings with kimi-k2.5 testing, DashScope API has a 6MB request body limit that was exceeded by large system prompts.",
-      "acceptanceCriteria": [
-        "Pre-flight size estimation before sending requests to OpenAI-compatible providers",
-        "Clear error message when request exceeds provider-specific size limit",
-        "Configuration for different provider limits (6MB DashScope, 100MB OpenAI, etc.)",
-        "Unit tests for size estimation and limit checking",
-        "Integration with existing error handling for actionable user messages"
-      ],
-      "passes": true,
-      "priority": "P1"
-    },
-    {
-      "id": "US-022",
-      "title": "Enhanced error context for API failures",
-      "description": "Add structured error context to API failures including request ID tracking across retries, provider-specific error code mapping, and suggested user actions based on error type (e.g., 'Reduce prompt size' for 413, 'Check API key' for 401).",
-      "acceptanceCriteria": [
-        "Request ID tracking across retries with full context in error messages",
-        "Provider-specific error code mapping with actionable suggestions",
-        "Suggested user actions for common error types (401, 403, 413, 429, 500, 502-504)",
-        "Unit tests for error context extraction",
-        "All existing tests pass and clippy is clean"
-      ],
-      "passes": true,
-      "priority": "P1"
-    },
-    {
-      "id": "US-023",
-      "title": "Add automatic routing for kimi models to DashScope",
-      "description": "Based on dogfood findings with kimi-k2.5 testing, users must manually prefix with dashscope/kimi-k2.5 instead of just using kimi-k2.5. Add automatic routing for kimi/ and kimi- prefixed models to DashScope (similar to qwen models), and add a 'kimi' alias to the model registry.",
-      "acceptanceCriteria": [
-        "kimi/ and kimi- prefix routing to DashScope in metadata_for_model()",
-        "'kimi' alias in MODEL_REGISTRY that resolves to 'kimi-k2.5'",
-        "resolve_model_alias() handles the kimi alias correctly",
-        "Unit tests for kimi routing (similar to qwen routing tests)",
-        "All tests pass and clippy is clean"
-      ],
-      "passes": true,
-      "priority": "P1"
-    },
-    {
-      "id": "US-024",
-      "title": "Add token limit metadata for kimi models",
-      "description": "The model_token_limit() function has no entries for kimi-k2.5 or kimi-k1.5, causing preflight context window validation to skip these models. Add token limit metadata to enable preflight checks and accurate max token defaults. Per Moonshot AI documentation, kimi-k2.5 supports 256K context window and 16K max output tokens.",
-      "acceptanceCriteria": [
-        "model_token_limit('kimi-k2.5') returns Some(ModelTokenLimit { max_output_tokens: 16384, context_window_tokens: 256000 })",
-        "model_token_limit('kimi-k1.5') returns appropriate limits",
-        "model_token_limit('kimi') follows alias chain (kimi → kimi-k2.5) and returns k2.5 limits",
-        "preflight_message_request() validates context window for kimi models (via generic preflight, no provider-specific code needed)",
-        "Unit tests verify limits and preflight behavior for kimi models",
-        "All tests pass and clippy is clean"
-      ],
-      "passes": true,
-      "priority": "P1"
-    }
-  ],
-  "metadata": {
-    "lastUpdated": "2026-04-17",
-    "completedStories": ["US-001", "US-002", "US-003", "US-004", "US-005", "US-006", "US-007", "US-008", "US-009", "US-010", "US-011", "US-012", "US-013", "US-014", "US-015", "US-016", "US-017", "US-018", "US-019", "US-020", "US-021", "US-022", "US-023", "US-024"],
-    "inProgressStories": [],
-    "totalStories": 24,
-    "status": "completed"
-  }
-}

progress.txt

@@ -1,378 +0,0 @@
-Ralph Iteration Summary - claw-code Roadmap Implementation
-===========================================================
-
-Iteration 1: 2026-04-16
-------------------------
-
-US-001 COMPLETED (Phase 1.6 - startup-no-evidence evidence bundle + classifier)
-- Files: rust/crates/runtime/src/worker_boot.rs
-- Added StartupFailureClassification enum with 6 variants
-- Added StartupEvidenceBundle with 8 fields
-- Implemented classify_startup_failure() logic
-- Added observe_startup_timeout() method to Worker
-- Tests: 6 new tests verifying classification logic
-
-US-002 COMPLETED (Phase 2 - Canonical lane event schema)
-- Files: rust/crates/runtime/src/lane_events.rs
-- Added EventProvenance enum with 5 labels
-- Added SessionIdentity, LaneOwnership structs
-- Added LaneEventMetadata with sequence/ordering
-- Added LaneEventBuilder for construction
-- Implemented is_terminal_event(), dedupe_terminal_events()
-- Tests: 10 new tests for events and deduplication
-
-US-005 COMPLETED (Phase 4 - Typed task packet format)
-- Files:
-  - rust/crates/runtime/src/task_packet.rs
-  - rust/crates/runtime/src/task_registry.rs
-  - rust/crates/tools/src/lib.rs
-- Added TaskScope enum (Workspace, Module, SingleFile, Custom)
-- Updated TaskPacket with scope_path and worktree fields
-- Added validate_scope_requirements() validation logic
-- Fixed all test compilation errors in dependent modules
-- Tests: Updated existing tests to use new types
-
-PRE-EXISTING IMPLEMENTATIONS (verified working):
-------------------------------------------------
-
-US-003 COMPLETE (Phase 3 - Stale-branch detection)
-- Files: rust/crates/runtime/src/stale_branch.rs
-- BranchFreshness enum (Fresh, Stale, Diverged)
-- StaleBranchPolicy (AutoRebase, AutoMergeForward, WarnOnly, Block)
-- StaleBranchEvent with structured events
-- check_freshness() with git integration
-- apply_policy() with policy resolution
-- Tests: 12 unit tests + 5 integration tests passing
-
-US-004 COMPLETE (Phase 3 - Recovery recipes with ledger)
-- Files: rust/crates/runtime/src/recovery_recipes.rs
-- FailureScenario enum with 7 scenarios
-- RecoveryStep enum with actionable steps
-- RecoveryRecipe with step sequences
-- RecoveryLedger for attempt tracking
-- RecoveryEvent for structured emission
-- attempt_recovery() with escalation logic
-- Tests: 15 unit tests + 1 integration test passing
-
-US-006 COMPLETE (Phase 4 - Policy engine for autonomous coding)
-- Files: rust/crates/runtime/src/policy_engine.rs
-- PolicyRule with condition/action/priority
-- PolicyCondition (And, Or, GreenAt, StaleBranch, etc.)
-- PolicyAction (MergeToDev, RecoverOnce, Escalate, etc.)
-- LaneContext for evaluation context
-- evaluate() for rule matching
-- Tests: 18 unit tests + 6 integration tests passing
-
-US-007 COMPLETE (Phase 5 - Plugin/MCP lifecycle maturity)
-- Files: rust/crates/runtime/src/plugin_lifecycle.rs
-- ServerStatus enum (Healthy, Degraded, Failed)
-- ServerHealth with capabilities tracking
-- PluginState with full lifecycle states
-- PluginLifecycle event tracking
-- PluginHealthcheck structured results
-- DiscoveryResult for capability discovery
-- DegradedMode behavior
-- Tests: 11 unit tests passing
-
-
-Iteration 2026-04-27 - ROADMAP #200 COMPLETED
-------------------------------------------------
-- Selected next actionable backlog item because no active task was in progress.
-- ROADMAP #200: Interactive MCP/tool permission prompts are invisible blockers.
-- Files: rust/crates/runtime/src/worker_boot.rs, rust/crates/runtime/src/recovery_recipes.rs, ROADMAP.md, progress.txt.
-- Added tool_permission_required worker status and event classification for interactive MCP/tool permission gates.
-- Added structured ToolPermissionPrompt payload with server/tool identity and prompt preview.
-- Startup evidence now records tool_permission_prompt_detected and classifies timeout evidence as tool_permission_required.
-- Readiness snapshots now mark tool-permission-gated workers as blocked, not ready/idle.
-- Tests: targeted tool_permission regressions, full runtime test/clippy/fmt pending in Ralph verification loop.
-
-VERIFICATION STATUS:
-------------------
-- cargo build --workspace: PASSED
-- cargo test --workspace: PASSED (476+ unit tests, 12 integration tests)
-- cargo clippy --workspace: PASSED
-
-All 7 stories from prd.json now have passes: true
-
-Iteration 2: 2026-04-16
-------------------------
-
-US-009 COMPLETED (Add unit tests for kimi model compatibility fix)
-- Files: rust/crates/api/src/providers/openai_compat.rs
-- Added 4 comprehensive unit tests:
-  1. model_rejects_is_error_field_detects_kimi_models - verifies detection of kimi-k2.5, kimi-k1.5, dashscope/kimi-k2.5, case insensitivity
-  2. translate_message_includes_is_error_for_non_kimi_models - verifies gpt-4o, grok-3, claude include is_error
-  3. translate_message_excludes_is_error_for_kimi_models - verifies kimi models exclude is_error (prevents 400 Bad Request)
-  4. build_chat_completion_request_kimi_vs_non_kimi_tool_results - full integration test for request building
-- Tests: 4 new tests, 119 unit tests total in api crate (+4), all passing
-- Integration tests: 29 passing (no regressions)
-
-US-010 COMPLETED (Add model compatibility documentation)
-- Files: docs/MODEL_COMPATIBILITY.md
-- Created comprehensive documentation covering:
-  1. Kimi Models (is_error Exclusion) - documents the 400 Bad Request issue and solution
-  2. Reasoning Models (Tuning Parameter Stripping) - covers o1, o3, o4, grok-3-mini, qwen-qwq, qwen3-thinking
-  3. GPT-5 (max_completion_tokens) - documents max_tokens vs max_completion_tokens requirement
-  4. Qwen Models (DashScope Routing) - explains routing and authentication
-- Added implementation details section with key functions
-- Added "Adding New Models" guide for future contributors
-- Added testing section with example commands
-- Cross-referenced with existing code comments in openai_compat.rs
-- cargo clippy passes
-
-Iteration 3: 2026-04-16
-------------------------
-
-US-012 COMPLETED (Trust prompt resolver with allowlist auto-trust)
-- Files: rust/crates/runtime/src/trust_resolver.rs
-- Enhanced TrustConfig with pattern matching and serde support:
-  - TrustAllowlistEntry struct with pattern, worktree_pattern, description
-  - TrustResolution enum (AutoAllowlisted, ManualApproval)
-  - Enhanced TrustEvent variants with serde tags and metadata
-  - Glob pattern matching with * and ? wildcards
-  - Support for path prefix matching and worktree patterns
-- Updated TrustResolver with new resolve() signature:
-  - Added worktree parameter for worktree pattern matching
-  - Proper event emission with TrustResolution
-  - Manual approval detection from screen text
-- Added helper functions:
-  - extract_repo_name() - extracts repo name from path
-  - detect_manual_approval() - detects manual trust from screen text
-  - glob_matches() - recursive backtracking glob matcher
-- Tests: 25 new tests for pattern matching, serialization, and resolver behavior
-- All 483 runtime tests pass
-- cargo clippy passes with no warnings
-
-US-011 COMPLETED (Performance optimization: reduce API request serialization overhead)
-- Files:
-  - rust/crates/api/Cargo.toml (added criterion dev-dependency and bench config)
-  - rust/crates/api/benches/request_building.rs (new benchmark suite)
-  - rust/crates/api/src/providers/openai_compat.rs (optimizations)
-  - rust/crates/api/src/lib.rs (public exports for benchmarks)
-- Optimizations implemented:
-  1. flatten_tool_result_content: Pre-allocate String capacity and avoid intermediate Vec
-     - Before: collected to Vec<String> then joined
-     - After: single String with pre-calculated capacity, push directly
-  2. Made key functions public for benchmarking: translate_message, build_chat_completion_request,
-     flatten_tool_result_content, is_reasoning_model, model_rejects_is_error_field
-- Benchmark results:
-  - flatten_tool_result_content/single_text: ~17ns
-  - flatten_tool_result_content/multi_text (10 blocks): ~46ns
-  - flatten_tool_result_content/large_content (50 blocks): ~11.7µs
-  - translate_message/text_only: ~200ns
-  - translate_message/tool_result: ~348ns
-  - build_chat_completion_request/10 messages: ~16.4µs
-  - build_chat_completion_request/100 messages: ~209µs
-  - is_reasoning_model detection: ~26-42ns depending on model
-- All tests pass (119 unit tests + 29 integration tests)
-- cargo clippy passes
-
-VERIFICATION STATUS (Iteration 3):
-----------------------------------
-- cargo build --workspace: PASSED
-- cargo test --workspace: PASSED (891+ tests)
-- cargo clippy --workspace --all-targets -- -D warnings: PASSED
-- cargo fmt -- --check: PASSED
-
-All 12 stories from prd.json now have passes: true
-- US-001 through US-007: Pre-existing implementations
-- US-008: kimi-k2.5 model API compatibility fix
-- US-009: Unit tests for kimi model compatibility
-- US-010: Model compatibility documentation
-- US-011: Performance optimization with criterion benchmarks
-- US-012: Trust prompt resolver with allowlist auto-trust
-
-Iteration 4: 2026-04-16
-------------------------
-
-US-013 COMPLETED (Phase 2 - Session event ordering + terminal-state reconciliation)
-- Files: rust/crates/runtime/src/lane_events.rs
-- Added EventTerminality enum (Terminal, Advisory, Uncertainty)
-- Added classify_event_terminality() function for event classification
-- Added reconcile_terminal_events() function for deterministic event ordering:
-  - Sorts events by monotonic sequence number
-  - Deduplicates terminal events by fingerprint
-  - Detects transport death uncertainty (terminal + transport death)
-  - Handles out-of-order event bursts
-- Added events_materially_differ() for detecting meaningful differences
-- Added 8 comprehensive tests for reconciliation logic:
-  - reconcile_terminal_events_sorts_by_monotonic_sequence
-  - reconcile_terminal_events_deduplicates_same_fingerprint
-  - reconcile_terminal_events_detects_transport_death_uncertainty
-  - reconcile_terminal_events_handles_completed_idle_error_completed_noise
-  - reconcile_terminal_events_returns_none_for_empty_input
-  - reconcile_terminal_events_preserves_advisory_events
-  - events_materially_differ_detects_real_differences
-  - classify_event_terminality_correctly_classifies
-- Fixed test compilation issues with LaneEventBuilder API
-
-VERIFICATION STATUS (Iteration 4):
-----------------------------------
-- cargo build --workspace: PASSED
-- cargo test --workspace: PASSED (891+ tests)
-- cargo clippy --workspace --all-targets -- -D warnings: PASSED
-- cargo fmt -- --check: PASSED
-
-US-013 marked passes: true in prd.json
-
-US-014 COMPLETED (Phase 2 - Event provenance / environment labeling)
-- Files: rust/crates/runtime/src/lane_events.rs
-- Added ConfidenceLevel enum (High, Medium, Low, Unknown)
-- Added fields to LaneEventMetadata:
-  - environment_label: Option<String> - environment/channel (production, staging, dev)
-  - emitter_identity: Option<String> - emitter (clawd, plugin-name, operator-id)
-  - confidence_level: Option<ConfidenceLevel> - trust level for automation
-- Added builder methods: with_environment(), with_emitter(), with_confidence()
-- Added filtering functions:
-  - filter_by_provenance() - select events by source
-  - filter_by_environment() - select events by environment label
-  - filter_by_confidence() - select events above confidence threshold
-  - is_test_event() - check if synthetic source (test, healthcheck, replay)
-  - is_live_lane_event() - check if production event
-- Added 7 comprehensive tests for US-014:
-  - confidence_level_round_trips_through_serialization
-  - filter_by_provenance_selects_only_matching_events
-  - filter_by_environment_selects_only_matching_environment
-  - filter_by_confidence_selects_events_above_threshold
-  - is_test_event_detects_synthetic_sources
-  - is_live_lane_event_detects_production_events
-  - lane_event_metadata_includes_us014_fields
-
-US-016 COMPLETED (Phase 2 - Duplicate terminal-event suppression)
-- Files: rust/crates/runtime/src/lane_events.rs
-- Event fingerprinting already implemented via compute_event_fingerprint()
-- Fingerprint attached via LaneEventMetadata.event_fingerprint
-- Deduplication via dedupe_terminal_events() - returns first occurrence of each fingerprint
-- Raw event history preserved separately from deduplicated actionable events
-- Material difference detection via events_materially_differ():
-  - Different event type (Finished vs Failed) is material
-  - Different status is material
-  - Different failure class is material
-  - Different data payload is material
-- Reconcile function surfaces latest terminal event when materially different
-- Added 5 comprehensive tests for US-016:
-  - canonical_terminal_event_fingerprint_attached_to_metadata
-  - dedupe_terminal_events_suppresses_repeated_fingerprints
-  - dedupe_preserves_raw_event_history_separately
-  - events_materially_differ_detects_payload_differences
-  - reconcile_terminal_events_surfaces_latest_when_different
-
-US-017 COMPLETED (Phase 2 - Lane ownership / scope binding)
-- Files: rust/crates/runtime/src/lane_events.rs
-- LaneOwnership struct already existed with:
-  - owner: String - owner/assignee identity
-  - workflow_scope: String - workflow scope (claw-code-dogfood, etc.)
-  - watcher_action: WatcherAction - Act, Observe, Ignore
-- Ownership preserved through lifecycle via with_ownership() builder method
-- All lifecycle events (Started -> Ready -> Finished) preserve ownership
-- Added 3 comprehensive tests for US-017:
-  - lane_ownership_attached_to_metadata
-  - lane_ownership_preserved_through_lifecycle_events
-  - lane_ownership_watcher_action_variants
-
-US-015 COMPLETED (Phase 2 - Session identity completeness at creation time)
-- Files: rust/crates/runtime/src/lane_events.rs
-- SessionIdentity struct already existed with:
-  - title: String - stable title for the session
-  - workspace: String - workspace/worktree path
-  - purpose: String - lane/session purpose
-  - placeholder_reason: Option<String> - reason for placeholder values
-- Added reconcile_enriched() method for updating session identity:
-  - Updates title/workspace/purpose with newly available data
-  - Clears placeholder_reason when real values are provided
-  - Preserves existing values for fields not being updated
-  - Allows incremental enrichment without ambiguity
-- Added 2 comprehensive tests:
-  - session_identity_reconcile_enriched_updates_fields
-  - session_identity_reconcile_preserves_placeholder_if_no_new_data
-
-US-018 COMPLETED (Phase 2 - Nudge acknowledgment / dedupe contract)
-- Files: rust/crates/runtime/src/lane_events.rs
-- Added NudgeTracking struct:
-  - nudge_id: String - unique nudge identifier
-  - delivered_at: String - timestamp of delivery
-  - acknowledged: bool - whether acknowledged
-  - acknowledged_at: Option<String> - when acknowledged
-  - is_retry: bool - whether this is a retry
-  - original_nudge_id: Option<String> - original ID if retry
-- Added NudgeClassification enum (New, Retry, StaleDuplicate)
-- Added classify_nudge() function for deduplication logic
-- Added 6 comprehensive tests for US-018
-
-US-019 COMPLETED (Phase 2 - Stable roadmap-id assignment)
-- Files: rust/crates/runtime/src/lane_events.rs
-- Added RoadmapId struct:
-  - id: String - canonical unique identifier
-  - filed_at: String - timestamp when filed
-  - is_new_filing: bool - new vs update
-  - supersedes: Option<String> - lineage for supersedes
-- Added builder methods: new_filing(), update(), supersedes()
-- Added 3 comprehensive tests for US-019
-
-US-020 COMPLETED (Phase 2 - Roadmap item lifecycle state contract)
-- Files: rust/crates/runtime/src/lane_events.rs
-- Added RoadmapLifecycleState enum (Filed, Acknowledged, InProgress, Blocked, Done, Superseded)
-- Added RoadmapLifecycle struct:
-  - state: RoadmapLifecycleState - current state
-  - state_changed_at: String - last transition timestamp
-  - filed_at: String - original filing timestamp
-  - lineage: Vec<String> - supersession chain
-- Added methods: new_filed(), transition(), superseded_by(), is_terminal(), is_active()
-- Added 5 comprehensive tests for US-020
-
-VERIFICATION STATUS (Iteration 7):
-----------------------------------
-- cargo build --workspace: PASSED
-- cargo test --workspace: PASSED (891+ tests)
-- cargo clippy --workspace --all-targets -- -D warnings: PASSED
-- cargo fmt -- --check: PASSED
-
-US-013 through US-015 and US-018 through US-020 now marked passes: true
-
-FINAL VERIFICATION (All 20 Stories Complete):
-------------------------------------------------
-- cargo build --workspace: PASSED
-- cargo test --workspace: PASSED (119+ API tests, 39 runtime tests, 12 integration tests)
-- cargo clippy --workspace --all-targets -- -D warnings: PASSED
-- cargo fmt -- --check: PASSED
-
-ALL 20 STORIES FROM PRD COMPLETE:
-- US-001 through US-012: Pre-existing implementations (verified working)
-- US-013: Session event ordering + terminal-state reconciliation
-- US-014: Event provenance / environment labeling
-- US-015: Session identity completeness at creation time
-- US-016: Duplicate terminal-event suppression
-- US-017: Lane ownership / scope binding
-- US-018: Nudge acknowledgment / dedupe contract
-- US-019: Stable roadmap-id assignment
-- US-020: Roadmap item lifecycle state contract
-
-Iteration 8: 2026-04-16
-------------------------
-
-US-021 COMPLETED (Request body size pre-flight check - from dogfood findings)
-- Files:
-  - rust/crates/api/src/error.rs (new error variant)
-  - rust/crates/api/src/providers/openai_compat.rs
-- Added RequestBodySizeExceeded error variant with actionable message
-- Added max_request_body_bytes to OpenAiCompatConfig:
-  - DashScope: 6MB (6_291_456 bytes) - from dogfood with kimi-k2.5
-  - OpenAI: 100MB (104_857_600 bytes)
-  - xAI: 50MB (52_428_800 bytes)
-- Added estimate_request_body_size() for pre-flight checks
-- Added check_request_body_size() for validation
-- Pre-flight check integrated in send_raw_request()
-- Tests: 5 new tests for size estimation and limit checking
-
-PROJECT STATUS: COMPLETE (21/21 stories)
-
-Iteration 2026-04-29 - ROADMAP #96 COMPLETED
-------------------------------------------------
-- Pulled origin/main: already up to date.
-- Selected ROADMAP #96 as a small repo-local Immediate Backlog item: the `claw --help` Resume-safe command summary leaked slash-command stubs despite the main Interactive command listing filtering them.
-- Files: rust/crates/rusty-claude-cli/src/main.rs, ROADMAP.md, progress.txt.
-- Changed help rendering to filter `resume_supported_slash_commands()` through `STUB_COMMANDS` before building the Resume-safe one-liner.
-- Added `stub_commands_absent_from_resume_safe_help` regression coverage so future stub additions cannot leak into the Resume-safe summary.
-- Targeted verification: `cargo test -p rusty-claude-cli stub_commands_absent_from_resume_safe_help -- --nocapture` passed; `cargo test -p rusty-claude-cli parses_direct_cli_actions -- --nocapture` passed.
-- Format/check verification: `cargo fmt --all --check`, `git diff --check`, and `cargo check -p rusty-claude-cli` passed.
-- Broader clippy note: `cargo clippy -p rusty-claude-cli --all-targets -- -D warnings` is blocked by pre-existing `clippy::unnecessary_wraps` failures in `rust/crates/commands/src/lib.rs` (`render_mcp_report_for`, `render_mcp_report_json_for`), outside this diff.

rust/.claw.json

@@ -1,5 +0,0 @@
-{
-  "permissions": {
-    "defaultMode": "dontAsk"
-  }
-}

rust/.claw/sessions/session-1775386832313-0.jsonl

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

rust/.claw/sessions/session-1775386842352-0.jsonl

@@ -1,2 +0,0 @@
-{"created_at_ms":1775386842352,"session_id":"session-1775386842352-0","type":"session_meta","updated_at_ms":1775386842352,"version":1}
-{"message":{"blocks":[{"text":"doctor --help","type":"text"}],"role":"user"},"type":"message"}

rust/.claw/sessions/session-1775386852257-0.jsonl

@@ -1,2 +0,0 @@
-{"created_at_ms":1775386852257,"session_id":"session-1775386852257-0","type":"session_meta","updated_at_ms":1775386852257,"version":1}
-{"message":{"blocks":[{"text":"doctor --help","type":"text"}],"role":"user"},"type":"message"}

rust/.claw/sessions/session-1775386853666-0.jsonl

@@ -1,2 +0,0 @@
-{"created_at_ms":1775386853666,"session_id":"session-1775386853666-0","type":"session_meta","updated_at_ms":1775386853666,"version":1}
-{"message":{"blocks":[{"text":"status --help","type":"text"}],"role":"user"},"type":"message"}

rust/.gitignore

@@ -1,7 +1,3 @@
 target/
 .omx/
 .clawd-agents/
-# Claw Code local artifacts
-.claw/settings.local.json
-.claw/sessions/
-.clawhip/

rust/CLAUDE.md

@@ -1,16 +0,0 @@
-# CLAUDE.md
-
-This file provides guidance to Claw Code (clawcode.dev) when working with code in this repository.
-
-## Detected stack
-- Languages: Rust.
-- Frameworks: none detected from the supported starter markers.
-
-## Verification
-- From the repository root, run Rust formatting with `scripts/fmt.sh` (or `scripts/fmt.sh --check` for CI-style checks). From this `rust/` directory, the equivalent command is `../scripts/fmt.sh`. Root-level `cargo fmt --manifest-path rust/Cargo.toml` is not the supported formatting command.
-- From this `rust/` directory, run Rust verification with `cargo clippy --workspace --all-targets -- -D warnings` and `cargo test --workspace`.
-
-## Working agreement
-- Prefer small, reviewable changes and keep generated bootstrap files aligned with actual repo workflows.
-- Keep shared defaults in `.claw.json`; reserve `.claw/settings.local.json` for machine-local overrides.
-- Do not overwrite existing `CLAUDE.md` content automatically; update it intentionally when repo workflows change.

rust/Cargo.lock

@@ -17,28 +17,14 @@ dependencies = [
  "memchr",
 ]
 
-[[package]]
-name = "anes"
-version = "0.1.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299"
-
-[[package]]
-name = "anstyle"
-version = "1.0.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "940b3a0ca603d1eade50a4846a2afffd5ef57a9feac2c0e2ec2e14f9ead76000"
-
 [[package]]
 name = "api"
 version = "0.1.0"
 dependencies = [
- "criterion",
  "reqwest",
  "runtime",
  "serde",
  "serde_json",
- "telemetry",
  "tokio",
 ]
 
@@ -48,12 +34,6 @@ version = "1.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0"
 
-[[package]]
-name = "autocfg"
-version = "1.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
-
 [[package]]
 name = "base64"
 version = "0.22.1"
@@ -96,12 +76,6 @@ version = "1.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33"
 
-[[package]]
-name = "cast"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
-
 [[package]]
 name = "cc"
 version = "1.2.58"
@@ -124,58 +98,6 @@ version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
 
-[[package]]
-name = "ciborium"
-version = "0.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "42e69ffd6f0917f5c029256a24d0161db17cea3997d185db0d35926308770f0e"
-dependencies = [
- "ciborium-io",
- "ciborium-ll",
- "serde",
-]
-
-[[package]]
-name = "ciborium-io"
-version = "0.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05afea1e0a06c9be33d539b876f1ce3692f4afea2cb41f740e7743225ed1c757"
-
-[[package]]
-name = "ciborium-ll"
-version = "0.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "57663b653d948a338bfb3eeba9bb2fd5fcfaecb9e199e87e1eda4d9e8b240fd9"
-dependencies = [
- "ciborium-io",
- "half",
-]
-
-[[package]]
-name = "clap"
-version = "4.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ddb117e43bbf7dacf0a4190fef4d345b9bad68dfc649cb349e7d17d28428e51"
-dependencies = [
- "clap_builder",
-]
-
-[[package]]
-name = "clap_builder"
-version = "4.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "714a53001bf66416adb0e2ef5ac857140e7dc3a0c48fb28b2f10762fc4b5069f"
-dependencies = [
- "anstyle",
- "clap_lex",
-]
-
-[[package]]
-name = "clap_lex"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c8d4a3bb8b1e0c1050499d1815f5ab16d04f0959b233085fb31653fbfc9d98f9"
-
 [[package]]
 name = "clipboard-win"
 version = "5.4.1"
@@ -189,9 +111,7 @@ dependencies = [
 name = "commands"
 version = "0.1.0"
 dependencies = [
- "plugins",
  "runtime",
- "serde_json",
 ]
 
 [[package]]
@@ -221,67 +141,6 @@ dependencies = [
  "cfg-if",
 ]
 
-[[package]]
-name = "criterion"
-version = "0.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2b12d017a929603d80db1831cd3a24082f8137ce19c69e6447f54f5fc8d692f"
-dependencies = [
- "anes",
- "cast",
- "ciborium",
- "clap",
- "criterion-plot",
- "is-terminal",
- "itertools",
- "num-traits",
- "once_cell",
- "oorandom",
- "plotters",
- "rayon",
- "regex",
- "serde",
- "serde_derive",
- "serde_json",
- "tinytemplate",
- "walkdir",
-]
-
-[[package]]
-name = "criterion-plot"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6b50826342786a51a89e2da3a28f1c32b06e387201bc2d19791f622c673706b1"
-dependencies = [
- "cast",
- "itertools",
-]
-
-[[package]]
-name = "crossbeam-deque"
-version = "0.8.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9dd111b7b7f7d55b72c0a6ae361660ee5853c9af73f70c3c2ef6858b950e2e51"
-dependencies = [
- "crossbeam-epoch",
- "crossbeam-utils",
-]
-
-[[package]]
-name = "crossbeam-epoch"
-version = "0.9.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
-dependencies = [
- "crossbeam-utils",
-]
-
-[[package]]
-name = "crossbeam-utils"
-version = "0.8.21"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
-
 [[package]]
 name = "crossterm"
 version = "0.28.1"
@@ -307,12 +166,6 @@ dependencies = [
  "winapi",
 ]
 
-[[package]]
-name = "crunchy"
-version = "0.2.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5"
-
 [[package]]
 name = "crypto-common"
 version = "0.1.7"
@@ -353,12 +206,6 @@ dependencies = [
  "syn",
 ]
 
-[[package]]
-name = "either"
-version = "1.15.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
-
 [[package]]
 name = "endian-type"
 version = "0.1.2"
@@ -395,7 +242,7 @@ checksum = "0ce92ff622d6dadf7349484f42c93271a0d49b7cc4d466a936405bacbe10aa78"
 dependencies = [
  "cfg-if",
  "rustix 1.1.4",
- "windows-sys 0.59.0",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -530,29 +377,12 @@ version = "0.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280"
 
-[[package]]
-name = "half"
-version = "2.7.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b"
-dependencies = [
- "cfg-if",
- "crunchy",
- "zerocopy",
-]
-
 [[package]]
 name = "hashbrown"
 version = "0.16.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"
 
-[[package]]
-name = "hermit-abi"
-version = "0.5.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c"
-
 [[package]]
 name = "home"
 version = "0.5.12"
@@ -789,26 +619,6 @@ dependencies = [
  "serde",
 ]
 
-[[package]]
-name = "is-terminal"
-version = "0.4.17"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3640c1c38b8e4e43584d8df18be5fc6b0aa314ce6ebf51b53313d4306cca8e46"
-dependencies = [
- "hermit-abi",
- "libc",
- "windows-sys 0.61.2",
-]
-
-[[package]]
-name = "itertools"
-version = "0.10.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
-dependencies = [
- "either",
-]
-
 [[package]]
 name = "itoa"
 version = "1.0.18"
@@ -906,15 +716,6 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
-[[package]]
-name = "mock-anthropic-service"
-version = "0.1.0"
-dependencies = [
- "api",
- "serde_json",
- "tokio",
-]
-
 [[package]]
 name = "nibble_vec"
 version = "0.1.0"
@@ -942,15 +743,6 @@ version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c6673768db2d862beb9b39a78fdcb1a69439615d5794a1be50caa9bc92c81967"
 
-[[package]]
-name = "num-traits"
-version = "0.2.19"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
-dependencies = [
- "autocfg",
-]
-
 [[package]]
 name = "once_cell"
 version = "1.21.4"
@@ -979,12 +771,6 @@ dependencies = [
  "pkg-config",
 ]
 
-[[package]]
-name = "oorandom"
-version = "11.1.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d6790f58c7ff633d8771f42965289203411a5e5c68388703c06e14f24770b41e"
-
 [[package]]
 name = "parking_lot"
 version = "0.12.5"
@@ -1039,42 +825,6 @@ dependencies = [
  "time",
 ]
 
-[[package]]
-name = "plotters"
-version = "0.3.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5aeb6f403d7a4911efb1e33402027fc44f29b5bf6def3effcc22d7bb75f2b747"
-dependencies = [
- "num-traits",
- "plotters-backend",
- "plotters-svg",
- "wasm-bindgen",
- "web-sys",
-]
-
-[[package]]
-name = "plotters-backend"
-version = "0.3.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df42e13c12958a16b3f7f4386b9ab1f3e7933914ecea48da7139435263a4172a"
-
-[[package]]
-name = "plotters-svg"
-version = "0.3.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "51bae2ac328883f7acdfea3d66a7c35751187f870bc81f94563733a154d7a670"
-dependencies = [
- "plotters-backend",
-]
-
-[[package]]
-name = "plugins"
-version = "0.1.0"
-dependencies = [
- "serde",
- "serde_json",
-]
-
 [[package]]
 name = "potential_utf"
 version = "0.1.4"
@@ -1245,26 +995,6 @@ dependencies = [
  "getrandom 0.3.4",
 ]
 
-[[package]]
-name = "rayon"
-version = "1.12.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fb39b166781f92d482534ef4b4b1b2568f42613b53e5b6c160e24cfbfa30926d"
-dependencies = [
- "either",
- "rayon-core",
-]
-
-[[package]]
-name = "rayon-core"
-version = "1.13.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91"
-dependencies = [
- "crossbeam-deque",
- "crossbeam-utils",
-]
-
 [[package]]
 name = "redox_syscall"
 version = "0.5.18"
@@ -1362,12 +1092,10 @@ name = "runtime"
 version = "0.1.0"
 dependencies = [
  "glob",
- "plugins",
  "regex",
  "serde",
  "serde_json",
  "sha2",
- "telemetry",
  "tokio",
  "walkdir",
 ]
@@ -1388,7 +1116,7 @@ dependencies = [
  "errno",
  "libc",
  "linux-raw-sys 0.4.15",
- "windows-sys 0.59.0",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -1453,12 +1181,9 @@ dependencies = [
  "commands",
  "compat-harness",
  "crossterm",
- "mock-anthropic-service",
- "plugins",
  "pulldown-cmark",
  "runtime",
  "rustyline",
- "serde",
  "serde_json",
  "syntect",
  "tokio",
@@ -1703,14 +1428,6 @@ dependencies = [
  "yaml-rust",
 ]
 
-[[package]]
-name = "telemetry"
-version = "0.1.0"
-dependencies = [
- "serde",
- "serde_json",
-]
-
 [[package]]
 name = "thiserror"
 version = "2.0.18"
@@ -1772,16 +1489,6 @@ dependencies = [
  "zerovec",
 ]
 
-[[package]]
-name = "tinytemplate"
-version = "1.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "be4d6b5f19ff7664e8c98d03e2139cb510db9b0a60b55f8e8709b689d939b6bc"
-dependencies = [
- "serde",
- "serde_json",
-]
-
 [[package]]
 name = "tinyvec"
 version = "1.11.0"
@@ -1839,9 +1546,6 @@ name = "tools"
 version = "0.1.0"
 dependencies = [
  "api",
- "commands",
- "flate2",
- "plugins",
  "reqwest",
  "runtime",
  "serde",

rust/Cargo.toml

@@ -8,9 +8,6 @@ edition = "2021"
 license = "MIT"
 publish = false
 
-[workspace.dependencies]
-serde_json = "1"
-
 [workspace.lints.rust]
 unsafe_code = "forbid"
 

rust/MOCK_PARITY_HARNESS.md

@@ -1,49 +0,0 @@
-# Mock LLM parity harness
-
-This milestone adds a deterministic Anthropic-compatible mock service plus a reproducible CLI harness for the Rust `claw` binary.
-
-## Artifacts
-
-- `crates/mock-anthropic-service/` — mock `/v1/messages` service
-- `crates/rusty-claude-cli/tests/mock_parity_harness.rs` — end-to-end clean-environment harness
-- `scripts/run_mock_parity_harness.sh` — convenience wrapper
-
-## Scenarios
-
-The harness runs these scripted scenarios against a fresh workspace and isolated environment variables:
-
-1. `streaming_text`
-2. `read_file_roundtrip`
-3. `grep_chunk_assembly`
-4. `write_file_allowed`
-5. `write_file_denied`
-6. `multi_tool_turn_roundtrip`
-7. `bash_stdout_roundtrip`
-8. `bash_permission_prompt_approved`
-9. `bash_permission_prompt_denied`
-10. `plugin_tool_roundtrip`
-
-## Run
-
-```bash
-cd rust/
-./scripts/run_mock_parity_harness.sh
-```
-
-Behavioral checklist / parity diff:
-
-```bash
-cd rust/
-python3 scripts/run_mock_parity_diff.py
-```
-
-Scenario-to-PARITY mappings live in `mock_parity_scenarios.json`.
-
-## Manual mock server
-
-```bash
-cd rust/
-cargo run -p mock-anthropic-service -- --bind 127.0.0.1:0
-```
-
-The server prints `MOCK_ANTHROPIC_BASE_URL=...`; point `ANTHROPIC_BASE_URL` at that URL and use any non-empty `ANTHROPIC_API_KEY`.

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/README.md

@@ -2,26 +2,21 @@
 
 A high-performance Rust rewrite of the Claw Code CLI agent harness. Built for speed, safety, and native tool execution.
 
-For a task-oriented guide with copy/paste examples, see [`../USAGE.md`](../USAGE.md).
-
 ## Quick Start
 
 ```bash
-# Inspect available commands
+# Build
 cd rust/
-cargo run -p rusty-claude-cli -- --help
+cargo build --release
 
-# Build the workspace
-cargo build --workspace
-
-# Run the interactive REPL
-cargo run -p rusty-claude-cli -- --model claude-opus-4-6
+# Run interactive REPL
+./target/release/claw
 
 # One-shot prompt
-cargo run -p rusty-claude-cli -- prompt "explain this codebase"
+./target/release/claw prompt "explain this codebase"
 
-# JSON output for automation
-cargo run -p rusty-claude-cli -- --output-format json prompt "summarize src/main.rs"
+# With specific model
+./target/release/claw --model sonnet prompt "fix the bug in main.rs"
 ```
 
 ## Configuration
@@ -34,74 +29,38 @@ export ANTHROPIC_API_KEY="sk-ant-..."
 export ANTHROPIC_BASE_URL="https://your-proxy.com"
 ```
 
-Or provide an OAuth bearer token directly:
+Or authenticate via OAuth:
 
 ```bash
-export ANTHROPIC_AUTH_TOKEN="anthropic-oauth-or-proxy-bearer-token"
+claw login
 ```
 
-## Mock parity harness
-
-The workspace now includes a deterministic Anthropic-compatible mock service and a clean-environment CLI harness for end-to-end parity checks.
-
-```bash
-cd rust/
-
-# Run the scripted clean-environment harness
-./scripts/run_mock_parity_harness.sh
-
-# Or start the mock service manually for ad hoc CLI runs
-cargo run -p mock-anthropic-service -- --bind 127.0.0.1:0
-```
-
-Harness coverage:
-
-- `streaming_text`
-- `read_file_roundtrip`
-- `grep_chunk_assembly`
-- `write_file_allowed`
-- `write_file_denied`
-- `multi_tool_turn_roundtrip`
-- `bash_stdout_roundtrip`
-- `bash_permission_prompt_approved`
-- `bash_permission_prompt_denied`
-- `plugin_tool_roundtrip`
-
-Primary artifacts:
-
-- `crates/mock-anthropic-service/` — reusable mock Anthropic-compatible service
-- `crates/rusty-claude-cli/tests/mock_parity_harness.rs` — clean-env CLI harness
-- `scripts/run_mock_parity_harness.sh` — reproducible wrapper
-- `scripts/run_mock_parity_diff.py` — scenario checklist + PARITY mapping runner
-- `mock_parity_scenarios.json` — scenario-to-PARITY manifest
-
 ## Features
 
 | Feature | Status |
 |---------|--------|
-| Anthropic / OpenAI-compatible provider flows + streaming | ✅ |
-| Direct bearer-token auth via `ANTHROPIC_AUTH_TOKEN` | ✅ |
+| Anthropic API + streaming | ✅ |
+| OAuth login/logout | ✅ |
 | Interactive REPL (rustyline) | ✅ |
 | Tool system (bash, read, write, edit, grep, glob) | ✅ |
 | Web tools (search, fetch) | ✅ |
-| Sub-agent / agent surfaces | ✅ |
+| Sub-agent orchestration | ✅ |
 | Todo tracking | ✅ |
 | Notebook editing | ✅ |
 | CLAUDE.md / project memory | ✅ |
-| Config file hierarchy (`.claw.json` + merged config sections) | ✅ |
+| Config file hierarchy (.claude.json) | ✅ |
 | Permission system | ✅ |
-| MCP server lifecycle + inspection | ✅ |
+| MCP server lifecycle | ✅ |
 | Session persistence + resume | ✅ |
-| Cost / usage / stats surfaces | ✅ |
+| Extended thinking (thinking blocks) | ✅ |
+| Cost tracking + usage display | ✅ |
 | Git integration | ✅ |
 | Markdown terminal rendering (ANSI) | ✅ |
 | Model aliases (opus/sonnet/haiku) | ✅ |
-| Direct CLI subcommands (`status`, `sandbox`, `agents`, `mcp`, `skills`, `doctor`) | ✅ |
-| Slash commands (including `/skills`, `/agents`, `/mcp`, `/doctor`, `/plugin`, `/subagent`) | ✅ |
-| Hooks (`/hooks`, config-backed lifecycle hooks) | ✅ |
-| Plugin management surfaces | ✅ |
-| Skills inventory / install surfaces | ✅ |
-| Machine-readable JSON output across core CLI surfaces | ✅ |
+| Slash commands (/status, /compact, /clear, etc.) | ✅ |
+| Hooks (PreToolUse/PostToolUse) | 🔧 Config only |
+| Plugin system | 📋 Planned |
+| Skills registry | 📋 Planned |
 
 ## Model Aliases
 
@@ -113,102 +72,74 @@ Short names resolve to the latest model versions:
 | `sonnet` | `claude-sonnet-4-6` |
 | `haiku` | `claude-haiku-4-5-20251213` |
 
-## CLI Flags and Commands
+## CLI Flags
 
-Representative current surface:
-
-```text
+```
 claw [OPTIONS] [COMMAND]
 
-Flags:
-  --model MODEL
-  --output-format text|json
-  --permission-mode MODE
-  --dangerously-skip-permissions
-  --allowedTools TOOLS
-  --resume [SESSION.jsonl|session-id|latest]
-  --version, -V
+Options:
+  --model MODEL                    Set the model (alias or full name)
+  --dangerously-skip-permissions   Skip all permission checks
+  --permission-mode MODE           Set read-only, workspace-write, or danger-full-access
+  --allowedTools TOOLS             Restrict enabled tools
+  --output-format FORMAT           Output format (text or json)
+  --version, -V                    Print version info
 
-Top-level commands:
-  prompt <text>
-  help
-  version
-  status
-  sandbox
-  acp [serve]
-  dump-manifests
-  bootstrap-plan
-  agents
-  mcp
-  skills
-  system-prompt
-  init
-```
-
-`claw acp` is a local discoverability surface for editor-first users: it reports the current ACP/Zed status without starting the runtime. As of April 16, 2026, claw-code does **not** ship an ACP/Zed daemon entrypoint yet, and `claw acp serve` is only a status alias until the real protocol surface lands.
-
-The command surface is moving quickly. For the canonical live help text, run:
-
-```bash
-cargo run -p rusty-claude-cli -- --help
+Commands:
+  prompt <text>      One-shot prompt (non-interactive)
+  login              Authenticate via OAuth
+  logout             Clear stored credentials
+  init               Initialize project config
+  doctor             Check environment health
+  self-update        Update to latest version
 ```
 
 ## Slash Commands (REPL)
 
-Tab completion expands slash commands, model aliases, permission modes, and recent session IDs.
-
-The REPL now exposes a much broader surface than the original minimal shell:
-
-- session / visibility: `/help`, `/status`, `/sandbox`, `/cost`, `/resume`, `/session`, `/version`, `/usage`, `/stats`
-- workspace / git: `/compact`, `/clear`, `/config`, `/memory`, `/init`, `/diff`, `/commit`, `/pr`, `/issue`, `/export`, `/hooks`, `/files`, `/release-notes`
-- discovery / debugging: `/mcp`, `/agents`, `/skills`, `/doctor`, `/tasks`, `/context`, `/desktop`
-- automation / analysis: `/review`, `/advisor`, `/insights`, `/security-review`, `/subagent`, `/team`, `/telemetry`, `/providers`, `/cron`, and more
-- plugin management: `/plugin` (with aliases `/plugins`, `/marketplace`)
-
-Notable claw-first surfaces now available directly in slash form:
-- `/skills [list|install <path>|help]`
-- `/agents [list|help]`
-- `/mcp [list|show <server>|help]`
-- `/doctor`
-- `/plugin [list|install <path>|enable <name>|disable <name>|uninstall <id>|update <id>]`
-- `/subagent [list|steer <target> <msg>|kill <id>]`
-
-See [`../USAGE.md`](../USAGE.md) for usage examples and run `cargo run -p rusty-claude-cli -- --help` for the live canonical command list.
+| Command | Description |
+|---------|-------------|
+| `/help` | Show help |
+| `/status` | Show session status (model, tokens, cost) |
+| `/cost` | Show cost breakdown |
+| `/compact` | Compact conversation history |
+| `/clear` | Clear conversation |
+| `/model [name]` | Show or switch model |
+| `/permissions` | Show or switch permission mode |
+| `/config [section]` | Show config (env, hooks, model) |
+| `/memory` | Show CLAUDE.md contents |
+| `/diff` | Show git diff |
+| `/export [path]` | Export conversation |
+| `/session [id]` | Resume a previous session |
+| `/version` | Show version |
 
 ## Workspace Layout
 
-```text
+```
 rust/
 ├── Cargo.toml              # Workspace root
 ├── Cargo.lock
 └── crates/
-    ├── api/                # Provider clients + streaming + request preflight
-    ├── commands/           # Shared slash-command registry + help rendering
+    ├── api/                # Anthropic API client + SSE streaming
+    ├── commands/           # Shared slash-command registry
     ├── compat-harness/     # TS manifest extraction harness
-    ├── mock-anthropic-service/ # Deterministic local Anthropic-compatible mock
-    ├── plugins/            # Plugin metadata, manager, install/enable/disable surfaces
-    ├── runtime/            # Session, config, permissions, MCP, prompts, auth/runtime loop
+    ├── runtime/            # Session, config, permissions, MCP, prompts
     ├── rusty-claude-cli/   # Main CLI binary (`claw`)
-    ├── telemetry/          # Session tracing and usage telemetry types
-    └── tools/              # Built-in tools, skill resolution, tool search, agent runtime surfaces
+    └── tools/              # Built-in tool implementations
 ```
 
 ### Crate Responsibilities
 
-- **api** — provider clients, SSE streaming, request/response types, auth (`ANTHROPIC_API_KEY` + bearer-token support), request-size/context-window preflight
-- **commands** — slash command definitions, parsing, help text generation, JSON/text command rendering
-- **compat-harness** — extracts tool/prompt manifests from upstream TS source
-- **mock-anthropic-service** — deterministic `/v1/messages` mock for CLI parity tests and local harness runs
-- **plugins** — plugin metadata, install/enable/disable/update flows, plugin tool definitions, hook integration surfaces
-- **runtime** — `ConversationRuntime`, config loading, session persistence, permission policy, MCP client lifecycle, system prompt assembly, usage tracking
-- **rusty-claude-cli** — REPL, one-shot prompt, direct CLI subcommands, streaming display, tool call rendering, CLI argument parsing
-- **telemetry** — session trace events and supporting telemetry payloads
-- **tools** — tool specs + execution: Bash, ReadFile, WriteFile, EditFile, GlobSearch, GrepSearch, WebSearch, WebFetch, Agent, TodoWrite, NotebookEdit, Skill, ToolSearch, and runtime-facing tool discovery
+- **api** — HTTP client, SSE stream parser, request/response types, auth (API key + OAuth bearer)
+- **commands** — Slash command definitions and help text generation
+- **compat-harness** — Extracts tool/prompt manifests from upstream TS source
+- **runtime** — `ConversationRuntime` agentic loop, `ConfigLoader` hierarchy, `Session` persistence, permission policy, MCP client, system prompt assembly, usage tracking
+- **rusty-claude-cli** — REPL, one-shot prompt, streaming display, tool call rendering, CLI argument parsing
+- **tools** — Tool specs + execution: Bash, ReadFile, WriteFile, EditFile, GlobSearch, GrepSearch, WebSearch, WebFetch, Agent, TodoWrite, NotebookEdit, Skill, ToolSearch, REPL runtimes
 
 ## Stats
 
 - **~20K lines** of Rust
-- **9 crates** in workspace
+- **6 crates** in workspace
 - **Binary name:** `claw`
 - **Default model:** `claude-opus-4-6`
 - **Default permissions:** `danger-full-access`

rust/TUI-ENHANCEMENT-PLAN.md

@@ -20,14 +20,12 @@ This plan covers a comprehensive analysis of the current terminal user interface
 
 ### Current TUI Components
 
-> Note: The legacy prototype files `app.rs` and `args.rs` were removed on 2026-04-05.
-> References below describe future extraction targets, not current tracked source files.
-
 | Component | File | What It Does Today | Quality |
 |---|---|---|---|
 | **Input** | `input.rs` (269 lines) | `rustyline`-based line editor with slash-command tab completion, Shift+Enter newline, history | ✅ Solid |
 | **Rendering** | `render.rs` (641 lines) | Markdown→terminal rendering (headings, lists, tables, code blocks with syntect highlighting, blockquotes), spinner widget | ✅ Good |
 | **App/REPL loop** | `main.rs` (3,159 lines) | The monolithic `LiveCli` struct: REPL loop, all slash command handlers, streaming output, tool call display, permission prompting, session management | ⚠️ Monolithic |
+| **Alt App** | `app.rs` (398 lines) | An earlier `CliApp` prototype with `ConversationClient`, stream event handling, `TerminalRenderer`, output format support | ⚠️ Appears unused/legacy |
 
 ### Key Dependencies
 
@@ -58,7 +56,7 @@ This plan covers a comprehensive analysis of the current terminal user interface
 8. **Streaming is char-by-char with artificial delay** — `stream_markdown` sleeps 8ms per whitespace-delimited chunk
 9. **No color theme customization** — hardcoded `ColorTheme::default()`
 10. **No resize handling** — no terminal size awareness for wrapping, truncation, or layout
-11. **Historical dual app split** — the repo previously carried a separate `CliApp` prototype alongside `LiveCli`; the prototype is gone, but the monolithic `main.rs` still needs extraction
+11. **Dual app structs** — `app.rs` has a separate `CliApp` that duplicates `LiveCli` from `main.rs`
 12. **No pager for long outputs** — `/status`, `/config`, `/memory` can overflow the viewport
 13. **Tool results not collapsible** — large bash outputs flood the screen
 14. **No thinking/reasoning indicator** — when the model is in "thinking" mode, no visual distinction
@@ -75,8 +73,8 @@ This plan covers a comprehensive analysis of the current terminal user interface
 | Task | Description | Effort |
 |---|---|---|
 | 0.1 | **Extract `LiveCli` into `app.rs`** — Move the entire `LiveCli` struct, its impl, and helpers (`format_*`, `render_*`, session management) out of `main.rs` into focused modules: `app.rs` (core), `format.rs` (report formatting), `session_manager.rs` (session CRUD) | M |
-| 0.2 | **Keep the legacy `CliApp` removed** — The old `CliApp` prototype has already been deleted; if any unique ideas remain valuable (for example stream event handler patterns), reintroduce them intentionally inside the active `LiveCli` extraction rather than restoring the old file wholesale | S |
-| 0.3 | **Extract `main.rs` arg parsing** — The current `parse_args()` is still a hand-rolled parser in `main.rs`. If parsing is extracted later, do it into a newly-introduced module intentionally rather than reviving the removed prototype `args.rs` by accident | S |
+| 0.2 | **Remove or merge the legacy `CliApp`** — The existing `app.rs` has an unused `CliApp` with its own `ConversationClient`-based rendering. Either delete it or merge its unique features (stream event handler pattern) into the active `LiveCli` | S |
+| 0.3 | **Extract `main.rs` arg parsing** — The current `parse_args()` is a hand-rolled parser that duplicates the clap-based `args.rs`. Consolidate on the hand-rolled parser (it's more feature-complete) and move it to `args.rs`, or adopt clap fully | S |
 | 0.4 | **Create a `tui/` module** — Introduce `crates/rusty-claude-cli/src/tui/mod.rs` as the namespace for all new TUI components: `status_bar.rs`, `layout.rs`, `tool_panel.rs`, etc. | S |
 
 ### Phase 1: Status Bar & Live HUD
@@ -216,7 +214,7 @@ crates/rusty-claude-cli/src/
 | Terminal compatibility issues (tmux, SSH, Windows) | Rely on crossterm's abstraction; test in degraded environments |
 | Performance regression with rich rendering | Profile before/after; keep the fast path (raw streaming) always available |
 | Scope creep into Phase 6 | Ship Phases 0–3 as a coherent release before starting Phase 6 |
-| Historical `app.rs` vs `main.rs` confusion | Keep the legacy prototype removed and avoid reintroducing a second app surface accidentally during extraction |
+| `app.rs` vs `main.rs` confusion | Phase 0.2 explicitly resolves this by removing the legacy `CliApp` |
 
 ---
 

rust/USAGE.md

@@ -1,11 +0,0 @@
-# Rust usage guide
-
-The canonical task-oriented usage guide lives at [`../USAGE.md`](../USAGE.md).
-
-Use that guide for:
-
-- workspace build and test commands
-- authentication setup
-- interactive and one-shot `claw` examples
-- session resume workflows
-- mock parity harness commands

rust/crates/api/Cargo.toml

@@ -9,16 +9,8 @@ publish.workspace = true
 reqwest = { version = "0.12", default-features = false, features = ["json", "rustls-tls"] }
 runtime = { path = "../runtime" }
 serde = { version = "1", features = ["derive"] }
-serde_json.workspace = true
-telemetry = { path = "../telemetry" }
+serde_json = "1"
 tokio = { version = "1", features = ["io-util", "macros", "net", "rt-multi-thread", "time"] }
 
-[dev-dependencies]
-criterion = { version = "0.5", features = ["html_reports"] }
-
 [lints]
 workspace = true
-
-[[bench]]
-name = "request_building"
-harness = false

rust/crates/api/benches/request_building.rs

@@ -1,329 +0,0 @@
-// Benchmarks for API request building performance
-// Benchmarks are exempt from strict linting as they are test/performance code
-#![allow(
-    clippy::cognitive_complexity,
-    clippy::doc_markdown,
-    clippy::explicit_iter_loop,
-    clippy::format_in_format_args,
-    clippy::missing_docs_in_private_items,
-    clippy::must_use_candidate,
-    clippy::needless_pass_by_value,
-    clippy::clone_on_copy,
-    clippy::too_many_lines,
-    clippy::uninlined_format_args
-)]
-
-use api::{
-    build_chat_completion_request, flatten_tool_result_content, is_reasoning_model,
-    translate_message, InputContentBlock, InputMessage, MessageRequest, OpenAiCompatConfig,
-    ToolResultContentBlock,
-};
-use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion};
-use serde_json::json;
-
-/// Create a sample message request with various content types
-fn create_sample_request(message_count: usize) -> MessageRequest {
-    let mut messages = Vec::with_capacity(message_count);
-
-    for i in 0..message_count {
-        match i % 4 {
-            0 => messages.push(InputMessage::user_text(format!("Message {}", i))),
-            1 => messages.push(InputMessage {
-                role: "assistant".to_string(),
-                content: vec![
-                    InputContentBlock::Text {
-                        text: format!("Assistant response {}", i),
-                    },
-                    InputContentBlock::ToolUse {
-                        id: format!("call_{}", i),
-                        name: "read_file".to_string(),
-                        input: json!({"path": format!("/tmp/file{}", i)}),
-                    },
-                ],
-            }),
-            2 => messages.push(InputMessage {
-                role: "user".to_string(),
-                content: vec![InputContentBlock::ToolResult {
-                    tool_use_id: format!("call_{}", i - 1),
-                    content: vec![ToolResultContentBlock::Text {
-                        text: format!("Tool result content {}", i),
-                    }],
-                    is_error: false,
-                }],
-            }),
-            _ => messages.push(InputMessage {
-                role: "assistant".to_string(),
-                content: vec![InputContentBlock::ToolUse {
-                    id: format!("call_{}", i),
-                    name: "write_file".to_string(),
-                    input: json!({"path": format!("/tmp/out{}", i), "content": "data"}),
-                }],
-            }),
-        }
-    }
-
-    MessageRequest {
-        model: "gpt-4o".to_string(),
-        max_tokens: 1024,
-        messages,
-        stream: false,
-        system: Some("You are a helpful assistant.".to_string()),
-        temperature: Some(0.7),
-        top_p: None,
-        tools: None,
-        tool_choice: None,
-        frequency_penalty: None,
-        presence_penalty: None,
-        stop: None,
-        reasoning_effort: None,
-    }
-}
-
-/// Benchmark translate_message with various message types
-fn bench_translate_message(c: &mut Criterion) {
-    let mut group = c.benchmark_group("translate_message");
-
-    // Text-only message
-    let text_message = InputMessage::user_text("Simple text message".to_string());
-    group.bench_with_input(
-        BenchmarkId::new("text_only", "single"),
-        &text_message,
-        |b, msg| {
-            b.iter(|| translate_message(black_box(msg), black_box("gpt-4o")));
-        },
-    );
-
-    // Assistant message with tool calls
-    let assistant_message = InputMessage {
-        role: "assistant".to_string(),
-        content: vec![
-            InputContentBlock::Text {
-                text: "I'll help you with that.".to_string(),
-            },
-            InputContentBlock::ToolUse {
-                id: "call_1".to_string(),
-                name: "read_file".to_string(),
-                input: json!({"path": "/tmp/test"}),
-            },
-            InputContentBlock::ToolUse {
-                id: "call_2".to_string(),
-                name: "write_file".to_string(),
-                input: json!({"path": "/tmp/out", "content": "data"}),
-            },
-        ],
-    };
-    group.bench_with_input(
-        BenchmarkId::new("assistant_with_tools", "2_tools"),
-        &assistant_message,
-        |b, msg| {
-            b.iter(|| translate_message(black_box(msg), black_box("gpt-4o")));
-        },
-    );
-
-    // Tool result message
-    let tool_result_message = InputMessage {
-        role: "user".to_string(),
-        content: vec![InputContentBlock::ToolResult {
-            tool_use_id: "call_1".to_string(),
-            content: vec![ToolResultContentBlock::Text {
-                text: "File contents here".to_string(),
-            }],
-            is_error: false,
-        }],
-    };
-    group.bench_with_input(
-        BenchmarkId::new("tool_result", "single"),
-        &tool_result_message,
-        |b, msg| {
-            b.iter(|| translate_message(black_box(msg), black_box("gpt-4o")));
-        },
-    );
-
-    // Tool result for kimi model (is_error excluded)
-    group.bench_with_input(
-        BenchmarkId::new("tool_result_kimi", "kimi-k2.5"),
-        &tool_result_message,
-        |b, msg| {
-            b.iter(|| translate_message(black_box(msg), black_box("kimi-k2.5")));
-        },
-    );
-
-    // Large content message
-    let large_content = "x".repeat(10000);
-    let large_message = InputMessage::user_text(large_content);
-    group.bench_with_input(
-        BenchmarkId::new("large_text", "10kb"),
-        &large_message,
-        |b, msg| {
-            b.iter(|| translate_message(black_box(msg), black_box("gpt-4o")));
-        },
-    );
-
-    group.finish();
-}
-
-/// Benchmark build_chat_completion_request with various message counts
-fn bench_build_request(c: &mut Criterion) {
-    let mut group = c.benchmark_group("build_chat_completion_request");
-    let config = OpenAiCompatConfig::openai();
-
-    for message_count in [10, 50, 100].iter() {
-        let request = create_sample_request(*message_count);
-        group.bench_with_input(
-            BenchmarkId::new("message_count", message_count),
-            &request,
-            |b, req| {
-                b.iter(|| build_chat_completion_request(black_box(req), config.clone()));
-            },
-        );
-    }
-
-    // Benchmark with reasoning model (tuning params stripped)
-    let mut reasoning_request = create_sample_request(50);
-    reasoning_request.model = "o1-mini".to_string();
-    group.bench_with_input(
-        BenchmarkId::new("reasoning_model", "o1-mini"),
-        &reasoning_request,
-        |b, req| {
-            b.iter(|| build_chat_completion_request(black_box(req), config.clone()));
-        },
-    );
-
-    // Benchmark with gpt-5 (max_completion_tokens)
-    let mut gpt5_request = create_sample_request(50);
-    gpt5_request.model = "gpt-5".to_string();
-    group.bench_with_input(
-        BenchmarkId::new("gpt5", "gpt-5"),
-        &gpt5_request,
-        |b, req| {
-            b.iter(|| build_chat_completion_request(black_box(req), config.clone()));
-        },
-    );
-
-    group.finish();
-}
-
-/// Benchmark flatten_tool_result_content
-fn bench_flatten_tool_result(c: &mut Criterion) {
-    let mut group = c.benchmark_group("flatten_tool_result_content");
-
-    // Single text block
-    let single_text = vec![ToolResultContentBlock::Text {
-        text: "Simple result".to_string(),
-    }];
-    group.bench_with_input(
-        BenchmarkId::new("single_text", "1_block"),
-        &single_text,
-        |b, content| {
-            b.iter(|| flatten_tool_result_content(black_box(content)));
-        },
-    );
-
-    // Multiple text blocks
-    let multi_text: Vec<ToolResultContentBlock> = (0..10)
-        .map(|i| ToolResultContentBlock::Text {
-            text: format!("Line {}: some content here\n", i),
-        })
-        .collect();
-    group.bench_with_input(
-        BenchmarkId::new("multi_text", "10_blocks"),
-        &multi_text,
-        |b, content| {
-            b.iter(|| flatten_tool_result_content(black_box(content)));
-        },
-    );
-
-    // JSON content blocks
-    let json_content: Vec<ToolResultContentBlock> = (0..5)
-        .map(|i| ToolResultContentBlock::Json {
-            value: json!({"index": i, "data": "test content", "nested": {"key": "value"}}),
-        })
-        .collect();
-    group.bench_with_input(
-        BenchmarkId::new("json_content", "5_blocks"),
-        &json_content,
-        |b, content| {
-            b.iter(|| flatten_tool_result_content(black_box(content)));
-        },
-    );
-
-    // Mixed content
-    let mixed_content = vec![
-        ToolResultContentBlock::Text {
-            text: "Here's the result:".to_string(),
-        },
-        ToolResultContentBlock::Json {
-            value: json!({"status": "success", "count": 42}),
-        },
-        ToolResultContentBlock::Text {
-            text: "Processing complete.".to_string(),
-        },
-    ];
-    group.bench_with_input(
-        BenchmarkId::new("mixed_content", "text+json"),
-        &mixed_content,
-        |b, content| {
-            b.iter(|| flatten_tool_result_content(black_box(content)));
-        },
-    );
-
-    // Large content - simulating typical tool output
-    let large_content: Vec<ToolResultContentBlock> = (0..50)
-        .map(|i| {
-            if i % 3 == 0 {
-                ToolResultContentBlock::Json {
-                    value: json!({"line": i, "content": "x".repeat(100)}),
-                }
-            } else {
-                ToolResultContentBlock::Text {
-                    text: format!("Line {}: {}", i, "some output content here"),
-                }
-            }
-        })
-        .collect();
-    group.bench_with_input(
-        BenchmarkId::new("large_content", "50_blocks"),
-        &large_content,
-        |b, content| {
-            b.iter(|| flatten_tool_result_content(black_box(content)));
-        },
-    );
-
-    group.finish();
-}
-
-/// Benchmark is_reasoning_model detection
-fn bench_is_reasoning_model(c: &mut Criterion) {
-    let mut group = c.benchmark_group("is_reasoning_model");
-
-    let models = vec![
-        ("gpt-4o", false),
-        ("o1-mini", true),
-        ("o3", true),
-        ("grok-3", false),
-        ("grok-3-mini", true),
-        ("qwen/qwen-qwq-32b", true),
-        ("qwen/qwen-plus", false),
-    ];
-
-    for (model, expected) in models {
-        group.bench_with_input(
-            BenchmarkId::new(model, if expected { "reasoning" } else { "normal" }),
-            model,
-            |b, m| {
-                b.iter(|| is_reasoning_model(black_box(m)));
-            },
-        );
-    }
-
-    group.finish();
-}
-
-criterion_group!(
-    benches,
-    bench_translate_message,
-    bench_build_request,
-    bench_flatten_tool_result,
-    bench_is_reasoning_model
-);
-criterion_main!(benches);

rust/crates/api/src/error.rs

@@ -2,64 +2,21 @@ use std::env::VarError;
 use std::fmt::{Display, Formatter};
 use std::time::Duration;
 
-const GENERIC_FATAL_WRAPPER_MARKERS: &[&str] = &[
-    "something went wrong while processing your request",
-    "please try again, or use /new to start a fresh session",
-];
-
-const CONTEXT_WINDOW_ERROR_MARKERS: &[&str] = &[
-    "maximum context length",
-    "context window",
-    "context length",
-    "too many tokens",
-    "prompt is too long",
-    "input is too long",
-    "input tokens exceed",
-    "configured limit",
-    "messages resulted in",
-    "completion tokens",
-    "prompt tokens",
-    "request is too large",
-];
-
 #[derive(Debug)]
 pub enum ApiError {
-    MissingCredentials {
-        provider: &'static str,
-        env_vars: &'static [&'static str],
-        /// Optional, runtime-computed hint appended to the error Display
-        /// output. Populated when the provider resolver can infer what the
-        /// user probably intended (e.g. an `OpenAI` key is set but Anthropic
-        /// was selected because no Anthropic credentials exist).
-        hint: Option<String>,
-    },
-    ContextWindowExceeded {
-        model: String,
-        estimated_input_tokens: u32,
-        requested_output_tokens: u32,
-        estimated_total_tokens: u32,
-        context_window_tokens: u32,
-    },
+    MissingApiKey,
     ExpiredOAuthToken,
     Auth(String),
     InvalidApiKeyEnv(VarError),
     Http(reqwest::Error),
     Io(std::io::Error),
-    Json {
-        provider: String,
-        model: String,
-        body_snippet: String,
-        source: serde_json::Error,
-    },
+    Json(serde_json::Error),
     Api {
         status: reqwest::StatusCode,
         error_type: Option<String>,
         message: Option<String>,
-        request_id: Option<String>,
         body: String,
         retryable: bool,
-        /// Suggested user action based on error type (e.g., "Reduce prompt size" for 413)
-        suggested_action: Option<String>,
     },
     RetriesExhausted {
         attempts: u32,
@@ -70,223 +27,36 @@ pub enum ApiError {
         attempt: u32,
         base_delay: Duration,
     },
-    RequestBodySizeExceeded {
-        estimated_bytes: usize,
-        max_bytes: usize,
-        provider: &'static str,
-    },
 }
 
 impl ApiError {
-    #[must_use]
-    pub const fn missing_credentials(
-        provider: &'static str,
-        env_vars: &'static [&'static str],
-    ) -> Self {
-        Self::MissingCredentials {
-            provider,
-            env_vars,
-            hint: None,
-        }
-    }
-
-    /// Build a `MissingCredentials` error carrying an extra, runtime-computed
-    /// hint string that the Display impl appends after the canonical "missing
-    /// <provider> credentials" message. Used by the provider resolver to
-    /// suggest the likely fix when the user has credentials for a different
-    /// provider already in the environment.
-    #[must_use]
-    pub fn missing_credentials_with_hint(
-        provider: &'static str,
-        env_vars: &'static [&'static str],
-        hint: impl Into<String>,
-    ) -> Self {
-        Self::MissingCredentials {
-            provider,
-            env_vars,
-            hint: Some(hint.into()),
-        }
-    }
-
-    /// Build a `Self::Json` enriched with the provider name, the model that
-    /// was requested, and the first 200 characters of the raw response body so
-    /// that callers can diagnose deserialization failures without re-running
-    /// the request.
-    #[must_use]
-    pub fn json_deserialize(
-        provider: impl Into<String>,
-        model: impl Into<String>,
-        body: &str,
-        source: serde_json::Error,
-    ) -> Self {
-        Self::Json {
-            provider: provider.into(),
-            model: model.into(),
-            body_snippet: truncate_body_snippet(body, 200),
-            source,
-        }
-    }
-
     #[must_use]
     pub fn is_retryable(&self) -> bool {
         match self {
             Self::Http(error) => error.is_connect() || error.is_timeout() || error.is_request(),
             Self::Api { retryable, .. } => *retryable,
             Self::RetriesExhausted { last_error, .. } => last_error.is_retryable(),
-            Self::MissingCredentials { .. }
-            | Self::ContextWindowExceeded { .. }
+            Self::MissingApiKey
             | Self::ExpiredOAuthToken
             | Self::Auth(_)
             | Self::InvalidApiKeyEnv(_)
             | Self::Io(_)
-            | Self::Json { .. }
+            | Self::Json(_)
             | Self::InvalidSseFrame(_)
-            | Self::BackoffOverflow { .. }
-            | Self::RequestBodySizeExceeded { .. } => false,
-        }
-    }
-
-    #[must_use]
-    pub fn request_id(&self) -> Option<&str> {
-        match self {
-            Self::Api { request_id, .. } => request_id.as_deref(),
-            Self::RetriesExhausted { last_error, .. } => last_error.request_id(),
-            Self::MissingCredentials { .. }
-            | Self::ContextWindowExceeded { .. }
-            | Self::ExpiredOAuthToken
-            | Self::Auth(_)
-            | Self::InvalidApiKeyEnv(_)
-            | Self::Http(_)
-            | Self::Io(_)
-            | Self::Json { .. }
-            | Self::InvalidSseFrame(_)
-            | Self::BackoffOverflow { .. }
-            | Self::RequestBodySizeExceeded { .. } => None,
-        }
-    }
-
-    #[must_use]
-    pub fn safe_failure_class(&self) -> &'static str {
-        match self {
-            Self::RetriesExhausted { .. } if self.is_context_window_failure() => "context_window",
-            Self::RetriesExhausted { .. } if self.is_generic_fatal_wrapper() => {
-                "provider_retry_exhausted"
-            }
-            Self::RetriesExhausted { last_error, .. } => last_error.safe_failure_class(),
-            Self::MissingCredentials { .. } | Self::ExpiredOAuthToken | Self::Auth(_) => {
-                "provider_auth"
-            }
-            Self::Api { status, .. } if matches!(status.as_u16(), 401 | 403) => "provider_auth",
-            Self::ContextWindowExceeded { .. } => "context_window",
-            Self::Api { .. } if self.is_context_window_failure() => "context_window",
-            Self::Api { status, .. } if status.as_u16() == 429 => "provider_rate_limit",
-            Self::Api { .. } if self.is_generic_fatal_wrapper() => "provider_internal",
-            Self::Api { .. } => "provider_error",
-            Self::Http(_) | Self::InvalidSseFrame(_) | Self::BackoffOverflow { .. } => {
-                "provider_transport"
-            }
-            Self::InvalidApiKeyEnv(_) | Self::Io(_) | Self::Json { .. } => "runtime_io",
-            Self::RequestBodySizeExceeded { .. } => "request_size",
-        }
-    }
-
-    #[must_use]
-    pub fn is_generic_fatal_wrapper(&self) -> bool {
-        match self {
-            Self::Api { message, body, .. } => {
-                message
-                    .as_deref()
-                    .is_some_and(looks_like_generic_fatal_wrapper)
-                    || looks_like_generic_fatal_wrapper(body)
-            }
-            Self::RetriesExhausted { last_error, .. } => last_error.is_generic_fatal_wrapper(),
-            Self::MissingCredentials { .. }
-            | Self::ContextWindowExceeded { .. }
-            | Self::ExpiredOAuthToken
-            | Self::Auth(_)
-            | Self::InvalidApiKeyEnv(_)
-            | Self::Http(_)
-            | Self::Io(_)
-            | Self::Json { .. }
-            | Self::InvalidSseFrame(_)
-            | Self::BackoffOverflow { .. }
-            | Self::RequestBodySizeExceeded { .. } => false,
-        }
-    }
-
-    #[must_use]
-    pub fn is_context_window_failure(&self) -> bool {
-        match self {
-            Self::ContextWindowExceeded { .. } => true,
-            Self::Api {
-                status,
-                message,
-                body,
-                ..
-            } => {
-                matches!(status.as_u16(), 400 | 413 | 422)
-                    && (message
-                        .as_deref()
-                        .is_some_and(looks_like_context_window_error)
-                        || looks_like_context_window_error(body))
-            }
-            Self::RetriesExhausted { last_error, .. } => last_error.is_context_window_failure(),
-            Self::MissingCredentials { .. }
-            | Self::ExpiredOAuthToken
-            | Self::Auth(_)
-            | Self::InvalidApiKeyEnv(_)
-            | Self::Http(_)
-            | Self::Io(_)
-            | Self::Json { .. }
-            | Self::InvalidSseFrame(_)
-            | Self::BackoffOverflow { .. }
-            | Self::RequestBodySizeExceeded { .. } => false,
+            | Self::BackoffOverflow { .. } => false,
         }
     }
 }
 
 impl Display for ApiError {
-    #[allow(clippy::too_many_lines)]
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         match self {
-            Self::MissingCredentials {
-                provider,
-                env_vars,
-                hint,
-            } => {
+            Self::MissingApiKey => {
                 write!(
                     f,
-                    "missing {provider} credentials; export {} before calling the {provider} API",
-                    env_vars.join(" or ")
-                )?;
-                if cfg!(target_os = "windows") {
-                    if let Some(primary) = env_vars.first() {
-                        write!(
-                            f,
-                            " (on Windows, environment variables set in PowerShell only persist for the current session; use `setx {primary} <value>` to make it permanent, then open a new terminal, or place a `.env` file containing `{primary}=<value>` in the current working directory)"
-                        )?;
-                    } else {
-                        write!(
-                            f,
-                            " (on Windows, environment variables set in PowerShell only persist for the current session; use `setx` to make them permanent, then open a new terminal, or place a `.env` file in the current working directory)"
-                        )?;
-                    }
-                }
-                if let Some(hint) = hint {
-                    write!(f, " — hint: {hint}")?;
-                }
-                Ok(())
+                    "ANTHROPIC_AUTH_TOKEN or ANTHROPIC_API_KEY is not set; export one before calling the Anthropic API"
+                )
             }
-            Self::ContextWindowExceeded {
-                model,
-                estimated_input_tokens,
-                requested_output_tokens,
-                estimated_total_tokens,
-                context_window_tokens,
-            } => write!(
-                f,
-                "context_window_blocked for {model}: estimated input {estimated_input_tokens} + requested output {requested_output_tokens} = {estimated_total_tokens} tokens exceeds the {context_window_tokens}-token context window; compact the session or reduce request size before retrying"
-            ),
             Self::ExpiredOAuthToken => {
                 write!(
                     f,
@@ -295,45 +65,36 @@ impl Display for ApiError {
             }
             Self::Auth(message) => write!(f, "auth error: {message}"),
             Self::InvalidApiKeyEnv(error) => {
-                write!(f, "failed to read credential environment variable: {error}")
+                write!(
+                    f,
+                    "failed to read ANTHROPIC_AUTH_TOKEN / ANTHROPIC_API_KEY: {error}"
+                )
             }
             Self::Http(error) => write!(f, "http error: {error}"),
             Self::Io(error) => write!(f, "io error: {error}"),
-            Self::Json {
-                provider,
-                model,
-                body_snippet,
-                source,
-            } => write!(
-                f,
-                "failed to parse {provider} response for model {model}: {source}; first 200 chars of body: {body_snippet}"
-            ),
+            Self::Json(error) => write!(f, "json error: {error}"),
             Self::Api {
                 status,
                 error_type,
                 message,
-                request_id,
                 body,
                 ..
-            } => {
-                if let (Some(error_type), Some(message)) = (error_type, message) {
-                    write!(f, "api returned {status} ({error_type})")?;
-                    if let Some(request_id) = request_id {
-                        write!(f, " [trace {request_id}]")?;
-                    }
-                    write!(f, ": {message}")
-                } else {
-                    write!(f, "api returned {status}")?;
-                    if let Some(request_id) = request_id {
-                        write!(f, " [trace {request_id}]")?;
-                    }
-                    write!(f, ": {body}")
+            } => match (error_type, message) {
+                (Some(error_type), Some(message)) => {
+                    write!(
+                        f,
+                        "anthropic api returned {status} ({error_type}): {message}"
+                    )
                 }
-            }
+                _ => write!(f, "anthropic api returned {status}: {body}"),
+            },
             Self::RetriesExhausted {
                 attempts,
                 last_error,
-            } => write!(f, "api failed after {attempts} attempts: {last_error}"),
+            } => write!(
+                f,
+                "anthropic api failed after {attempts} attempts: {last_error}"
+            ),
             Self::InvalidSseFrame(message) => write!(f, "invalid sse frame: {message}"),
             Self::BackoffOverflow {
                 attempt,
@@ -342,14 +103,6 @@ impl Display for ApiError {
                 f,
                 "retry backoff overflowed on attempt {attempt} with base delay {base_delay:?}"
             ),
-            Self::RequestBodySizeExceeded {
-                estimated_bytes,
-                max_bytes,
-                provider,
-            } => write!(
-                f,
-                "request body size ({estimated_bytes} bytes) exceeds {provider} limit ({max_bytes} bytes); reduce prompt length or context before retrying"
-            ),
         }
     }
 }
@@ -370,12 +123,7 @@ impl From<std::io::Error> for ApiError {
 
 impl From<serde_json::Error> for ApiError {
     fn from(value: serde_json::Error) -> Self {
-        Self::Json {
-            provider: "unknown".to_string(),
-            model: "unknown".to_string(),
-            body_snippet: String::new(),
-            source: value,
-        }
+        Self::Json(value)
     }
 }
 
@@ -384,238 +132,3 @@ impl From<VarError> for ApiError {
         Self::InvalidApiKeyEnv(value)
     }
 }
-
-fn looks_like_generic_fatal_wrapper(text: &str) -> bool {
-    let lowered = text.to_ascii_lowercase();
-    GENERIC_FATAL_WRAPPER_MARKERS
-        .iter()
-        .any(|marker| lowered.contains(marker))
-}
-
-fn looks_like_context_window_error(text: &str) -> bool {
-    let lowered = text.to_ascii_lowercase();
-    CONTEXT_WINDOW_ERROR_MARKERS
-        .iter()
-        .any(|marker| lowered.contains(marker))
-}
-
-/// Truncate `body` so the resulting snippet contains at most `max_chars`
-/// characters (counted by Unicode scalar values, not bytes), preserving the
-/// leading slice of the body that the caller most often needs to inspect.
-fn truncate_body_snippet(body: &str, max_chars: usize) -> String {
-    let mut taken_chars = 0;
-    let mut byte_end = 0;
-    for (offset, character) in body.char_indices() {
-        if taken_chars >= max_chars {
-            break;
-        }
-        taken_chars += 1;
-        byte_end = offset + character.len_utf8();
-    }
-    if taken_chars >= max_chars && byte_end < body.len() {
-        format!("{}…", &body[..byte_end])
-    } else {
-        body[..byte_end].to_string()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::{truncate_body_snippet, ApiError};
-
-    #[test]
-    fn json_deserialize_error_includes_provider_model_and_truncated_body_snippet() {
-        let raw_body = format!("{}{}", "x".repeat(190), "_TAIL_PAST_200_CHARS_MARKER_");
-        let source = serde_json::from_str::<serde_json::Value>("{not json")
-            .expect_err("invalid json should fail to parse");
-
-        let error = ApiError::json_deserialize("Anthropic", "claude-opus-4-6", &raw_body, source);
-        let rendered = error.to_string();
-
-        assert!(
-            rendered.starts_with("failed to parse Anthropic response for model claude-opus-4-6: "),
-            "rendered error should lead with provider and model: {rendered}"
-        );
-        assert!(
-            rendered.contains("first 200 chars of body: "),
-            "rendered error should label the body snippet: {rendered}"
-        );
-        let snippet = rendered
-            .split("first 200 chars of body: ")
-            .nth(1)
-            .expect("snippet section should be present");
-        assert!(
-            snippet.starts_with(&"x".repeat(190)),
-            "snippet should preserve the leading characters of the body: {snippet}"
-        );
-        assert!(
-            snippet.ends_with('…'),
-            "snippet should signal truncation with an ellipsis: {snippet}"
-        );
-        assert!(
-            !snippet.contains("_TAIL_PAST_200_CHARS_MARKER_"),
-            "snippet should drop characters past the 200-char cap: {snippet}"
-        );
-        assert_eq!(error.safe_failure_class(), "runtime_io");
-        assert_eq!(error.request_id(), None);
-        assert!(!error.is_retryable());
-    }
-
-    #[test]
-    fn truncate_body_snippet_keeps_short_bodies_intact() {
-        assert_eq!(truncate_body_snippet("hello", 200), "hello");
-        assert_eq!(truncate_body_snippet("", 200), "");
-    }
-
-    #[test]
-    fn truncate_body_snippet_caps_long_bodies_at_max_chars() {
-        let body = "a".repeat(250);
-        let snippet = truncate_body_snippet(&body, 200);
-        assert_eq!(snippet.chars().count(), 201, "200 chars + ellipsis");
-        assert!(snippet.ends_with('…'));
-        assert!(snippet.starts_with(&"a".repeat(200)));
-    }
-
-    #[test]
-    fn truncate_body_snippet_does_not_split_multibyte_characters() {
-        let body = "한글한글한글한글한글한글";
-        let snippet = truncate_body_snippet(body, 4);
-        assert_eq!(snippet, "한글한글…");
-    }
-
-    #[test]
-    fn detects_generic_fatal_wrapper_and_classifies_it_as_provider_internal() {
-        let error = ApiError::Api {
-            status: reqwest::StatusCode::INTERNAL_SERVER_ERROR,
-            error_type: Some("api_error".to_string()),
-            message: Some(
-                "Something went wrong while processing your request. Please try again, or use /new to start a fresh session."
-                    .to_string(),
-            ),
-            request_id: Some("req_jobdori_123".to_string()),
-            body: String::new(),
-            retryable: true,
-            suggested_action: None,
-        };
-
-        assert!(error.is_generic_fatal_wrapper());
-        assert_eq!(error.safe_failure_class(), "provider_internal");
-        assert_eq!(error.request_id(), Some("req_jobdori_123"));
-        assert!(error.to_string().contains("[trace req_jobdori_123]"));
-    }
-
-    #[test]
-    fn retries_exhausted_preserves_nested_request_id_and_failure_class() {
-        let error = ApiError::RetriesExhausted {
-            attempts: 3,
-            last_error: Box::new(ApiError::Api {
-                status: reqwest::StatusCode::BAD_GATEWAY,
-                error_type: Some("api_error".to_string()),
-                message: Some(
-                    "Something went wrong while processing your request. Please try again, or use /new to start a fresh session."
-                        .to_string(),
-                ),
-                request_id: Some("req_nested_456".to_string()),
-                body: String::new(),
-                retryable: true,
-                suggested_action: None,
-            }),
-        };
-
-        assert!(error.is_generic_fatal_wrapper());
-        assert_eq!(error.safe_failure_class(), "provider_retry_exhausted");
-        assert_eq!(error.request_id(), Some("req_nested_456"));
-    }
-
-    #[test]
-    fn classifies_provider_context_window_errors() {
-        let error = ApiError::Api {
-            status: reqwest::StatusCode::BAD_REQUEST,
-            error_type: Some("invalid_request_error".to_string()),
-            message: Some(
-                "This model's maximum context length is 200000 tokens, but your request used 230000 tokens."
-                    .to_string(),
-            ),
-            request_id: Some("req_ctx_123".to_string()),
-            body: String::new(),
-            retryable: false,
-            suggested_action: None,
-        };
-
-        assert!(error.is_context_window_failure());
-        assert_eq!(error.safe_failure_class(), "context_window");
-        assert_eq!(error.request_id(), Some("req_ctx_123"));
-    }
-
-    #[test]
-    fn classifies_openai_configured_limit_errors_as_context_window_failures() {
-        let error = ApiError::Api {
-            status: reqwest::StatusCode::BAD_REQUEST,
-            error_type: Some("invalid_request_error".to_string()),
-            message: Some(
-                "Input tokens exceed the configured limit of 922000 tokens. Your messages resulted in 1860900 tokens. Please reduce the length of the messages."
-                    .to_string(),
-            ),
-            request_id: Some("req_ctx_openai_123".to_string()),
-            body: String::new(),
-            retryable: false,
-            suggested_action: None,
-        };
-
-        assert!(error.is_context_window_failure());
-        assert_eq!(error.safe_failure_class(), "context_window");
-        assert_eq!(error.request_id(), Some("req_ctx_openai_123"));
-    }
-
-    #[test]
-    fn missing_credentials_without_hint_renders_the_canonical_message() {
-        // given
-        let error = ApiError::missing_credentials(
-            "Anthropic",
-            &["ANTHROPIC_AUTH_TOKEN", "ANTHROPIC_API_KEY"],
-        );
-
-        // when
-        let rendered = error.to_string();
-
-        // then
-        assert!(
-            rendered.starts_with(
-                "missing Anthropic credentials; export ANTHROPIC_AUTH_TOKEN or ANTHROPIC_API_KEY before calling the Anthropic API"
-            ),
-            "rendered error should lead with the canonical missing-credential message: {rendered}"
-        );
-        assert!(
-            !rendered.contains(" — hint: "),
-            "no hint should be appended when none is supplied: {rendered}"
-        );
-    }
-
-    #[test]
-    fn missing_credentials_with_hint_appends_the_hint_after_base_message() {
-        // given
-        let error = ApiError::missing_credentials_with_hint(
-            "Anthropic",
-            &["ANTHROPIC_AUTH_TOKEN", "ANTHROPIC_API_KEY"],
-            "I see OPENAI_API_KEY is set — if you meant to use the OpenAI-compat provider, prefix your model name with `openai/` so prefix routing selects it.",
-        );
-
-        // when
-        let rendered = error.to_string();
-
-        // then
-        assert!(
-            rendered.starts_with("missing Anthropic credentials;"),
-            "hint should be appended, not replace the base message: {rendered}"
-        );
-        let hint_marker = " — hint: I see OPENAI_API_KEY is set — if you meant to use the OpenAI-compat provider, prefix your model name with `openai/` so prefix routing selects it.";
-        assert!(
-            rendered.ends_with(hint_marker),
-            "rendered error should end with the hint: {rendered}"
-        );
-        // Classification semantics are unaffected by the presence of a hint.
-        assert_eq!(error.safe_failure_class(), "provider_auth");
-        assert!(!error.is_retryable());
-        assert_eq!(error.request_id(), None);
-    }
-}

rust/crates/api/src/http_client.rs

@@ -1,344 +0,0 @@
-use crate::error::ApiError;
-
-const HTTP_PROXY_KEYS: [&str; 2] = ["HTTP_PROXY", "http_proxy"];
-const HTTPS_PROXY_KEYS: [&str; 2] = ["HTTPS_PROXY", "https_proxy"];
-const NO_PROXY_KEYS: [&str; 2] = ["NO_PROXY", "no_proxy"];
-
-/// Snapshot of the proxy-related environment variables that influence the
-/// outbound HTTP client. Captured up front so callers can inspect, log, and
-/// test the resolved configuration without re-reading the process environment.
-///
-/// When `proxy_url` is set it acts as a single catch-all proxy for both
-/// HTTP and HTTPS traffic, taking precedence over the per-scheme fields.
-#[derive(Debug, Clone, Default, PartialEq, Eq)]
-pub struct ProxyConfig {
-    pub http_proxy: Option<String>,
-    pub https_proxy: Option<String>,
-    pub no_proxy: Option<String>,
-    /// Optional unified proxy URL that applies to both HTTP and HTTPS.
-    /// When set, this takes precedence over `http_proxy` and `https_proxy`.
-    pub proxy_url: Option<String>,
-}
-
-impl ProxyConfig {
-    /// Read proxy settings from the live process environment, honouring both
-    /// the upper- and lower-case spellings used by curl, git, and friends.
-    #[must_use]
-    pub fn from_env() -> Self {
-        Self::from_lookup(|key| std::env::var(key).ok())
-    }
-
-    /// Create a proxy configuration from a single URL that applies to both
-    /// HTTP and HTTPS traffic. This is the config-file alternative to setting
-    /// `HTTP_PROXY` and `HTTPS_PROXY` environment variables separately.
-    #[must_use]
-    pub fn from_proxy_url(url: impl Into<String>) -> Self {
-        Self {
-            proxy_url: Some(url.into()),
-            ..Self::default()
-        }
-    }
-
-    fn from_lookup<F>(mut lookup: F) -> Self
-    where
-        F: FnMut(&str) -> Option<String>,
-    {
-        Self {
-            http_proxy: first_non_empty(&HTTP_PROXY_KEYS, &mut lookup),
-            https_proxy: first_non_empty(&HTTPS_PROXY_KEYS, &mut lookup),
-            no_proxy: first_non_empty(&NO_PROXY_KEYS, &mut lookup),
-            proxy_url: None,
-        }
-    }
-
-    #[must_use]
-    pub fn is_empty(&self) -> bool {
-        self.proxy_url.is_none() && self.http_proxy.is_none() && self.https_proxy.is_none()
-    }
-}
-
-/// Build a `reqwest::Client` that honours the standard `HTTP_PROXY`,
-/// `HTTPS_PROXY`, and `NO_PROXY` environment variables. When no proxy is
-/// configured the client behaves identically to `reqwest::Client::new()`.
-pub fn build_http_client() -> Result<reqwest::Client, ApiError> {
-    build_http_client_with(&ProxyConfig::from_env())
-}
-
-/// Infallible counterpart to [`build_http_client`] for constructors that
-/// historically returned `Self` rather than `Result<Self, _>`. When the proxy
-/// configuration is malformed we fall back to a default client so that
-/// callers retain the previous behaviour and the failure surfaces on the
-/// first outbound request instead of at construction time.
-#[must_use]
-pub fn build_http_client_or_default() -> reqwest::Client {
-    build_http_client().unwrap_or_else(|_| reqwest::Client::new())
-}
-
-/// Build a `reqwest::Client` from an explicit [`ProxyConfig`]. Used by tests
-/// and by callers that want to override process-level environment lookups.
-///
-/// When `config.proxy_url` is set it overrides the per-scheme `http_proxy`
-/// and `https_proxy` fields and is registered as both an HTTP and HTTPS
-/// proxy so a single value can route every outbound request.
-pub fn build_http_client_with(config: &ProxyConfig) -> Result<reqwest::Client, ApiError> {
-    let mut builder = reqwest::Client::builder().no_proxy();
-
-    let no_proxy = config
-        .no_proxy
-        .as_deref()
-        .and_then(reqwest::NoProxy::from_string);
-
-    let (http_proxy_url, https_url) = match config.proxy_url.as_deref() {
-        Some(unified) => (Some(unified), Some(unified)),
-        None => (config.http_proxy.as_deref(), config.https_proxy.as_deref()),
-    };
-
-    if let Some(url) = https_url {
-        let mut proxy = reqwest::Proxy::https(url)?;
-        if let Some(filter) = no_proxy.clone() {
-            proxy = proxy.no_proxy(Some(filter));
-        }
-        builder = builder.proxy(proxy);
-    }
-
-    if let Some(url) = http_proxy_url {
-        let mut proxy = reqwest::Proxy::http(url)?;
-        if let Some(filter) = no_proxy.clone() {
-            proxy = proxy.no_proxy(Some(filter));
-        }
-        builder = builder.proxy(proxy);
-    }
-
-    Ok(builder.build()?)
-}
-
-fn first_non_empty<F>(keys: &[&str], lookup: &mut F) -> Option<String>
-where
-    F: FnMut(&str) -> Option<String>,
-{
-    keys.iter()
-        .find_map(|key| lookup(key).filter(|value| !value.is_empty()))
-}
-
-#[cfg(test)]
-mod tests {
-    use std::collections::HashMap;
-
-    use super::{build_http_client_with, ProxyConfig};
-
-    fn config_from_map(pairs: &[(&str, &str)]) -> ProxyConfig {
-        let map: HashMap<String, String> = pairs
-            .iter()
-            .map(|(key, value)| ((*key).to_string(), (*value).to_string()))
-            .collect();
-        ProxyConfig::from_lookup(|key| map.get(key).cloned())
-    }
-
-    #[test]
-    fn proxy_config_is_empty_when_no_env_vars_are_set() {
-        // given
-        let config = config_from_map(&[]);
-
-        // when
-        let empty = config.is_empty();
-
-        // then
-        assert!(empty);
-        assert_eq!(config, ProxyConfig::default());
-    }
-
-    #[test]
-    fn proxy_config_reads_uppercase_http_https_and_no_proxy() {
-        // given
-        let pairs = [
-            ("HTTP_PROXY", "http://proxy.internal:3128"),
-            ("HTTPS_PROXY", "http://secure.internal:3129"),
-            ("NO_PROXY", "localhost,127.0.0.1,.corp"),
-        ];
-
-        // when
-        let config = config_from_map(&pairs);
-
-        // then
-        assert_eq!(
-            config.http_proxy.as_deref(),
-            Some("http://proxy.internal:3128")
-        );
-        assert_eq!(
-            config.https_proxy.as_deref(),
-            Some("http://secure.internal:3129")
-        );
-        assert_eq!(
-            config.no_proxy.as_deref(),
-            Some("localhost,127.0.0.1,.corp")
-        );
-        assert!(!config.is_empty());
-    }
-
-    #[test]
-    fn proxy_config_falls_back_to_lowercase_keys() {
-        // given
-        let pairs = [
-            ("http_proxy", "http://lower.internal:3128"),
-            ("https_proxy", "http://lower-secure.internal:3129"),
-            ("no_proxy", ".lower"),
-        ];
-
-        // when
-        let config = config_from_map(&pairs);
-
-        // then
-        assert_eq!(
-            config.http_proxy.as_deref(),
-            Some("http://lower.internal:3128")
-        );
-        assert_eq!(
-            config.https_proxy.as_deref(),
-            Some("http://lower-secure.internal:3129")
-        );
-        assert_eq!(config.no_proxy.as_deref(), Some(".lower"));
-    }
-
-    #[test]
-    fn proxy_config_prefers_uppercase_over_lowercase_when_both_set() {
-        // given
-        let pairs = [
-            ("HTTP_PROXY", "http://upper.internal:3128"),
-            ("http_proxy", "http://lower.internal:3128"),
-        ];
-
-        // when
-        let config = config_from_map(&pairs);
-
-        // then
-        assert_eq!(
-            config.http_proxy.as_deref(),
-            Some("http://upper.internal:3128")
-        );
-    }
-
-    #[test]
-    fn proxy_config_treats_empty_strings_as_unset() {
-        // given
-        let pairs = [("HTTP_PROXY", ""), ("http_proxy", "")];
-
-        // when
-        let config = config_from_map(&pairs);
-
-        // then
-        assert!(config.http_proxy.is_none());
-    }
-
-    #[test]
-    fn build_http_client_succeeds_when_no_proxy_is_configured() {
-        // given
-        let config = ProxyConfig::default();
-
-        // when
-        let result = build_http_client_with(&config);
-
-        // then
-        assert!(result.is_ok());
-    }
-
-    #[test]
-    fn build_http_client_succeeds_with_valid_http_and_https_proxies() {
-        // given
-        let config = ProxyConfig {
-            http_proxy: Some("http://proxy.internal:3128".to_string()),
-            https_proxy: Some("http://secure.internal:3129".to_string()),
-            no_proxy: Some("localhost,127.0.0.1".to_string()),
-            proxy_url: None,
-        };
-
-        // when
-        let result = build_http_client_with(&config);
-
-        // then
-        assert!(result.is_ok());
-    }
-
-    #[test]
-    fn build_http_client_returns_http_error_for_invalid_proxy_url() {
-        // given
-        let config = ProxyConfig {
-            http_proxy: None,
-            https_proxy: Some("not a url".to_string()),
-            no_proxy: None,
-            proxy_url: None,
-        };
-
-        // when
-        let result = build_http_client_with(&config);
-
-        // then
-        let error = result.expect_err("invalid proxy URL must be reported as a build failure");
-        assert!(
-            matches!(error, crate::error::ApiError::Http(_)),
-            "expected ApiError::Http for invalid proxy URL, got: {error:?}"
-        );
-    }
-
-    #[test]
-    fn from_proxy_url_sets_unified_field_and_leaves_per_scheme_empty() {
-        // given / when
-        let config = ProxyConfig::from_proxy_url("http://unified.internal:3128");
-
-        // then
-        assert_eq!(
-            config.proxy_url.as_deref(),
-            Some("http://unified.internal:3128")
-        );
-        assert!(config.http_proxy.is_none());
-        assert!(config.https_proxy.is_none());
-        assert!(!config.is_empty());
-    }
-
-    #[test]
-    fn build_http_client_succeeds_with_unified_proxy_url() {
-        // given
-        let config = ProxyConfig {
-            proxy_url: Some("http://unified.internal:3128".to_string()),
-            no_proxy: Some("localhost".to_string()),
-            ..ProxyConfig::default()
-        };
-
-        // when
-        let result = build_http_client_with(&config);
-
-        // then
-        assert!(result.is_ok());
-    }
-
-    #[test]
-    fn proxy_url_takes_precedence_over_per_scheme_fields() {
-        // given – both per-scheme and unified are set
-        let config = ProxyConfig {
-            http_proxy: Some("http://per-scheme.internal:1111".to_string()),
-            https_proxy: Some("http://per-scheme.internal:2222".to_string()),
-            no_proxy: None,
-            proxy_url: Some("http://unified.internal:3128".to_string()),
-        };
-
-        // when – building succeeds (the unified URL is valid)
-        let result = build_http_client_with(&config);
-
-        // then
-        assert!(result.is_ok());
-    }
-
-    #[test]
-    fn build_http_client_returns_error_for_invalid_unified_proxy_url() {
-        // given
-        let config = ProxyConfig::from_proxy_url("not a url");
-
-        // when
-        let result = build_http_client_with(&config);
-
-        // then
-        assert!(
-            matches!(result, Err(crate::error::ApiError::Http(_))),
-            "invalid unified proxy URL should fail: {result:?}"
-        );
-    }
-}

rust/crates/api/src/lib.rs

@@ -1,33 +1,13 @@
 mod client;
 mod error;
-mod http_client;
-mod prompt_cache;
-mod providers;
 mod sse;
 mod types;
 
 pub use client::{
-    oauth_token_is_expired, read_base_url, read_xai_base_url, resolve_saved_oauth_token,
-    resolve_startup_auth_source, MessageStream, OAuthTokenSet, ProviderClient,
+    oauth_token_is_expired, read_base_url, resolve_saved_oauth_token, resolve_startup_auth_source,
+    AnthropicClient, AuthSource, MessageStream, OAuthTokenSet,
 };
 pub use error::ApiError;
-pub use http_client::{
-    build_http_client, build_http_client_or_default, build_http_client_with, ProxyConfig,
-};
-pub use prompt_cache::{
-    CacheBreakEvent, PromptCache, PromptCacheConfig, PromptCachePaths, PromptCacheRecord,
-    PromptCacheStats,
-};
-pub use providers::anthropic::{AnthropicClient, AnthropicClient as ApiClient, AuthSource};
-pub use providers::openai_compat::{
-    build_chat_completion_request, flatten_tool_result_content, is_reasoning_model,
-    model_rejects_is_error_field, model_requires_reasoning_content_in_history, translate_message,
-    OpenAiCompatClient, OpenAiCompatConfig,
-};
-pub use providers::{
-    detect_provider_kind, max_tokens_for_model, max_tokens_for_model_with_override,
-    model_family_identity_for, model_family_identity_for_kind, resolve_model_alias, ProviderKind,
-};
 pub use sse::{parse_frame, SseParser};
 pub use types::{
     ContentBlockDelta, ContentBlockDeltaEvent, ContentBlockStartEvent, ContentBlockStopEvent,
@@ -35,9 +15,3 @@ pub use types::{
     MessageResponse, MessageStartEvent, MessageStopEvent, OutputContentBlock, StreamEvent,
     ToolChoice, ToolDefinition, ToolResultContentBlock, Usage,
 };
-
-pub use telemetry::{
-    AnalyticsEvent, AnthropicRequestProfile, ClientIdentity, JsonlTelemetrySink,
-    MemoryTelemetrySink, SessionTraceRecord, SessionTracer, TelemetryEvent, TelemetrySink,
-    DEFAULT_ANTHROPIC_VERSION,
-};

rust/crates/api/src/prompt_cache.rs

@@ -1,735 +0,0 @@
-use std::fs;
-use std::path::{Path, PathBuf};
-use std::sync::{Arc, Mutex};
-use std::time::{Duration, SystemTime, UNIX_EPOCH};
-
-use serde::{Deserialize, Serialize};
-
-use crate::types::{MessageRequest, MessageResponse, Usage};
-
-const DEFAULT_COMPLETION_TTL_SECS: u64 = 30;
-const DEFAULT_PROMPT_TTL_SECS: u64 = 5 * 60;
-const DEFAULT_BREAK_MIN_DROP: u32 = 2_000;
-const MAX_SANITIZED_LENGTH: usize = 80;
-const REQUEST_FINGERPRINT_VERSION: u32 = 1;
-const REQUEST_FINGERPRINT_PREFIX: &str = "v1";
-const FNV_OFFSET_BASIS: u64 = 0xcbf2_9ce4_8422_2325;
-const FNV_PRIME: u64 = 0x0000_0100_0000_01b3;
-
-#[derive(Debug, Clone)]
-pub struct PromptCacheConfig {
-    pub session_id: String,
-    pub completion_ttl: Duration,
-    pub prompt_ttl: Duration,
-    pub cache_break_min_drop: u32,
-}
-
-impl PromptCacheConfig {
-    #[must_use]
-    pub fn new(session_id: impl Into<String>) -> Self {
-        Self {
-            session_id: session_id.into(),
-            completion_ttl: Duration::from_secs(DEFAULT_COMPLETION_TTL_SECS),
-            prompt_ttl: Duration::from_secs(DEFAULT_PROMPT_TTL_SECS),
-            cache_break_min_drop: DEFAULT_BREAK_MIN_DROP,
-        }
-    }
-}
-
-impl Default for PromptCacheConfig {
-    fn default() -> Self {
-        Self::new("default")
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub struct PromptCachePaths {
-    pub root: PathBuf,
-    pub session_dir: PathBuf,
-    pub completion_dir: PathBuf,
-    pub session_state_path: PathBuf,
-    pub stats_path: PathBuf,
-}
-
-impl PromptCachePaths {
-    #[must_use]
-    pub fn for_session(session_id: &str) -> Self {
-        let root = base_cache_root();
-        let session_dir = root.join(sanitize_path_segment(session_id));
-        let completion_dir = session_dir.join("completions");
-        Self {
-            root,
-            session_state_path: session_dir.join("session-state.json"),
-            stats_path: session_dir.join("stats.json"),
-            session_dir,
-            completion_dir,
-        }
-    }
-
-    #[must_use]
-    pub fn completion_entry_path(&self, request_hash: &str) -> PathBuf {
-        self.completion_dir.join(format!("{request_hash}.json"))
-    }
-}
-
-#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
-pub struct PromptCacheStats {
-    pub tracked_requests: u64,
-    pub completion_cache_hits: u64,
-    pub completion_cache_misses: u64,
-    pub completion_cache_writes: u64,
-    pub expected_invalidations: u64,
-    pub unexpected_cache_breaks: u64,
-    pub total_cache_creation_input_tokens: u64,
-    pub total_cache_read_input_tokens: u64,
-    pub last_cache_creation_input_tokens: Option<u32>,
-    pub last_cache_read_input_tokens: Option<u32>,
-    pub last_request_hash: Option<String>,
-    pub last_completion_cache_key: Option<String>,
-    pub last_break_reason: Option<String>,
-    pub last_cache_source: Option<String>,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub struct CacheBreakEvent {
-    pub unexpected: bool,
-    pub reason: String,
-    pub previous_cache_read_input_tokens: u32,
-    pub current_cache_read_input_tokens: u32,
-    pub token_drop: u32,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct PromptCacheRecord {
-    pub cache_break: Option<CacheBreakEvent>,
-    pub stats: PromptCacheStats,
-}
-
-#[derive(Debug, Clone)]
-pub struct PromptCache {
-    inner: Arc<Mutex<PromptCacheInner>>,
-}
-
-impl PromptCache {
-    #[must_use]
-    pub fn new(session_id: impl Into<String>) -> Self {
-        Self::with_config(PromptCacheConfig::new(session_id))
-    }
-
-    #[must_use]
-    pub fn with_config(config: PromptCacheConfig) -> Self {
-        let paths = PromptCachePaths::for_session(&config.session_id);
-        let stats = read_json::<PromptCacheStats>(&paths.stats_path).unwrap_or_default();
-        let previous = read_json::<TrackedPromptState>(&paths.session_state_path);
-        Self {
-            inner: Arc::new(Mutex::new(PromptCacheInner {
-                config,
-                paths,
-                stats,
-                previous,
-            })),
-        }
-    }
-
-    #[must_use]
-    pub fn paths(&self) -> PromptCachePaths {
-        self.lock().paths.clone()
-    }
-
-    #[must_use]
-    pub fn stats(&self) -> PromptCacheStats {
-        self.lock().stats.clone()
-    }
-
-    #[must_use]
-    pub fn lookup_completion(&self, request: &MessageRequest) -> Option<MessageResponse> {
-        let request_hash = request_hash_hex(request);
-        let (paths, ttl) = {
-            let inner = self.lock();
-            (inner.paths.clone(), inner.config.completion_ttl)
-        };
-        let entry_path = paths.completion_entry_path(&request_hash);
-        let entry = read_json::<CompletionCacheEntry>(&entry_path);
-        let Some(entry) = entry else {
-            let mut inner = self.lock();
-            inner.stats.completion_cache_misses += 1;
-            inner.stats.last_completion_cache_key = Some(request_hash);
-            persist_state(&inner);
-            return None;
-        };
-
-        if entry.fingerprint_version != current_fingerprint_version() {
-            let mut inner = self.lock();
-            inner.stats.completion_cache_misses += 1;
-            inner.stats.last_completion_cache_key = Some(request_hash.clone());
-            let _ = fs::remove_file(entry_path);
-            persist_state(&inner);
-            return None;
-        }
-
-        let expired = now_unix_secs().saturating_sub(entry.cached_at_unix_secs) >= ttl.as_secs();
-        let mut inner = self.lock();
-        inner.stats.last_completion_cache_key = Some(request_hash.clone());
-        if expired {
-            inner.stats.completion_cache_misses += 1;
-            let _ = fs::remove_file(entry_path);
-            persist_state(&inner);
-            return None;
-        }
-
-        inner.stats.completion_cache_hits += 1;
-        apply_usage_to_stats(
-            &mut inner.stats,
-            &entry.response.usage,
-            &request_hash,
-            "completion-cache",
-        );
-        inner.previous = Some(TrackedPromptState::from_usage(
-            request,
-            &entry.response.usage,
-        ));
-        persist_state(&inner);
-        Some(entry.response)
-    }
-
-    #[must_use]
-    pub fn record_response(
-        &self,
-        request: &MessageRequest,
-        response: &MessageResponse,
-    ) -> PromptCacheRecord {
-        self.record_usage_internal(request, &response.usage, Some(response))
-    }
-
-    #[must_use]
-    pub fn record_usage(&self, request: &MessageRequest, usage: &Usage) -> PromptCacheRecord {
-        self.record_usage_internal(request, usage, None)
-    }
-
-    fn record_usage_internal(
-        &self,
-        request: &MessageRequest,
-        usage: &Usage,
-        response: Option<&MessageResponse>,
-    ) -> PromptCacheRecord {
-        let request_hash = request_hash_hex(request);
-        let mut inner = self.lock();
-        let previous = inner.previous.clone();
-        let current = TrackedPromptState::from_usage(request, usage);
-        let cache_break = detect_cache_break(&inner.config, previous.as_ref(), &current);
-
-        inner.stats.tracked_requests += 1;
-        apply_usage_to_stats(&mut inner.stats, usage, &request_hash, "api-response");
-        if let Some(event) = &cache_break {
-            if event.unexpected {
-                inner.stats.unexpected_cache_breaks += 1;
-            } else {
-                inner.stats.expected_invalidations += 1;
-            }
-            inner.stats.last_break_reason = Some(event.reason.clone());
-        }
-
-        inner.previous = Some(current);
-        if let Some(response) = response {
-            write_completion_entry(&inner.paths, &request_hash, response);
-            inner.stats.completion_cache_writes += 1;
-        }
-        persist_state(&inner);
-
-        PromptCacheRecord {
-            cache_break,
-            stats: inner.stats.clone(),
-        }
-    }
-
-    fn lock(&self) -> std::sync::MutexGuard<'_, PromptCacheInner> {
-        self.inner
-            .lock()
-            .unwrap_or_else(std::sync::PoisonError::into_inner)
-    }
-}
-
-#[derive(Debug)]
-struct PromptCacheInner {
-    config: PromptCacheConfig,
-    paths: PromptCachePaths,
-    stats: PromptCacheStats,
-    previous: Option<TrackedPromptState>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-struct CompletionCacheEntry {
-    cached_at_unix_secs: u64,
-    #[serde(default = "current_fingerprint_version")]
-    fingerprint_version: u32,
-    response: MessageResponse,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-struct TrackedPromptState {
-    observed_at_unix_secs: u64,
-    #[serde(default = "current_fingerprint_version")]
-    fingerprint_version: u32,
-    model_hash: u64,
-    system_hash: u64,
-    tools_hash: u64,
-    messages_hash: u64,
-    cache_read_input_tokens: u32,
-}
-
-impl TrackedPromptState {
-    fn from_usage(request: &MessageRequest, usage: &Usage) -> Self {
-        let hashes = RequestFingerprints::from_request(request);
-        Self {
-            observed_at_unix_secs: now_unix_secs(),
-            fingerprint_version: current_fingerprint_version(),
-            model_hash: hashes.model,
-            system_hash: hashes.system,
-            tools_hash: hashes.tools,
-            messages_hash: hashes.messages,
-            cache_read_input_tokens: usage.cache_read_input_tokens,
-        }
-    }
-}
-
-#[derive(Debug, Clone, Copy)]
-struct RequestFingerprints {
-    model: u64,
-    system: u64,
-    tools: u64,
-    messages: u64,
-}
-
-impl RequestFingerprints {
-    fn from_request(request: &MessageRequest) -> Self {
-        Self {
-            model: hash_serializable(&request.model),
-            system: hash_serializable(&request.system),
-            tools: hash_serializable(&request.tools),
-            messages: hash_serializable(&request.messages),
-        }
-    }
-}
-
-fn detect_cache_break(
-    config: &PromptCacheConfig,
-    previous: Option<&TrackedPromptState>,
-    current: &TrackedPromptState,
-) -> Option<CacheBreakEvent> {
-    let previous = previous?;
-    if previous.fingerprint_version != current.fingerprint_version {
-        return Some(CacheBreakEvent {
-            unexpected: false,
-            reason: format!(
-                "fingerprint version changed (v{} -> v{})",
-                previous.fingerprint_version, current.fingerprint_version
-            ),
-            previous_cache_read_input_tokens: previous.cache_read_input_tokens,
-            current_cache_read_input_tokens: current.cache_read_input_tokens,
-            token_drop: previous
-                .cache_read_input_tokens
-                .saturating_sub(current.cache_read_input_tokens),
-        });
-    }
-    let token_drop = previous
-        .cache_read_input_tokens
-        .saturating_sub(current.cache_read_input_tokens);
-    if token_drop < config.cache_break_min_drop {
-        return None;
-    }
-
-    let mut reasons = Vec::new();
-    if previous.model_hash != current.model_hash {
-        reasons.push("model changed");
-    }
-    if previous.system_hash != current.system_hash {
-        reasons.push("system prompt changed");
-    }
-    if previous.tools_hash != current.tools_hash {
-        reasons.push("tool definitions changed");
-    }
-    if previous.messages_hash != current.messages_hash {
-        reasons.push("message payload changed");
-    }
-
-    let elapsed = current
-        .observed_at_unix_secs
-        .saturating_sub(previous.observed_at_unix_secs);
-
-    let (unexpected, reason) = if reasons.is_empty() {
-        if elapsed > config.prompt_ttl.as_secs() {
-            (
-                false,
-                format!("possible prompt cache TTL expiry after {elapsed}s"),
-            )
-        } else {
-            (
-                true,
-                "cache read tokens dropped while prompt fingerprint remained stable".to_string(),
-            )
-        }
-    } else {
-        (false, reasons.join(", "))
-    };
-
-    Some(CacheBreakEvent {
-        unexpected,
-        reason,
-        previous_cache_read_input_tokens: previous.cache_read_input_tokens,
-        current_cache_read_input_tokens: current.cache_read_input_tokens,
-        token_drop,
-    })
-}
-
-fn apply_usage_to_stats(
-    stats: &mut PromptCacheStats,
-    usage: &Usage,
-    request_hash: &str,
-    source: &str,
-) {
-    stats.total_cache_creation_input_tokens += u64::from(usage.cache_creation_input_tokens);
-    stats.total_cache_read_input_tokens += u64::from(usage.cache_read_input_tokens);
-    stats.last_cache_creation_input_tokens = Some(usage.cache_creation_input_tokens);
-    stats.last_cache_read_input_tokens = Some(usage.cache_read_input_tokens);
-    stats.last_request_hash = Some(request_hash.to_string());
-    stats.last_cache_source = Some(source.to_string());
-}
-
-fn persist_state(inner: &PromptCacheInner) {
-    let _ = ensure_cache_dirs(&inner.paths);
-    let _ = write_json(&inner.paths.stats_path, &inner.stats);
-    if let Some(previous) = &inner.previous {
-        let _ = write_json(&inner.paths.session_state_path, previous);
-    }
-}
-
-fn write_completion_entry(
-    paths: &PromptCachePaths,
-    request_hash: &str,
-    response: &MessageResponse,
-) {
-    let _ = ensure_cache_dirs(paths);
-    let entry = CompletionCacheEntry {
-        cached_at_unix_secs: now_unix_secs(),
-        fingerprint_version: current_fingerprint_version(),
-        response: response.clone(),
-    };
-    let _ = write_json(&paths.completion_entry_path(request_hash), &entry);
-}
-
-fn ensure_cache_dirs(paths: &PromptCachePaths) -> std::io::Result<()> {
-    fs::create_dir_all(&paths.completion_dir)
-}
-
-fn write_json<T: Serialize>(path: &Path, value: &T) -> std::io::Result<()> {
-    let json = serde_json::to_vec_pretty(value)
-        .map_err(|error| std::io::Error::new(std::io::ErrorKind::InvalidData, error))?;
-    fs::write(path, json)
-}
-
-fn read_json<T: for<'de> Deserialize<'de>>(path: &Path) -> Option<T> {
-    let bytes = fs::read(path).ok()?;
-    serde_json::from_slice(&bytes).ok()
-}
-
-fn request_hash_hex(request: &MessageRequest) -> String {
-    format!(
-        "{REQUEST_FINGERPRINT_PREFIX}-{:016x}",
-        hash_serializable(request)
-    )
-}
-
-fn hash_serializable<T: Serialize>(value: &T) -> u64 {
-    let json = serde_json::to_vec(value).unwrap_or_default();
-    stable_hash_bytes(&json)
-}
-
-fn sanitize_path_segment(value: &str) -> String {
-    let sanitized: String = value
-        .chars()
-        .map(|ch| if ch.is_ascii_alphanumeric() { ch } else { '-' })
-        .collect();
-    if sanitized.len() <= MAX_SANITIZED_LENGTH {
-        return sanitized;
-    }
-    let suffix = format!("-{:x}", hash_string(value));
-    format!(
-        "{}{}",
-        &sanitized[..MAX_SANITIZED_LENGTH.saturating_sub(suffix.len())],
-        suffix
-    )
-}
-
-fn hash_string(value: &str) -> u64 {
-    stable_hash_bytes(value.as_bytes())
-}
-
-fn base_cache_root() -> PathBuf {
-    if let Some(config_home) = std::env::var_os("CLAUDE_CONFIG_HOME") {
-        return PathBuf::from(config_home)
-            .join("cache")
-            .join("prompt-cache");
-    }
-    if let Some(home) = std::env::var_os("HOME") {
-        return PathBuf::from(home)
-            .join(".claude")
-            .join("cache")
-            .join("prompt-cache");
-    }
-    std::env::temp_dir().join("claude-prompt-cache")
-}
-
-fn now_unix_secs() -> u64 {
-    SystemTime::now()
-        .duration_since(UNIX_EPOCH)
-        .map_or(0, |duration| duration.as_secs())
-}
-
-const fn current_fingerprint_version() -> u32 {
-    REQUEST_FINGERPRINT_VERSION
-}
-
-fn stable_hash_bytes(bytes: &[u8]) -> u64 {
-    let mut hash = FNV_OFFSET_BASIS;
-    for byte in bytes {
-        hash ^= u64::from(*byte);
-        hash = hash.wrapping_mul(FNV_PRIME);
-    }
-    hash
-}
-
-#[cfg(test)]
-mod tests {
-    use std::sync::{Mutex, OnceLock};
-    use std::time::{Duration, SystemTime, UNIX_EPOCH};
-
-    use super::{
-        detect_cache_break, read_json, request_hash_hex, sanitize_path_segment, PromptCache,
-        PromptCacheConfig, PromptCachePaths, TrackedPromptState, REQUEST_FINGERPRINT_PREFIX,
-    };
-    use crate::types::{InputMessage, MessageRequest, MessageResponse, OutputContentBlock, Usage};
-
-    fn test_env_lock() -> std::sync::MutexGuard<'static, ()> {
-        static LOCK: OnceLock<Mutex<()>> = OnceLock::new();
-        LOCK.get_or_init(|| Mutex::new(()))
-            .lock()
-            .unwrap_or_else(std::sync::PoisonError::into_inner)
-    }
-
-    #[test]
-    fn path_builder_sanitizes_session_identifier() {
-        let paths = PromptCachePaths::for_session("session:/with spaces");
-        let session_dir = paths
-            .session_dir
-            .file_name()
-            .and_then(|value| value.to_str())
-            .expect("session dir name");
-        assert_eq!(session_dir, "session--with-spaces");
-        assert!(paths.completion_dir.ends_with("completions"));
-        assert!(paths.stats_path.ends_with("stats.json"));
-        assert!(paths.session_state_path.ends_with("session-state.json"));
-    }
-
-    #[test]
-    fn request_fingerprint_drives_unexpected_break_detection() {
-        let request = sample_request("same");
-        let previous = TrackedPromptState::from_usage(
-            &request,
-            &Usage {
-                input_tokens: 0,
-                cache_creation_input_tokens: 0,
-                cache_read_input_tokens: 6_000,
-                output_tokens: 0,
-            },
-        );
-        let current = TrackedPromptState::from_usage(
-            &request,
-            &Usage {
-                input_tokens: 0,
-                cache_creation_input_tokens: 0,
-                cache_read_input_tokens: 1_000,
-                output_tokens: 0,
-            },
-        );
-        let event = detect_cache_break(&PromptCacheConfig::default(), Some(&previous), &current)
-            .expect("break should be detected");
-        assert!(event.unexpected);
-        assert!(event.reason.contains("stable"));
-    }
-
-    #[test]
-    fn changed_prompt_marks_break_as_expected() {
-        let previous_request = sample_request("first");
-        let current_request = sample_request("second");
-        let previous = TrackedPromptState::from_usage(
-            &previous_request,
-            &Usage {
-                input_tokens: 0,
-                cache_creation_input_tokens: 0,
-                cache_read_input_tokens: 6_000,
-                output_tokens: 0,
-            },
-        );
-        let current = TrackedPromptState::from_usage(
-            &current_request,
-            &Usage {
-                input_tokens: 0,
-                cache_creation_input_tokens: 0,
-                cache_read_input_tokens: 1_000,
-                output_tokens: 0,
-            },
-        );
-        let event = detect_cache_break(&PromptCacheConfig::default(), Some(&previous), &current)
-            .expect("break should be detected");
-        assert!(!event.unexpected);
-        assert!(event.reason.contains("message payload changed"));
-    }
-
-    #[test]
-    fn completion_cache_round_trip_persists_recent_response() {
-        let _guard = test_env_lock();
-        let temp_root = std::env::temp_dir().join(format!(
-            "prompt-cache-test-{}-{}",
-            std::process::id(),
-            SystemTime::now()
-                .duration_since(UNIX_EPOCH)
-                .expect("time")
-                .as_nanos()
-        ));
-        std::env::set_var("CLAUDE_CONFIG_HOME", &temp_root);
-        let cache = PromptCache::new("unit-test-session");
-        let request = sample_request("cache me");
-        let response = sample_response(42, 12, "cached");
-
-        assert!(cache.lookup_completion(&request).is_none());
-        let record = cache.record_response(&request, &response);
-        assert!(record.cache_break.is_none());
-
-        let cached = cache
-            .lookup_completion(&request)
-            .expect("cached response should load");
-        assert_eq!(cached.content, response.content);
-
-        let stats = cache.stats();
-        assert_eq!(stats.completion_cache_hits, 1);
-        assert_eq!(stats.completion_cache_misses, 1);
-        assert_eq!(stats.completion_cache_writes, 1);
-
-        let persisted = read_json::<super::PromptCacheStats>(&cache.paths().stats_path)
-            .expect("stats should persist");
-        assert_eq!(persisted.completion_cache_hits, 1);
-
-        std::fs::remove_dir_all(temp_root).expect("cleanup temp root");
-        std::env::remove_var("CLAUDE_CONFIG_HOME");
-    }
-
-    #[test]
-    fn distinct_requests_do_not_collide_in_completion_cache() {
-        let _guard = test_env_lock();
-        let temp_root = std::env::temp_dir().join(format!(
-            "prompt-cache-distinct-{}-{}",
-            std::process::id(),
-            SystemTime::now()
-                .duration_since(UNIX_EPOCH)
-                .expect("time")
-                .as_nanos()
-        ));
-        std::env::set_var("CLAUDE_CONFIG_HOME", &temp_root);
-        let cache = PromptCache::new("distinct-request-session");
-        let first_request = sample_request("first");
-        let second_request = sample_request("second");
-
-        let response = sample_response(42, 12, "cached");
-        let _ = cache.record_response(&first_request, &response);
-
-        assert!(cache.lookup_completion(&second_request).is_none());
-
-        std::fs::remove_dir_all(temp_root).expect("cleanup temp root");
-        std::env::remove_var("CLAUDE_CONFIG_HOME");
-    }
-
-    #[test]
-    fn expired_completion_entries_are_not_reused() {
-        let _guard = test_env_lock();
-        let temp_root = std::env::temp_dir().join(format!(
-            "prompt-cache-expired-{}-{}",
-            std::process::id(),
-            SystemTime::now()
-                .duration_since(UNIX_EPOCH)
-                .expect("time")
-                .as_nanos()
-        ));
-        std::env::set_var("CLAUDE_CONFIG_HOME", &temp_root);
-        let cache = PromptCache::with_config(PromptCacheConfig {
-            session_id: "expired-session".to_string(),
-            completion_ttl: Duration::ZERO,
-            ..PromptCacheConfig::default()
-        });
-        let request = sample_request("expire me");
-        let response = sample_response(7, 3, "stale");
-
-        let _ = cache.record_response(&request, &response);
-
-        assert!(cache.lookup_completion(&request).is_none());
-        let stats = cache.stats();
-        assert_eq!(stats.completion_cache_hits, 0);
-        assert_eq!(stats.completion_cache_misses, 1);
-
-        std::fs::remove_dir_all(temp_root).expect("cleanup temp root");
-        std::env::remove_var("CLAUDE_CONFIG_HOME");
-    }
-
-    #[test]
-    fn sanitize_path_caps_long_values() {
-        let long_value = "x".repeat(200);
-        let sanitized = sanitize_path_segment(&long_value);
-        assert!(sanitized.len() <= 80);
-    }
-
-    #[test]
-    fn request_hashes_are_versioned_and_stable() {
-        let request = sample_request("stable");
-        let first = request_hash_hex(&request);
-        let second = request_hash_hex(&request);
-        assert_eq!(first, second);
-        assert!(first.starts_with(REQUEST_FINGERPRINT_PREFIX));
-    }
-
-    fn sample_request(text: &str) -> MessageRequest {
-        MessageRequest {
-            model: "claude-3-7-sonnet-latest".to_string(),
-            max_tokens: 64,
-            messages: vec![InputMessage::user_text(text)],
-            system: Some("system".to_string()),
-            tools: None,
-            tool_choice: None,
-            stream: false,
-            ..Default::default()
-        }
-    }
-
-    fn sample_response(
-        cache_read_input_tokens: u32,
-        output_tokens: u32,
-        text: &str,
-    ) -> MessageResponse {
-        MessageResponse {
-            id: "msg_test".to_string(),
-            kind: "message".to_string(),
-            role: "assistant".to_string(),
-            content: vec![OutputContentBlock::Text {
-                text: text.to_string(),
-            }],
-            model: "claude-3-7-sonnet-latest".to_string(),
-            stop_reason: Some("end_turn".to_string()),
-            stop_sequence: None,
-            usage: Usage {
-                input_tokens: 10,
-                cache_creation_input_tokens: 5,
-                cache_read_input_tokens,
-                output_tokens,
-            },
-            request_id: Some("req_test".to_string()),
-        }
-    }
-}

rust/crates/api/src/sse.rs

@@ -4,8 +4,6 @@ use crate::types::StreamEvent;
 #[derive(Debug, Default)]
 pub struct SseParser {
     buffer: Vec<u8>,
-    provider: Option<String>,
-    model: Option<String>,
 }
 
 impl SseParser {
@@ -14,23 +12,12 @@ impl SseParser {
         Self::default()
     }
 
-    /// Attach the provider name and model to this parser so that JSON
-    /// deserialization failures within streamed frames carry enough context
-    /// for callers to understand which upstream produced the unparseable
-    /// payload.
-    #[must_use]
-    pub fn with_context(mut self, provider: impl Into<String>, model: impl Into<String>) -> Self {
-        self.provider = Some(provider.into());
-        self.model = Some(model.into());
-        self
-    }
-
     pub fn push(&mut self, chunk: &[u8]) -> Result<Vec<StreamEvent>, ApiError> {
         self.buffer.extend_from_slice(chunk);
         let mut events = Vec::new();
 
         while let Some(frame) = self.next_frame() {
-            if let Some(event) = self.parse_frame_with_context(&frame)? {
+            if let Some(event) = parse_frame(&frame)? {
                 events.push(event);
             }
         }
@@ -44,18 +31,12 @@ impl SseParser {
         }
 
         let trailing = std::mem::take(&mut self.buffer);
-        match self.parse_frame_with_context(&String::from_utf8_lossy(&trailing))? {
+        match parse_frame(&String::from_utf8_lossy(&trailing))? {
             Some(event) => Ok(vec![event]),
             None => Ok(Vec::new()),
         }
     }
 
-    fn parse_frame_with_context(&self, frame: &str) -> Result<Option<StreamEvent>, ApiError> {
-        let provider = self.provider.as_deref().unwrap_or("unknown");
-        let model = self.model.as_deref().unwrap_or("unknown");
-        parse_frame_with_provider(frame, provider, model)
-    }
-
     fn next_frame(&mut self) -> Option<String> {
         let separator = self
             .buffer
@@ -80,14 +61,6 @@ impl SseParser {
 }
 
 pub fn parse_frame(frame: &str) -> Result<Option<StreamEvent>, ApiError> {
-    parse_frame_with_provider(frame, "unknown", "unknown")
-}
-
-pub(crate) fn parse_frame_with_provider(
-    frame: &str,
-    provider: &str,
-    model: &str,
-) -> Result<Option<StreamEvent>, ApiError> {
     let trimmed = frame.trim();
     if trimmed.is_empty() {
         return Ok(None);
@@ -124,7 +97,7 @@ pub(crate) fn parse_frame_with_provider(
 
     serde_json::from_str::<StreamEvent>(&payload)
         .map(Some)
-        .map_err(|error| ApiError::json_deserialize(provider, model, &payload, error))
+        .map_err(ApiError::from)
 }
 
 #[cfg(test)]
@@ -243,88 +216,4 @@ mod tests {
             ))
         );
     }
-
-    #[test]
-    fn parses_thinking_content_block_start() {
-        let frame = concat!(
-            "event: content_block_start\n",
-            "data: {\"type\":\"content_block_start\",\"index\":0,\"content_block\":{\"type\":\"thinking\",\"thinking\":\"\",\"signature\":null}}\n\n"
-        );
-
-        let event = parse_frame(frame).expect("frame should parse");
-        assert_eq!(
-            event,
-            Some(StreamEvent::ContentBlockStart(
-                crate::types::ContentBlockStartEvent {
-                    index: 0,
-                    content_block: OutputContentBlock::Thinking {
-                        thinking: String::new(),
-                        signature: None,
-                    },
-                },
-            ))
-        );
-    }
-
-    #[test]
-    fn parses_thinking_related_deltas() {
-        let thinking = concat!(
-            "event: content_block_delta\n",
-            "data: {\"type\":\"content_block_delta\",\"index\":0,\"delta\":{\"type\":\"thinking_delta\",\"thinking\":\"step 1\"}}\n\n"
-        );
-        let signature = concat!(
-            "event: content_block_delta\n",
-            "data: {\"type\":\"content_block_delta\",\"index\":0,\"delta\":{\"type\":\"signature_delta\",\"signature\":\"sig_123\"}}\n\n"
-        );
-
-        let thinking_event = parse_frame(thinking).expect("thinking delta should parse");
-        let signature_event = parse_frame(signature).expect("signature delta should parse");
-
-        assert_eq!(
-            thinking_event,
-            Some(StreamEvent::ContentBlockDelta(
-                crate::types::ContentBlockDeltaEvent {
-                    index: 0,
-                    delta: ContentBlockDelta::ThinkingDelta {
-                        thinking: "step 1".to_string(),
-                    },
-                }
-            ))
-        );
-        assert_eq!(
-            signature_event,
-            Some(StreamEvent::ContentBlockDelta(
-                crate::types::ContentBlockDeltaEvent {
-                    index: 0,
-                    delta: ContentBlockDelta::SignatureDelta {
-                        signature: "sig_123".to_string(),
-                    },
-                }
-            ))
-        );
-    }
-
-    #[test]
-    fn given_message_delta_frame_with_empty_usage_when_parsed_then_usage_defaults_to_zero() {
-        // given
-        let frame = concat!(
-            "event: message_delta\n",
-            "data: {\"type\":\"message_delta\",\"delta\":{\"stop_reason\":\"end_turn\",\"stop_sequence\":null},\"usage\":{}}\n\n"
-        );
-
-        // when
-        let event = parse_frame(frame).expect("frame should parse");
-
-        // then
-        assert_eq!(
-            event,
-            Some(StreamEvent::MessageDelta(crate::types::MessageDeltaEvent {
-                delta: MessageDelta {
-                    stop_reason: Some("end_turn".to_string()),
-                    stop_sequence: None,
-                },
-                usage: Usage::default(),
-            }))
-        );
-    }
 }

rust/crates/api/src/types.rs

@@ -1,8 +1,7 @@
-use runtime::{pricing_for_model, TokenUsage, UsageCostEstimate};
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
 
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct MessageRequest {
     pub model: String,
     pub max_tokens: u32,
@@ -15,22 +14,6 @@ pub struct MessageRequest {
     pub tool_choice: Option<ToolChoice>,
     #[serde(default, skip_serializing_if = "std::ops::Not::not")]
     pub stream: bool,
-    /// OpenAI-compatible tuning parameters. Optional — omitted from payload when None.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub temperature: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub top_p: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub frequency_penalty: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub presence_penalty: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub stop: Option<Vec<String>>,
-    /// Reasoning effort level for OpenAI-compatible reasoning models (e.g. `o4-mini`).
-    /// Accepted values: `"low"`, `"medium"`, `"high"`. Omitted when `None`.
-    /// Silently ignored by backends that do not support it.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub reasoning_effort: Option<String>,
 }
 
 impl MessageRequest {
@@ -81,11 +64,6 @@ pub enum InputContentBlock {
     Text {
         text: String,
     },
-    Thinking {
-        thinking: String,
-        #[serde(default, skip_serializing_if = "Option::is_none")]
-        signature: Option<String>,
-    },
     ToolUse {
         id: String,
         name: String,
@@ -134,7 +112,6 @@ pub struct MessageResponse {
     pub stop_reason: Option<String>,
     #[serde(default)]
     pub stop_sequence: Option<String>,
-    #[serde(default)]
     pub usage: Usage,
     #[serde(default)]
     pub request_id: Option<String>,
@@ -158,55 +135,22 @@ pub enum OutputContentBlock {
         name: String,
         input: Value,
     },
-    Thinking {
-        #[serde(default)]
-        thinking: String,
-        #[serde(default, skip_serializing_if = "Option::is_none")]
-        signature: Option<String>,
-    },
-    RedactedThinking {
-        data: Value,
-    },
 }
 
-#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub struct Usage {
-    #[serde(default)]
     pub input_tokens: u32,
     #[serde(default)]
     pub cache_creation_input_tokens: u32,
     #[serde(default)]
     pub cache_read_input_tokens: u32,
-    #[serde(default)]
     pub output_tokens: u32,
 }
 
 impl Usage {
     #[must_use]
     pub const fn total_tokens(&self) -> u32 {
-        self.input_tokens
-            + self.output_tokens
-            + self.cache_creation_input_tokens
-            + self.cache_read_input_tokens
-    }
-
-    #[must_use]
-    pub const fn token_usage(&self) -> TokenUsage {
-        TokenUsage {
-            input_tokens: self.input_tokens,
-            output_tokens: self.output_tokens,
-            cache_creation_input_tokens: self.cache_creation_input_tokens,
-            cache_read_input_tokens: self.cache_read_input_tokens,
-        }
-    }
-
-    #[must_use]
-    pub fn estimated_cost_usd(&self, model: &str) -> UsageCostEstimate {
-        let usage = self.token_usage();
-        pricing_for_model(model).map_or_else(
-            || usage.estimate_cost_usd(),
-            |pricing| usage.estimate_cost_usd_with_pricing(pricing),
-        )
+        self.input_tokens + self.output_tokens
     }
 }
 
@@ -218,7 +162,6 @@ pub struct MessageStartEvent {
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct MessageDeltaEvent {
     pub delta: MessageDelta,
-    #[serde(default)]
     pub usage: Usage,
 }
 
@@ -247,8 +190,6 @@ pub struct ContentBlockDeltaEvent {
 pub enum ContentBlockDelta {
     TextDelta { text: String },
     InputJsonDelta { partial_json: String },
-    ThinkingDelta { thinking: String },
-    SignatureDelta { signature: String },
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
@@ -269,77 +210,3 @@ pub enum StreamEvent {
     ContentBlockStop(ContentBlockStopEvent),
     MessageStop(MessageStopEvent),
 }
-
-#[cfg(test)]
-mod tests {
-    use runtime::format_usd;
-    use serde_json::json;
-
-    use super::{InputContentBlock, MessageResponse, Usage};
-
-    #[test]
-    fn usage_total_tokens_includes_cache_tokens() {
-        let usage = Usage {
-            input_tokens: 10,
-            cache_creation_input_tokens: 2,
-            cache_read_input_tokens: 3,
-            output_tokens: 4,
-        };
-
-        assert_eq!(usage.total_tokens(), 19);
-        assert_eq!(usage.token_usage().total_tokens(), 19);
-    }
-
-    #[test]
-    fn message_response_estimates_cost_from_model_usage() {
-        let response = MessageResponse {
-            id: "msg_cost".to_string(),
-            kind: "message".to_string(),
-            role: "assistant".to_string(),
-            content: Vec::new(),
-            model: "claude-sonnet-4-20250514".to_string(),
-            stop_reason: Some("end_turn".to_string()),
-            stop_sequence: None,
-            usage: Usage {
-                input_tokens: 1_000_000,
-                cache_creation_input_tokens: 100_000,
-                cache_read_input_tokens: 200_000,
-                output_tokens: 500_000,
-            },
-            request_id: None,
-        };
-
-        let cost = response.usage.estimated_cost_usd(&response.model);
-        assert_eq!(format_usd(cost.total_cost_usd()), "$54.6750");
-        assert_eq!(response.total_tokens(), 1_800_000);
-    }
-
-    #[test]
-    fn input_content_block_thinking_serializes_with_snake_case_type() {
-        // given
-        let block = InputContentBlock::Thinking {
-            thinking: "pondering".to_string(),
-            signature: Some("sig_123".to_string()),
-        };
-
-        // when
-        let serialized = serde_json::to_value(&block).unwrap();
-        let deserialized: InputContentBlock = serde_json::from_value(json!({
-            "type": "thinking",
-            "thinking": "pondering",
-            "signature": "sig_123"
-        }))
-        .unwrap();
-
-        // then
-        assert_eq!(
-            serialized,
-            json!({
-                "type": "thinking",
-                "thinking": "pondering",
-                "signature": "sig_123"
-            })
-        );
-        assert_eq!(deserialized, block);
-    }
-}

rust/crates/api/tests/client_integration.rs

@@ -1,27 +1,17 @@
 use std::collections::HashMap;
 use std::sync::Arc;
-use std::sync::{Mutex as StdMutex, OnceLock};
 use std::time::Duration;
 
 use api::{
-    AnthropicClient, ApiClient, ApiError, AuthSource, ContentBlockDelta, ContentBlockDeltaEvent,
-    ContentBlockStartEvent, InputContentBlock, InputMessage, MessageDeltaEvent, MessageRequest,
-    OutputContentBlock, PromptCache, PromptCacheConfig, ProviderClient, StreamEvent, ToolChoice,
-    ToolDefinition,
+    AnthropicClient, ApiError, ContentBlockDelta, ContentBlockDeltaEvent, ContentBlockStartEvent,
+    InputContentBlock, InputMessage, MessageDeltaEvent, MessageRequest, OutputContentBlock,
+    StreamEvent, ToolChoice, ToolDefinition,
 };
 use serde_json::json;
-use telemetry::{ClientIdentity, MemoryTelemetrySink, SessionTracer, TelemetryEvent};
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
 use tokio::net::TcpListener;
 use tokio::sync::Mutex;
 
-fn env_lock() -> std::sync::MutexGuard<'static, ()> {
-    static LOCK: OnceLock<StdMutex<()>> = OnceLock::new();
-    LOCK.get_or_init(|| StdMutex::new(()))
-        .lock()
-        .unwrap_or_else(std::sync::PoisonError::into_inner)
-}
-
 #[tokio::test]
 async fn send_message_posts_json_and_parses_response() {
     let state = Arc::new(Mutex::new(Vec::<CapturedRequest>::new()));
@@ -44,7 +34,7 @@ async fn send_message_posts_json_and_parses_response() {
     )
     .await;
 
-    let client = ApiClient::new("test-key")
+    let client = AnthropicClient::new("test-key")
         .with_auth_token(Some("proxy-token".to_string()))
         .with_base_url(server.base_url());
     let response = client
@@ -55,8 +45,6 @@ async fn send_message_posts_json_and_parses_response() {
     assert_eq!(response.id, "msg_test");
     assert_eq!(response.total_tokens(), 16);
     assert_eq!(response.request_id.as_deref(), Some("req_body_123"));
-    assert_eq!(response.usage.cache_creation_input_tokens, 0);
-    assert_eq!(response.usage.cache_read_input_tokens, 0);
     assert_eq!(
         response.content,
         vec![OutputContentBlock::Text {
@@ -76,18 +64,6 @@ async fn send_message_posts_json_and_parses_response() {
         request.headers.get("authorization").map(String::as_str),
         Some("Bearer proxy-token")
     );
-    assert_eq!(
-        request.headers.get("anthropic-version").map(String::as_str),
-        Some("2023-06-01")
-    );
-    assert_eq!(
-        request.headers.get("user-agent").map(String::as_str),
-        Some("claude-code/0.1.0")
-    );
-    assert_eq!(
-        request.headers.get("anthropic-beta").map(String::as_str),
-        Some("claude-code-20250219,prompt-caching-scope-2026-01-05")
-    );
     let body: serde_json::Value =
         serde_json::from_str(&request.body).expect("request body should be json");
     assert_eq!(
@@ -97,237 +73,14 @@ async fn send_message_posts_json_and_parses_response() {
     assert!(body.get("stream").is_none());
     assert_eq!(body["tools"][0]["name"], json!("get_weather"));
     assert_eq!(body["tool_choice"]["type"], json!("auto"));
-    assert!(
-        body.get("betas").is_none(),
-        "betas must travel via the anthropic-beta header, not the request body"
-    );
 }
 
 #[tokio::test]
-async fn send_message_blocks_oversized_requests_before_the_http_call() {
-    let state = Arc::new(Mutex::new(Vec::<CapturedRequest>::new()));
-    let server = spawn_server(
-        state.clone(),
-        vec![http_response("200 OK", "application/json", "{}")],
-    )
-    .await;
-
-    let client = AnthropicClient::new("test-key").with_base_url(server.base_url());
-    let error = client
-        .send_message(&MessageRequest {
-            model: "claude-sonnet-4-6".to_string(),
-            max_tokens: 64_000,
-            messages: vec![InputMessage {
-                role: "user".to_string(),
-                content: vec![InputContentBlock::Text {
-                    text: "x".repeat(600_000),
-                }],
-            }],
-            system: Some("Keep the answer short.".to_string()),
-            tools: None,
-            tool_choice: None,
-            stream: false,
-            ..Default::default()
-        })
-        .await
-        .expect_err("oversized request should fail local context-window preflight");
-
-    assert!(matches!(error, ApiError::ContextWindowExceeded { .. }));
-    assert!(
-        state.lock().await.is_empty(),
-        "preflight failure should avoid any upstream HTTP request"
-    );
-}
-
-#[tokio::test]
-async fn send_message_applies_request_profile_and_records_telemetry() {
-    let state = Arc::new(Mutex::new(Vec::<CapturedRequest>::new()));
-    let server = spawn_server(
-        state.clone(),
-        vec![http_response_with_headers(
-            "200 OK",
-            "application/json",
-            concat!(
-                "{",
-                "\"id\":\"msg_profile\",",
-                "\"type\":\"message\",",
-                "\"role\":\"assistant\",",
-                "\"content\":[{\"type\":\"text\",\"text\":\"ok\"}],",
-                "\"model\":\"claude-3-7-sonnet-latest\",",
-                "\"stop_reason\":\"end_turn\",",
-                "\"stop_sequence\":null,",
-                "\"usage\":{\"input_tokens\":1,\"cache_creation_input_tokens\":2,\"cache_read_input_tokens\":3,\"output_tokens\":1}",
-                "}"
-            ),
-            &[("request-id", "req_profile_123")],
-        )],
-    )
-    .await;
-    let sink = Arc::new(MemoryTelemetrySink::default());
-
-    let client = AnthropicClient::new("test-key")
-        .with_base_url(server.base_url())
-        .with_client_identity(ClientIdentity::new("claude-code", "9.9.9").with_runtime("rust-cli"))
-        .with_beta("tools-2026-04-01")
-        .with_extra_body_param("metadata", json!({"source": "clawd-code"}))
-        .with_session_tracer(SessionTracer::new("session-telemetry", sink.clone()));
-
-    let response = client
-        .send_message(&sample_request(false))
-        .await
-        .expect("request should succeed");
-
-    assert_eq!(response.request_id.as_deref(), Some("req_profile_123"));
-
-    let captured = state.lock().await;
-    let request = captured.first().expect("server should capture request");
-    assert_eq!(
-        request.headers.get("anthropic-beta").map(String::as_str),
-        Some("claude-code-20250219,prompt-caching-scope-2026-01-05,tools-2026-04-01")
-    );
-    assert_eq!(
-        request.headers.get("user-agent").map(String::as_str),
-        Some("claude-code/9.9.9")
-    );
-    let body: serde_json::Value =
-        serde_json::from_str(&request.body).expect("request body should be json");
-    assert_eq!(body["metadata"]["source"], json!("clawd-code"));
-    assert!(
-        body.get("betas").is_none(),
-        "betas must travel via the anthropic-beta header, not the request body"
-    );
-
-    let events = sink.events();
-    assert_eq!(events.len(), 6);
-    assert!(matches!(
-        &events[0],
-        TelemetryEvent::HttpRequestStarted {
-            session_id,
-            attempt: 1,
-            method,
-            path,
-            ..
-        } if session_id == "session-telemetry" && method == "POST" && path == "/v1/messages"
-    ));
-    assert!(matches!(
-        &events[1],
-        TelemetryEvent::SessionTrace(trace) if trace.name == "http_request_started"
-    ));
-    assert!(matches!(
-        &events[2],
-        TelemetryEvent::HttpRequestSucceeded {
-            request_id,
-            status: 200,
-            ..
-        } if request_id.as_deref() == Some("req_profile_123")
-    ));
-    assert!(matches!(
-        &events[3],
-        TelemetryEvent::SessionTrace(trace) if trace.name == "http_request_succeeded"
-    ));
-    assert!(matches!(
-        &events[4],
-        TelemetryEvent::Analytics(event)
-            if event.namespace == "api"
-                && event.action == "message_usage"
-                && event.properties.get("request_id") == Some(&json!("req_profile_123"))
-                && event.properties.get("total_tokens") == Some(&json!(7))
-                && event.properties.get("estimated_cost_usd") == Some(&json!("$0.0001"))
-    ));
-    assert!(matches!(
-        &events[5],
-        TelemetryEvent::SessionTrace(trace) if trace.name == "analytics"
-    ));
-}
-
-#[tokio::test]
-async fn send_message_parses_prompt_cache_token_usage_from_response() {
-    let state = Arc::new(Mutex::new(Vec::<CapturedRequest>::new()));
-    let body = concat!(
-        "{",
-        "\"id\":\"msg_cache_tokens\",",
-        "\"type\":\"message\",",
-        "\"role\":\"assistant\",",
-        "\"content\":[{\"type\":\"text\",\"text\":\"Cache tokens\"}],",
-        "\"model\":\"claude-3-7-sonnet-latest\",",
-        "\"stop_reason\":\"end_turn\",",
-        "\"stop_sequence\":null,",
-        "\"usage\":{\"input_tokens\":12,\"cache_creation_input_tokens\":321,\"cache_read_input_tokens\":654,\"output_tokens\":4}",
-        "}"
-    );
-    let server = spawn_server(
-        state,
-        vec![http_response("200 OK", "application/json", body)],
-    )
-    .await;
-
-    let client = AnthropicClient::new("test-key").with_base_url(server.base_url());
-    let response = client
-        .send_message(&sample_request(false))
-        .await
-        .expect("request should succeed");
-
-    assert_eq!(response.usage.input_tokens, 12);
-    assert_eq!(response.usage.cache_creation_input_tokens, 321);
-    assert_eq!(response.usage.cache_read_input_tokens, 654);
-    assert_eq!(response.usage.output_tokens, 4);
-}
-
-#[tokio::test]
-async fn given_empty_usage_object_when_send_message_parses_response_then_usage_defaults_to_zero() {
-    // given
-    let state = Arc::new(Mutex::new(Vec::<CapturedRequest>::new()));
-    let body = concat!(
-        "{",
-        "\"id\":\"msg_empty_usage\",",
-        "\"type\":\"message\",",
-        "\"role\":\"assistant\",",
-        "\"content\":[{\"type\":\"text\",\"text\":\"Hello from Claude\"}],",
-        "\"model\":\"claude-3-7-sonnet-latest\",",
-        "\"stop_reason\":\"end_turn\",",
-        "\"stop_sequence\":null,",
-        "\"usage\":{}",
-        "}"
-    );
-    let server = spawn_server(
-        state,
-        vec![http_response("200 OK", "application/json", body)],
-    )
-    .await;
-    let client = AnthropicClient::new("test-key").with_base_url(server.base_url());
-
-    // when
-    let response = client
-        .send_message(&sample_request(false))
-        .await
-        .expect("response with empty usage object should still parse");
-
-    // then
-    assert_eq!(response.id, "msg_empty_usage");
-    assert_eq!(response.total_tokens(), 0);
-    assert_eq!(response.usage.input_tokens, 0);
-    assert_eq!(response.usage.cache_creation_input_tokens, 0);
-    assert_eq!(response.usage.cache_read_input_tokens, 0);
-    assert_eq!(response.usage.output_tokens, 0);
-}
-
-#[tokio::test]
-#[allow(clippy::await_holding_lock)]
 async fn stream_message_parses_sse_events_with_tool_use() {
-    let _guard = env_lock();
-    let temp_root = std::env::temp_dir().join(format!(
-        "api-stream-cache-{}-{}",
-        std::process::id(),
-        std::time::SystemTime::now()
-            .duration_since(std::time::UNIX_EPOCH)
-            .expect("time")
-            .as_nanos()
-    ));
-    std::env::set_var("CLAUDE_CONFIG_HOME", &temp_root);
     let state = Arc::new(Mutex::new(Vec::<CapturedRequest>::new()));
     let sse = concat!(
         "event: message_start\n",
-        "data: {\"type\":\"message_start\",\"message\":{\"id\":\"msg_stream\",\"type\":\"message\",\"role\":\"assistant\",\"content\":[],\"model\":\"claude-3-7-sonnet-latest\",\"stop_reason\":null,\"stop_sequence\":null,\"usage\":{\"input_tokens\":8,\"cache_creation_input_tokens\":13,\"cache_read_input_tokens\":21,\"output_tokens\":0}}}\n\n",
+        "data: {\"type\":\"message_start\",\"message\":{\"id\":\"msg_stream\",\"type\":\"message\",\"role\":\"assistant\",\"content\":[],\"model\":\"claude-3-7-sonnet-latest\",\"stop_reason\":null,\"stop_sequence\":null,\"usage\":{\"input_tokens\":8,\"output_tokens\":0}}}\n\n",
         "event: content_block_start\n",
         "data: {\"type\":\"content_block_start\",\"index\":0,\"content_block\":{\"type\":\"tool_use\",\"id\":\"toolu_123\",\"name\":\"get_weather\",\"input\":{}}}\n\n",
         "event: content_block_delta\n",
@@ -335,7 +88,7 @@ async fn stream_message_parses_sse_events_with_tool_use() {
         "event: content_block_stop\n",
         "data: {\"type\":\"content_block_stop\",\"index\":0}\n\n",
         "event: message_delta\n",
-        "data: {\"type\":\"message_delta\",\"delta\":{\"stop_reason\":\"tool_use\",\"stop_sequence\":null},\"usage\":{\"input_tokens\":8,\"cache_creation_input_tokens\":34,\"cache_read_input_tokens\":55,\"output_tokens\":1}}\n\n",
+        "data: {\"type\":\"message_delta\",\"delta\":{\"stop_reason\":\"tool_use\",\"stop_sequence\":null},\"usage\":{\"input_tokens\":8,\"output_tokens\":1}}\n\n",
         "event: message_stop\n",
         "data: {\"type\":\"message_stop\"}\n\n",
         "data: [DONE]\n\n"
@@ -351,10 +104,9 @@ async fn stream_message_parses_sse_events_with_tool_use() {
     )
     .await;
 
-    let client = ApiClient::new("test-key")
+    let client = AnthropicClient::new("test-key")
         .with_auth_token(Some("proxy-token".to_string()))
-        .with_base_url(server.base_url())
-        .with_prompt_cache(PromptCache::new("stream-session"));
+        .with_base_url(server.base_url());
     let mut stream = client
         .stream_message(&sample_request(false))
         .await
@@ -408,20 +160,6 @@ async fn stream_message_parses_sse_events_with_tool_use() {
     let captured = state.lock().await;
     let request = captured.first().expect("server should capture request");
     assert!(request.body.contains("\"stream\":true"));
-
-    let cache_stats = client
-        .prompt_cache_stats()
-        .expect("prompt cache stats should exist");
-    assert_eq!(cache_stats.tracked_requests, 1);
-    assert_eq!(cache_stats.last_cache_creation_input_tokens, Some(34));
-    assert_eq!(cache_stats.last_cache_read_input_tokens, Some(55));
-    assert_eq!(
-        cache_stats.last_cache_source.as_deref(),
-        Some("api-response")
-    );
-
-    std::fs::remove_dir_all(temp_root).expect("cleanup temp root");
-    std::env::remove_var("CLAUDE_CONFIG_HOME");
 }
 
 #[tokio::test]
@@ -444,7 +182,7 @@ async fn retries_retryable_failures_before_succeeding() {
     )
     .await;
 
-    let client = ApiClient::new("test-key")
+    let client = AnthropicClient::new("test-key")
         .with_base_url(server.base_url())
         .with_retry_policy(2, Duration::from_millis(1), Duration::from_millis(2));
 
@@ -457,47 +195,6 @@ async fn retries_retryable_failures_before_succeeding() {
     assert_eq!(state.lock().await.len(), 2);
 }
 
-#[tokio::test]
-async fn provider_client_dispatches_anthropic_requests() {
-    let state = Arc::new(Mutex::new(Vec::<CapturedRequest>::new()));
-    let server = spawn_server(
-        state.clone(),
-        vec![http_response(
-            "200 OK",
-            "application/json",
-            "{\"id\":\"msg_provider\",\"type\":\"message\",\"role\":\"assistant\",\"content\":[{\"type\":\"text\",\"text\":\"Dispatched\"}],\"model\":\"claude-3-7-sonnet-latest\",\"stop_reason\":\"end_turn\",\"stop_sequence\":null,\"usage\":{\"input_tokens\":3,\"output_tokens\":2}}",
-        )],
-    )
-    .await;
-
-    let client = ProviderClient::from_model_with_anthropic_auth(
-        "claude-sonnet-4-6",
-        Some(AuthSource::ApiKey("test-key".to_string())),
-    )
-    .expect("anthropic provider client should be constructed");
-    let client = match client {
-        ProviderClient::Anthropic(client) => {
-            ProviderClient::Anthropic(client.with_base_url(server.base_url()))
-        }
-        other => panic!("expected anthropic provider, got {other:?}"),
-    };
-
-    let response = client
-        .send_message(&sample_request(false))
-        .await
-        .expect("provider-dispatched request should succeed");
-
-    assert_eq!(response.total_tokens(), 5);
-
-    let captured = state.lock().await;
-    let request = captured.first().expect("server should capture request");
-    assert_eq!(request.path, "/v1/messages");
-    assert_eq!(
-        request.headers.get("x-api-key").map(String::as_str),
-        Some("test-key")
-    );
-}
-
 #[tokio::test]
 async fn surfaces_retry_exhaustion_for_persistent_retryable_errors() {
     let state = Arc::new(Mutex::new(Vec::<CapturedRequest>::new()));
@@ -518,7 +215,7 @@ async fn surfaces_retry_exhaustion_for_persistent_retryable_errors() {
     )
     .await;
 
-    let client = ApiClient::new("test-key")
+    let client = AnthropicClient::new("test-key")
         .with_base_url(server.base_url())
         .with_retry_policy(1, Duration::from_millis(1), Duration::from_millis(2));
 
@@ -546,190 +243,10 @@ async fn surfaces_retry_exhaustion_for_persistent_retryable_errors() {
     }
 }
 
-#[tokio::test]
-async fn retries_multiple_retryable_failures_with_exponential_backoff_and_jitter() {
-    let state = Arc::new(Mutex::new(Vec::<CapturedRequest>::new()));
-    let server = spawn_server(
-        state.clone(),
-        vec![
-            http_response(
-                "429 Too Many Requests",
-                "application/json",
-                "{\"type\":\"error\",\"error\":{\"type\":\"rate_limit_error\",\"message\":\"slow down\"}}",
-            ),
-            http_response(
-                "500 Internal Server Error",
-                "application/json",
-                "{\"type\":\"error\",\"error\":{\"type\":\"api_error\",\"message\":\"boom\"}}",
-            ),
-            http_response(
-                "503 Service Unavailable",
-                "application/json",
-                "{\"type\":\"error\",\"error\":{\"type\":\"overloaded_error\",\"message\":\"busy\"}}",
-            ),
-            http_response(
-                "429 Too Many Requests",
-                "application/json",
-                "{\"type\":\"error\",\"error\":{\"type\":\"rate_limit_error\",\"message\":\"slow down again\"}}",
-            ),
-            http_response(
-                "503 Service Unavailable",
-                "application/json",
-                "{\"type\":\"error\",\"error\":{\"type\":\"overloaded_error\",\"message\":\"still busy\"}}",
-            ),
-            http_response(
-                "200 OK",
-                "application/json",
-                "{\"id\":\"msg_exp_retry\",\"type\":\"message\",\"role\":\"assistant\",\"content\":[{\"type\":\"text\",\"text\":\"Recovered after 5\"}],\"model\":\"claude-3-7-sonnet-latest\",\"stop_reason\":\"end_turn\",\"stop_sequence\":null,\"usage\":{\"input_tokens\":3,\"output_tokens\":2}}",
-            ),
-        ],
-    )
-    .await;
-
-    let client = ApiClient::new("test-key")
-        .with_base_url(server.base_url())
-        .with_retry_policy(8, Duration::from_millis(1), Duration::from_millis(4));
-    let started_at = std::time::Instant::now();
-
-    let response = client
-        .send_message(&sample_request(false))
-        .await
-        .expect("8-retry policy should absorb 5 retryable failures");
-
-    let elapsed = started_at.elapsed();
-    assert_eq!(response.total_tokens(), 5);
-    assert_eq!(
-        state.lock().await.len(),
-        6,
-        "client should issue 1 original + 5 retry requests before the 200"
-    );
-    // Jittered sleeps are bounded by 2 * max_backoff per retry (base + jitter),
-    // so 5 sleeps fit comfortably below this upper bound with generous slack.
-    assert!(
-        elapsed < Duration::from_secs(5),
-        "retries should complete promptly, took {elapsed:?}"
-    );
-}
-
-#[tokio::test]
-#[allow(clippy::await_holding_lock)]
-async fn send_message_reuses_recent_completion_cache_entries() {
-    let _guard = env_lock();
-    let temp_root = std::env::temp_dir().join(format!(
-        "api-prompt-cache-{}-{}",
-        std::process::id(),
-        std::time::SystemTime::now()
-            .duration_since(std::time::UNIX_EPOCH)
-            .expect("time")
-            .as_nanos()
-    ));
-    std::env::set_var("CLAUDE_CONFIG_HOME", &temp_root);
-
-    let state = Arc::new(Mutex::new(Vec::<CapturedRequest>::new()));
-    let server = spawn_server(
-        state.clone(),
-        vec![http_response(
-            "200 OK",
-            "application/json",
-            "{\"id\":\"msg_cached\",\"type\":\"message\",\"role\":\"assistant\",\"content\":[{\"type\":\"text\",\"text\":\"Cached once\"}],\"model\":\"claude-3-7-sonnet-latest\",\"stop_reason\":\"end_turn\",\"stop_sequence\":null,\"usage\":{\"input_tokens\":3,\"cache_creation_input_tokens\":5,\"cache_read_input_tokens\":4000,\"output_tokens\":2}}",
-        )],
-    )
-    .await;
-
-    let client = AnthropicClient::new("test-key")
-        .with_base_url(server.base_url())
-        .with_prompt_cache(PromptCache::new("integration-session"));
-
-    let first = client
-        .send_message(&sample_request(false))
-        .await
-        .expect("first request should succeed");
-    let second = client
-        .send_message(&sample_request(false))
-        .await
-        .expect("second request should reuse cache");
-
-    assert_eq!(first.content, second.content);
-    assert_eq!(state.lock().await.len(), 1);
-
-    let cache_stats = client
-        .prompt_cache_stats()
-        .expect("prompt cache stats should exist");
-    assert_eq!(cache_stats.completion_cache_hits, 1);
-    assert_eq!(cache_stats.completion_cache_misses, 1);
-    assert_eq!(cache_stats.completion_cache_writes, 1);
-
-    std::fs::remove_dir_all(temp_root).expect("cleanup temp root");
-    std::env::remove_var("CLAUDE_CONFIG_HOME");
-}
-
-#[tokio::test]
-#[allow(clippy::await_holding_lock)]
-async fn send_message_tracks_unexpected_prompt_cache_breaks() {
-    let _guard = env_lock();
-    let temp_root = std::env::temp_dir().join(format!(
-        "api-prompt-break-{}-{}",
-        std::process::id(),
-        std::time::SystemTime::now()
-            .duration_since(std::time::UNIX_EPOCH)
-            .expect("time")
-            .as_nanos()
-    ));
-    std::env::set_var("CLAUDE_CONFIG_HOME", &temp_root);
-
-    let state = Arc::new(Mutex::new(Vec::<CapturedRequest>::new()));
-    let server = spawn_server(
-        state,
-        vec![
-            http_response(
-                "200 OK",
-                "application/json",
-                "{\"id\":\"msg_one\",\"type\":\"message\",\"role\":\"assistant\",\"content\":[{\"type\":\"text\",\"text\":\"One\"}],\"model\":\"claude-3-7-sonnet-latest\",\"stop_reason\":\"end_turn\",\"stop_sequence\":null,\"usage\":{\"input_tokens\":3,\"cache_creation_input_tokens\":5,\"cache_read_input_tokens\":6000,\"output_tokens\":2}}",
-            ),
-            http_response(
-                "200 OK",
-                "application/json",
-                "{\"id\":\"msg_two\",\"type\":\"message\",\"role\":\"assistant\",\"content\":[{\"type\":\"text\",\"text\":\"Two\"}],\"model\":\"claude-3-7-sonnet-latest\",\"stop_reason\":\"end_turn\",\"stop_sequence\":null,\"usage\":{\"input_tokens\":3,\"cache_creation_input_tokens\":0,\"cache_read_input_tokens\":1000,\"output_tokens\":2}}",
-            ),
-        ],
-    )
-    .await;
-
-    let request = sample_request(false);
-    let client = AnthropicClient::new("test-key")
-        .with_base_url(server.base_url())
-        .with_prompt_cache(PromptCache::with_config(PromptCacheConfig {
-            session_id: "break-session".to_string(),
-            completion_ttl: Duration::from_secs(0),
-            ..PromptCacheConfig::default()
-        }));
-
-    client
-        .send_message(&request)
-        .await
-        .expect("first response should succeed");
-    client
-        .send_message(&request)
-        .await
-        .expect("second response should succeed");
-
-    let cache_stats = client
-        .prompt_cache_stats()
-        .expect("prompt cache stats should exist");
-    assert_eq!(cache_stats.unexpected_cache_breaks, 1);
-    assert_eq!(
-        cache_stats.last_break_reason.as_deref(),
-        Some("cache read tokens dropped while prompt fingerprint remained stable")
-    );
-
-    std::fs::remove_dir_all(temp_root).expect("cleanup temp root");
-    std::env::remove_var("CLAUDE_CONFIG_HOME");
-}
-
 #[tokio::test]
 #[ignore = "requires ANTHROPIC_API_KEY and network access"]
 async fn live_stream_smoke_test() {
-    let client = ApiClient::from_env().expect("ANTHROPIC_API_KEY must be set");
+    let client = AnthropicClient::from_env().expect("ANTHROPIC_API_KEY must be set");
     let mut stream = client
         .stream_message(&MessageRequest {
             model: std::env::var("ANTHROPIC_MODEL")
@@ -742,7 +259,6 @@ async fn live_stream_smoke_test() {
             tools: None,
             tool_choice: None,
             stream: false,
-            ..Default::default()
         })
         .await
         .expect("live stream should start");
@@ -923,6 +439,5 @@ fn sample_request(stream: bool) -> MessageRequest {
         }]),
         tool_choice: Some(ToolChoice::Auto),
         stream,
-        ..Default::default()
     }
 }

rust/crates/api/tests/openai_compat_integration.rs

@@ -1,575 +0,0 @@
-use std::collections::HashMap;
-use std::ffi::OsString;
-use std::sync::Arc;
-use std::sync::{Mutex as StdMutex, OnceLock};
-
-use api::{
-    ApiError, ContentBlockDelta, ContentBlockDeltaEvent, ContentBlockStartEvent,
-    ContentBlockStopEvent, InputContentBlock, InputMessage, MessageDeltaEvent, MessageRequest,
-    OpenAiCompatClient, OpenAiCompatConfig, OutputContentBlock, ProviderClient, StreamEvent,
-    ToolChoice, ToolDefinition,
-};
-use serde_json::json;
-use tokio::io::{AsyncReadExt, AsyncWriteExt};
-use tokio::net::TcpListener;
-use tokio::sync::Mutex;
-
-#[tokio::test]
-async fn send_message_uses_openai_compatible_endpoint_and_auth() {
-    let state = Arc::new(Mutex::new(Vec::<CapturedRequest>::new()));
-    let body = concat!(
-        "{",
-        "\"id\":\"chatcmpl_test\",",
-        "\"model\":\"grok-3\",",
-        "\"choices\":[{",
-        "\"message\":{\"role\":\"assistant\",\"content\":\"Hello from Grok\",\"tool_calls\":[]},",
-        "\"finish_reason\":\"stop\"",
-        "}],",
-        "\"usage\":{\"prompt_tokens\":11,\"completion_tokens\":5}",
-        "}"
-    );
-    let server = spawn_server(
-        state.clone(),
-        vec![http_response("200 OK", "application/json", body)],
-    )
-    .await;
-
-    let client = OpenAiCompatClient::new("xai-test-key", OpenAiCompatConfig::xai())
-        .with_base_url(server.base_url());
-    let response = client
-        .send_message(&sample_request(false))
-        .await
-        .expect("request should succeed");
-
-    assert_eq!(response.model, "grok-3");
-    assert_eq!(response.total_tokens(), 16);
-    assert_eq!(
-        response.content,
-        vec![OutputContentBlock::Text {
-            text: "Hello from Grok".to_string(),
-        }]
-    );
-
-    let captured = state.lock().await;
-    let request = captured.first().expect("server should capture request");
-    assert_eq!(request.path, "/chat/completions");
-    assert_eq!(
-        request.headers.get("authorization").map(String::as_str),
-        Some("Bearer xai-test-key")
-    );
-    let body: serde_json::Value = serde_json::from_str(&request.body).expect("json body");
-    assert_eq!(body["model"], json!("grok-3"));
-    assert_eq!(body["messages"][0]["role"], json!("system"));
-    assert_eq!(body["tools"][0]["type"], json!("function"));
-}
-
-#[tokio::test]
-async fn send_message_preserves_deepseek_reasoning_content_before_text() {
-    let state = Arc::new(Mutex::new(Vec::<CapturedRequest>::new()));
-    let body = concat!(
-        "{",
-        "\"id\":\"chatcmpl_deepseek_reasoning\",",
-        "\"model\":\"deepseek-v4-pro\",",
-        "\"choices\":[{",
-        "\"message\":{\"role\":\"assistant\",\"reasoning_content\":\"Think first\",\"content\":\"Answer second\",\"tool_calls\":[]},",
-        "\"finish_reason\":\"stop\"",
-        "}],",
-        "\"usage\":{\"prompt_tokens\":11,\"completion_tokens\":5}",
-        "}"
-    );
-    let server = spawn_server(
-        state.clone(),
-        vec![http_response("200 OK", "application/json", body)],
-    )
-    .await;
-
-    let client = OpenAiCompatClient::new("openai-test-key", OpenAiCompatConfig::openai())
-        .with_base_url(server.base_url());
-    let response = client
-        .send_message(&MessageRequest {
-            model: "openai/deepseek-v4-pro".to_string(),
-            ..sample_request(false)
-        })
-        .await
-        .expect("request should succeed");
-
-    assert_eq!(
-        response.content,
-        vec![
-            OutputContentBlock::Thinking {
-                thinking: "Think first".to_string(),
-                signature: None,
-            },
-            OutputContentBlock::Text {
-                text: "Answer second".to_string(),
-            },
-        ]
-    );
-}
-
-#[tokio::test]
-async fn send_message_blocks_oversized_xai_requests_before_the_http_call() {
-    let state = Arc::new(Mutex::new(Vec::<CapturedRequest>::new()));
-    let server = spawn_server(
-        state.clone(),
-        vec![http_response("200 OK", "application/json", "{}")],
-    )
-    .await;
-
-    let client = OpenAiCompatClient::new("xai-test-key", OpenAiCompatConfig::xai())
-        .with_base_url(server.base_url());
-    let error = client
-        .send_message(&MessageRequest {
-            model: "grok-3".to_string(),
-            max_tokens: 64_000,
-            messages: vec![InputMessage {
-                role: "user".to_string(),
-                content: vec![InputContentBlock::Text {
-                    text: "x".repeat(300_000),
-                }],
-            }],
-            system: Some("Keep the answer short.".to_string()),
-            tools: None,
-            tool_choice: None,
-            stream: false,
-            ..Default::default()
-        })
-        .await
-        .expect_err("oversized request should fail local context-window preflight");
-
-    assert!(matches!(error, ApiError::ContextWindowExceeded { .. }));
-    assert!(
-        state.lock().await.is_empty(),
-        "preflight failure should avoid any upstream HTTP request"
-    );
-}
-
-#[tokio::test]
-async fn send_message_accepts_full_chat_completions_endpoint_override() {
-    let state = Arc::new(Mutex::new(Vec::<CapturedRequest>::new()));
-    let body = concat!(
-        "{",
-        "\"id\":\"chatcmpl_full_endpoint\",",
-        "\"model\":\"grok-3\",",
-        "\"choices\":[{",
-        "\"message\":{\"role\":\"assistant\",\"content\":\"Endpoint override works\",\"tool_calls\":[]},",
-        "\"finish_reason\":\"stop\"",
-        "}],",
-        "\"usage\":{\"prompt_tokens\":7,\"completion_tokens\":3}",
-        "}"
-    );
-    let server = spawn_server(
-        state.clone(),
-        vec![http_response("200 OK", "application/json", body)],
-    )
-    .await;
-
-    let endpoint_url = format!("{}/chat/completions", server.base_url());
-    let client = OpenAiCompatClient::new("xai-test-key", OpenAiCompatConfig::xai())
-        .with_base_url(endpoint_url);
-    let response = client
-        .send_message(&sample_request(false))
-        .await
-        .expect("request should succeed");
-
-    assert_eq!(response.total_tokens(), 10);
-
-    let captured = state.lock().await;
-    let request = captured.first().expect("server should capture request");
-    assert_eq!(request.path, "/chat/completions");
-}
-
-#[tokio::test]
-async fn stream_message_normalizes_text_and_multiple_tool_calls() {
-    let state = Arc::new(Mutex::new(Vec::<CapturedRequest>::new()));
-    let sse = concat!(
-        "data: {\"id\":\"chatcmpl_stream\",\"model\":\"grok-3\",\"choices\":[{\"delta\":{\"content\":\"Hello\"}}]}\n\n",
-        "data: {\"id\":\"chatcmpl_stream\",\"choices\":[{\"delta\":{\"tool_calls\":[{\"index\":0,\"id\":\"call_1\",\"function\":{\"name\":\"weather\",\"arguments\":\"{\\\"city\\\":\\\"Paris\\\"}\"}},{\"index\":1,\"id\":\"call_2\",\"function\":{\"name\":\"clock\",\"arguments\":\"{\\\"zone\\\":\\\"UTC\\\"}\"}}]}}]}\n\n",
-        "data: {\"id\":\"chatcmpl_stream\",\"choices\":[{\"delta\":{},\"finish_reason\":\"tool_calls\"}]}\n\n",
-        "data: [DONE]\n\n"
-    );
-    let server = spawn_server(
-        state.clone(),
-        vec![http_response_with_headers(
-            "200 OK",
-            "text/event-stream",
-            sse,
-            &[("x-request-id", "req_grok_stream")],
-        )],
-    )
-    .await;
-
-    let client = OpenAiCompatClient::new("xai-test-key", OpenAiCompatConfig::xai())
-        .with_base_url(server.base_url());
-    let mut stream = client
-        .stream_message(&sample_request(false))
-        .await
-        .expect("stream should start");
-
-    assert_eq!(stream.request_id(), Some("req_grok_stream"));
-
-    let mut events = Vec::new();
-    while let Some(event) = stream.next_event().await.expect("event should parse") {
-        events.push(event);
-    }
-
-    assert!(matches!(events[0], StreamEvent::MessageStart(_)));
-    assert!(matches!(
-        events[1],
-        StreamEvent::ContentBlockStart(ContentBlockStartEvent {
-            content_block: OutputContentBlock::Text { .. },
-            ..
-        })
-    ));
-    assert!(matches!(
-        events[2],
-        StreamEvent::ContentBlockDelta(ContentBlockDeltaEvent {
-            delta: ContentBlockDelta::TextDelta { .. },
-            ..
-        })
-    ));
-    assert!(matches!(
-        events[3],
-        StreamEvent::ContentBlockStart(ContentBlockStartEvent {
-            index: 1,
-            content_block: OutputContentBlock::ToolUse { .. },
-        })
-    ));
-    assert!(matches!(
-        events[4],
-        StreamEvent::ContentBlockDelta(ContentBlockDeltaEvent {
-            index: 1,
-            delta: ContentBlockDelta::InputJsonDelta { .. },
-        })
-    ));
-    assert!(matches!(
-        events[5],
-        StreamEvent::ContentBlockStart(ContentBlockStartEvent {
-            index: 2,
-            content_block: OutputContentBlock::ToolUse { .. },
-        })
-    ));
-    assert!(matches!(
-        events[6],
-        StreamEvent::ContentBlockDelta(ContentBlockDeltaEvent {
-            index: 2,
-            delta: ContentBlockDelta::InputJsonDelta { .. },
-        })
-    ));
-    assert!(matches!(
-        events[7],
-        StreamEvent::ContentBlockStop(ContentBlockStopEvent { index: 1 })
-    ));
-    assert!(matches!(
-        events[8],
-        StreamEvent::ContentBlockStop(ContentBlockStopEvent { index: 2 })
-    ));
-    assert!(matches!(
-        events[9],
-        StreamEvent::ContentBlockStop(ContentBlockStopEvent { index: 0 })
-    ));
-    assert!(matches!(events[10], StreamEvent::MessageDelta(_)));
-    assert!(matches!(events[11], StreamEvent::MessageStop(_)));
-
-    let captured = state.lock().await;
-    let request = captured.first().expect("captured request");
-    assert_eq!(request.path, "/chat/completions");
-    assert!(request.body.contains("\"stream\":true"));
-}
-
-#[allow(clippy::await_holding_lock)]
-#[tokio::test]
-async fn openai_streaming_requests_opt_into_usage_chunks() {
-    let state = Arc::new(Mutex::new(Vec::<CapturedRequest>::new()));
-    let sse = concat!(
-        "data: {\"id\":\"chatcmpl_openai_stream\",\"model\":\"gpt-5\",\"choices\":[{\"delta\":{\"content\":\"Hi\"}}]}\n\n",
-        "data: {\"id\":\"chatcmpl_openai_stream\",\"choices\":[{\"delta\":{},\"finish_reason\":\"stop\"}]}\n\n",
-        "data: {\"id\":\"chatcmpl_openai_stream\",\"choices\":[],\"usage\":{\"prompt_tokens\":9,\"completion_tokens\":4}}\n\n",
-        "data: [DONE]\n\n"
-    );
-    let server = spawn_server(
-        state.clone(),
-        vec![http_response_with_headers(
-            "200 OK",
-            "text/event-stream",
-            sse,
-            &[("x-request-id", "req_openai_stream")],
-        )],
-    )
-    .await;
-
-    let client = OpenAiCompatClient::new("openai-test-key", OpenAiCompatConfig::openai())
-        .with_base_url(server.base_url());
-    let mut stream = client
-        .stream_message(&sample_request(false))
-        .await
-        .expect("stream should start");
-
-    assert_eq!(stream.request_id(), Some("req_openai_stream"));
-
-    let mut events = Vec::new();
-    while let Some(event) = stream.next_event().await.expect("event should parse") {
-        events.push(event);
-    }
-
-    assert!(matches!(events[0], StreamEvent::MessageStart(_)));
-    assert!(matches!(
-        events[1],
-        StreamEvent::ContentBlockStart(ContentBlockStartEvent {
-            content_block: OutputContentBlock::Text { .. },
-            ..
-        })
-    ));
-    assert!(matches!(
-        events[2],
-        StreamEvent::ContentBlockDelta(ContentBlockDeltaEvent {
-            delta: ContentBlockDelta::TextDelta { .. },
-            ..
-        })
-    ));
-    assert!(matches!(
-        events[3],
-        StreamEvent::ContentBlockStop(ContentBlockStopEvent { index: 0 })
-    ));
-    assert!(matches!(
-        events[4],
-        StreamEvent::MessageDelta(MessageDeltaEvent { .. })
-    ));
-    assert!(matches!(events[5], StreamEvent::MessageStop(_)));
-
-    match &events[4] {
-        StreamEvent::MessageDelta(MessageDeltaEvent { usage, .. }) => {
-            assert_eq!(usage.input_tokens, 9);
-            assert_eq!(usage.output_tokens, 4);
-        }
-        other => panic!("expected message delta, got {other:?}"),
-    }
-
-    let captured = state.lock().await;
-    let request = captured.first().expect("captured request");
-    assert_eq!(request.path, "/chat/completions");
-    let body: serde_json::Value = serde_json::from_str(&request.body).expect("json body");
-    assert_eq!(body["stream"], json!(true));
-    assert_eq!(body["stream_options"], json!({"include_usage": true}));
-}
-
-#[allow(clippy::await_holding_lock)]
-#[tokio::test]
-async fn provider_client_dispatches_xai_requests_from_env() {
-    let _lock = env_lock();
-    let _api_key = ScopedEnvVar::set("XAI_API_KEY", "xai-test-key");
-
-    let state = Arc::new(Mutex::new(Vec::<CapturedRequest>::new()));
-    let server = spawn_server(
-        state.clone(),
-        vec![http_response(
-            "200 OK",
-            "application/json",
-            "{\"id\":\"chatcmpl_provider\",\"model\":\"grok-3\",\"choices\":[{\"message\":{\"role\":\"assistant\",\"content\":\"Through provider client\",\"tool_calls\":[]},\"finish_reason\":\"stop\"}],\"usage\":{\"prompt_tokens\":9,\"completion_tokens\":4}}",
-        )],
-    )
-    .await;
-    let _base_url = ScopedEnvVar::set("XAI_BASE_URL", server.base_url());
-
-    let client =
-        ProviderClient::from_model("grok").expect("xAI provider client should be constructed");
-    assert!(matches!(client, ProviderClient::Xai(_)));
-
-    let response = client
-        .send_message(&sample_request(false))
-        .await
-        .expect("provider-dispatched request should succeed");
-
-    assert_eq!(response.total_tokens(), 13);
-
-    let captured = state.lock().await;
-    let request = captured.first().expect("captured request");
-    assert_eq!(request.path, "/chat/completions");
-    assert_eq!(
-        request.headers.get("authorization").map(String::as_str),
-        Some("Bearer xai-test-key")
-    );
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-struct CapturedRequest {
-    path: String,
-    headers: HashMap<String, String>,
-    body: String,
-}
-
-struct TestServer {
-    base_url: String,
-    join_handle: tokio::task::JoinHandle<()>,
-}
-
-impl TestServer {
-    fn base_url(&self) -> String {
-        self.base_url.clone()
-    }
-}
-
-impl Drop for TestServer {
-    fn drop(&mut self) {
-        self.join_handle.abort();
-    }
-}
-
-async fn spawn_server(
-    state: Arc<Mutex<Vec<CapturedRequest>>>,
-    responses: Vec<String>,
-) -> TestServer {
-    let listener = TcpListener::bind("127.0.0.1:0")
-        .await
-        .expect("listener should bind");
-    let address = listener.local_addr().expect("listener addr");
-    let join_handle = tokio::spawn(async move {
-        for response in responses {
-            let (mut socket, _) = listener.accept().await.expect("accept");
-            let mut buffer = Vec::new();
-            let mut header_end = None;
-            loop {
-                let mut chunk = [0_u8; 1024];
-                let read = socket.read(&mut chunk).await.expect("read request");
-                if read == 0 {
-                    break;
-                }
-                buffer.extend_from_slice(&chunk[..read]);
-                if let Some(position) = find_header_end(&buffer) {
-                    header_end = Some(position);
-                    break;
-                }
-            }
-
-            let header_end = header_end.expect("headers should exist");
-            let (header_bytes, remaining) = buffer.split_at(header_end);
-            let header_text = String::from_utf8(header_bytes.to_vec()).expect("utf8 headers");
-            let mut lines = header_text.split("\r\n");
-            let request_line = lines.next().expect("request line");
-            let path = request_line
-                .split_whitespace()
-                .nth(1)
-                .expect("path")
-                .to_string();
-            let mut headers = HashMap::new();
-            let mut content_length = 0_usize;
-            for line in lines {
-                if line.is_empty() {
-                    continue;
-                }
-                let (name, value) = line.split_once(':').expect("header");
-                let value = value.trim().to_string();
-                if name.eq_ignore_ascii_case("content-length") {
-                    content_length = value.parse().expect("content length");
-                }
-                headers.insert(name.to_ascii_lowercase(), value);
-            }
-
-            let mut body = remaining[4..].to_vec();
-            while body.len() < content_length {
-                let mut chunk = vec![0_u8; content_length - body.len()];
-                let read = socket.read(&mut chunk).await.expect("read body");
-                if read == 0 {
-                    break;
-                }
-                body.extend_from_slice(&chunk[..read]);
-            }
-
-            state.lock().await.push(CapturedRequest {
-                path,
-                headers,
-                body: String::from_utf8(body).expect("utf8 body"),
-            });
-
-            socket
-                .write_all(response.as_bytes())
-                .await
-                .expect("write response");
-        }
-    });
-
-    TestServer {
-        base_url: format!("http://{address}"),
-        join_handle,
-    }
-}
-
-fn find_header_end(bytes: &[u8]) -> Option<usize> {
-    bytes.windows(4).position(|window| window == b"\r\n\r\n")
-}
-
-fn http_response(status: &str, content_type: &str, body: &str) -> String {
-    http_response_with_headers(status, content_type, body, &[])
-}
-
-fn http_response_with_headers(
-    status: &str,
-    content_type: &str,
-    body: &str,
-    headers: &[(&str, &str)],
-) -> String {
-    let mut extra_headers = String::new();
-    for (name, value) in headers {
-        use std::fmt::Write as _;
-        write!(&mut extra_headers, "{name}: {value}\r\n").expect("header write");
-    }
-    format!(
-        "HTTP/1.1 {status}\r\ncontent-type: {content_type}\r\n{extra_headers}content-length: {}\r\nconnection: close\r\n\r\n{body}",
-        body.len()
-    )
-}
-
-fn sample_request(stream: bool) -> MessageRequest {
-    MessageRequest {
-        model: "grok-3".to_string(),
-        max_tokens: 64,
-        messages: vec![InputMessage {
-            role: "user".to_string(),
-            content: vec![InputContentBlock::Text {
-                text: "Say hello".to_string(),
-            }],
-        }],
-        system: Some("Use tools when needed".to_string()),
-        tools: Some(vec![ToolDefinition {
-            name: "weather".to_string(),
-            description: Some("Fetches weather".to_string()),
-            input_schema: json!({
-                "type": "object",
-                "properties": {"city": {"type": "string"}},
-                "required": ["city"]
-            }),
-        }]),
-        tool_choice: Some(ToolChoice::Auto),
-        stream,
-        ..Default::default()
-    }
-}
-
-fn env_lock() -> std::sync::MutexGuard<'static, ()> {
-    static LOCK: OnceLock<StdMutex<()>> = OnceLock::new();
-    LOCK.get_or_init(|| StdMutex::new(()))
-        .lock()
-        .unwrap_or_else(std::sync::PoisonError::into_inner)
-}
-
-struct ScopedEnvVar {
-    key: &'static str,
-    previous: Option<OsString>,
-}
-
-impl ScopedEnvVar {
-    fn set(key: &'static str, value: impl AsRef<std::ffi::OsStr>) -> Self {
-        let previous = std::env::var_os(key);
-        std::env::set_var(key, value);
-        Self { key, previous }
-    }
-}
-
-impl Drop for ScopedEnvVar {
-    fn drop(&mut self) {
-        match &self.previous {
-            Some(value) => std::env::set_var(self.key, value),
-            None => std::env::remove_var(self.key),
-        }
-    }
-}

rust/crates/api/tests/provider_client_integration.rs

@@ -1,88 +0,0 @@
-use std::ffi::OsString;
-use std::sync::{Mutex, OnceLock};
-
-use api::{read_xai_base_url, ApiError, AuthSource, ProviderClient, ProviderKind};
-
-#[test]
-fn provider_client_routes_grok_aliases_through_xai() {
-    let _lock = env_lock();
-    let _xai_api_key = EnvVarGuard::set("XAI_API_KEY", Some("xai-test-key"));
-
-    let client = ProviderClient::from_model("grok-mini").expect("grok alias should resolve");
-
-    assert_eq!(client.provider_kind(), ProviderKind::Xai);
-}
-
-#[test]
-fn provider_client_reports_missing_xai_credentials_for_grok_models() {
-    let _lock = env_lock();
-    let _xai_api_key = EnvVarGuard::set("XAI_API_KEY", None);
-
-    let error = ProviderClient::from_model("grok-3")
-        .expect_err("grok requests without XAI_API_KEY should fail fast");
-
-    match error {
-        ApiError::MissingCredentials {
-            provider, env_vars, ..
-        } => {
-            assert_eq!(provider, "xAI");
-            assert_eq!(env_vars, &["XAI_API_KEY"]);
-        }
-        other => panic!("expected missing xAI credentials, got {other:?}"),
-    }
-}
-
-#[test]
-fn provider_client_uses_explicit_anthropic_auth_without_env_lookup() {
-    let _lock = env_lock();
-    let _anthropic_api_key = EnvVarGuard::set("ANTHROPIC_API_KEY", None);
-    let _anthropic_auth_token = EnvVarGuard::set("ANTHROPIC_AUTH_TOKEN", None);
-
-    let client = ProviderClient::from_model_with_anthropic_auth(
-        "claude-sonnet-4-6",
-        Some(AuthSource::ApiKey("anthropic-test-key".to_string())),
-    )
-    .expect("explicit anthropic auth should avoid env lookup");
-
-    assert_eq!(client.provider_kind(), ProviderKind::Anthropic);
-}
-
-#[test]
-fn read_xai_base_url_prefers_env_override() {
-    let _lock = env_lock();
-    let _xai_base_url = EnvVarGuard::set("XAI_BASE_URL", Some("https://example.xai.test/v1"));
-
-    assert_eq!(read_xai_base_url(), "https://example.xai.test/v1");
-}
-
-fn env_lock() -> std::sync::MutexGuard<'static, ()> {
-    static LOCK: OnceLock<Mutex<()>> = OnceLock::new();
-    LOCK.get_or_init(|| Mutex::new(()))
-        .lock()
-        .unwrap_or_else(std::sync::PoisonError::into_inner)
-}
-
-struct EnvVarGuard {
-    key: &'static str,
-    original: Option<OsString>,
-}
-
-impl EnvVarGuard {
-    fn set(key: &'static str, value: Option<&str>) -> Self {
-        let original = std::env::var_os(key);
-        match value {
-            Some(value) => std::env::set_var(key, value),
-            None => std::env::remove_var(key),
-        }
-        Self { key, original }
-    }
-}
-
-impl Drop for EnvVarGuard {
-    fn drop(&mut self) {
-        match &self.original {
-            Some(value) => std::env::set_var(self.key, value),
-            None => std::env::remove_var(self.key),
-        }
-    }
-}

rust/crates/api/tests/proxy_integration.rs

@@ -1,173 +0,0 @@
-use std::ffi::OsString;
-use std::sync::{Mutex, OnceLock};
-
-use api::{build_http_client_with, ProxyConfig};
-
-fn env_lock() -> std::sync::MutexGuard<'static, ()> {
-    static LOCK: OnceLock<Mutex<()>> = OnceLock::new();
-    LOCK.get_or_init(|| Mutex::new(()))
-        .lock()
-        .unwrap_or_else(std::sync::PoisonError::into_inner)
-}
-
-struct EnvVarGuard {
-    key: &'static str,
-    original: Option<OsString>,
-}
-
-impl EnvVarGuard {
-    fn set(key: &'static str, value: Option<&str>) -> Self {
-        let original = std::env::var_os(key);
-        match value {
-            Some(value) => std::env::set_var(key, value),
-            None => std::env::remove_var(key),
-        }
-        Self { key, original }
-    }
-}
-
-impl Drop for EnvVarGuard {
-    fn drop(&mut self) {
-        match &self.original {
-            Some(value) => std::env::set_var(self.key, value),
-            None => std::env::remove_var(self.key),
-        }
-    }
-}
-
-#[test]
-fn proxy_config_from_env_reads_uppercase_proxy_vars() {
-    // given
-    let _lock = env_lock();
-    let _http = EnvVarGuard::set("HTTP_PROXY", Some("http://proxy.corp:3128"));
-    let _https = EnvVarGuard::set("HTTPS_PROXY", Some("http://secure.corp:3129"));
-    let _no = EnvVarGuard::set("NO_PROXY", Some("localhost,127.0.0.1"));
-    let _http_lower = EnvVarGuard::set("http_proxy", None);
-    let _https_lower = EnvVarGuard::set("https_proxy", None);
-    let _no_lower = EnvVarGuard::set("no_proxy", None);
-
-    // when
-    let config = ProxyConfig::from_env();
-
-    // then
-    assert_eq!(config.http_proxy.as_deref(), Some("http://proxy.corp:3128"));
-    assert_eq!(
-        config.https_proxy.as_deref(),
-        Some("http://secure.corp:3129")
-    );
-    assert_eq!(config.no_proxy.as_deref(), Some("localhost,127.0.0.1"));
-    assert!(config.proxy_url.is_none());
-    assert!(!config.is_empty());
-}
-
-#[test]
-fn proxy_config_from_env_reads_lowercase_proxy_vars() {
-    // given
-    let _lock = env_lock();
-    let _http = EnvVarGuard::set("HTTP_PROXY", None);
-    let _https = EnvVarGuard::set("HTTPS_PROXY", None);
-    let _no = EnvVarGuard::set("NO_PROXY", None);
-    let _http_lower = EnvVarGuard::set("http_proxy", Some("http://lower.corp:3128"));
-    let _https_lower = EnvVarGuard::set("https_proxy", Some("http://lower-secure.corp:3129"));
-    let _no_lower = EnvVarGuard::set("no_proxy", Some(".internal"));
-
-    // when
-    let config = ProxyConfig::from_env();
-
-    // then
-    assert_eq!(config.http_proxy.as_deref(), Some("http://lower.corp:3128"));
-    assert_eq!(
-        config.https_proxy.as_deref(),
-        Some("http://lower-secure.corp:3129")
-    );
-    assert_eq!(config.no_proxy.as_deref(), Some(".internal"));
-    assert!(!config.is_empty());
-}
-
-#[test]
-fn proxy_config_from_env_is_empty_when_no_vars_set() {
-    // given
-    let _lock = env_lock();
-    let _http = EnvVarGuard::set("HTTP_PROXY", None);
-    let _https = EnvVarGuard::set("HTTPS_PROXY", None);
-    let _no = EnvVarGuard::set("NO_PROXY", None);
-    let _http_lower = EnvVarGuard::set("http_proxy", None);
-    let _https_lower = EnvVarGuard::set("https_proxy", None);
-    let _no_lower = EnvVarGuard::set("no_proxy", None);
-
-    // when
-    let config = ProxyConfig::from_env();
-
-    // then
-    assert!(config.is_empty());
-    assert!(config.http_proxy.is_none());
-    assert!(config.https_proxy.is_none());
-    assert!(config.no_proxy.is_none());
-}
-
-#[test]
-fn proxy_config_from_env_treats_empty_values_as_unset() {
-    // given
-    let _lock = env_lock();
-    let _http = EnvVarGuard::set("HTTP_PROXY", Some(""));
-    let _https = EnvVarGuard::set("HTTPS_PROXY", Some(""));
-    let _http_lower = EnvVarGuard::set("http_proxy", Some(""));
-    let _https_lower = EnvVarGuard::set("https_proxy", Some(""));
-    let _no = EnvVarGuard::set("NO_PROXY", Some(""));
-    let _no_lower = EnvVarGuard::set("no_proxy", Some(""));
-
-    // when
-    let config = ProxyConfig::from_env();
-
-    // then
-    assert!(config.is_empty());
-}
-
-#[test]
-fn build_client_with_env_proxy_config_succeeds() {
-    // given
-    let _lock = env_lock();
-    let _http = EnvVarGuard::set("HTTP_PROXY", Some("http://proxy.corp:3128"));
-    let _https = EnvVarGuard::set("HTTPS_PROXY", Some("http://secure.corp:3129"));
-    let _no = EnvVarGuard::set("NO_PROXY", Some("localhost"));
-    let _http_lower = EnvVarGuard::set("http_proxy", None);
-    let _https_lower = EnvVarGuard::set("https_proxy", None);
-    let _no_lower = EnvVarGuard::set("no_proxy", None);
-    let config = ProxyConfig::from_env();
-
-    // when
-    let result = build_http_client_with(&config);
-
-    // then
-    assert!(result.is_ok());
-}
-
-#[test]
-fn build_client_with_proxy_url_config_succeeds() {
-    // given
-    let config = ProxyConfig::from_proxy_url("http://unified.corp:3128");
-
-    // when
-    let result = build_http_client_with(&config);
-
-    // then
-    assert!(result.is_ok());
-}
-
-#[test]
-fn proxy_config_from_env_prefers_uppercase_over_lowercase() {
-    // given
-    let _lock = env_lock();
-    let _http_upper = EnvVarGuard::set("HTTP_PROXY", Some("http://upper.corp:3128"));
-    let _http_lower = EnvVarGuard::set("http_proxy", Some("http://lower.corp:3128"));
-    let _https = EnvVarGuard::set("HTTPS_PROXY", None);
-    let _https_lower = EnvVarGuard::set("https_proxy", None);
-    let _no = EnvVarGuard::set("NO_PROXY", None);
-    let _no_lower = EnvVarGuard::set("no_proxy", None);
-
-    // when
-    let config = ProxyConfig::from_env();
-
-    // then
-    assert_eq!(config.http_proxy.as_deref(), Some("http://upper.corp:3128"));
-}

rust/crates/commands/Cargo.toml

@@ -9,6 +9,4 @@ publish.workspace = true
 workspace = true
 
 [dependencies]
-plugins = { path = "../plugins" }
 runtime = { path = "../runtime" }
-serde_json.workspace = true

rust/crates/compat-harness/src/lib.rs

@@ -18,12 +18,6 @@ impl UpstreamPaths {
         }
     }
 
-    /// Returns the repository root path.
-    #[must_use]
-    pub fn repo_root(&self) -> &Path {
-        &self.repo_root
-    }
-
     #[must_use]
     pub fn from_workspace_dir(workspace_dir: impl AsRef<Path>) -> Self {
         let workspace_dir = workspace_dir
@@ -80,7 +74,11 @@ fn upstream_repo_candidates(primary_repo_root: &Path) -> Vec<PathBuf> {
         candidates.push(ancestor.join("clawd-code"));
     }
 
-    candidates.push(primary_repo_root.join("reference-source").join("claw-code"));
+    candidates.push(
+        primary_repo_root
+            .join("reference-source")
+            .join("claw-code"),
+    );
     candidates.push(primary_repo_root.join("vendor").join("claw-code"));
 
     let mut deduped = Vec::new();

rust/crates/mock-anthropic-service/Cargo.toml

@@ -1,18 +0,0 @@
-[package]
-name = "mock-anthropic-service"
-version.workspace = true
-edition.workspace = true
-license.workspace = true
-publish.workspace = true
-
-[[bin]]
-name = "mock-anthropic-service"
-path = "src/main.rs"
-
-[dependencies]
-api = { path = "../api" }
-serde_json.workspace = true
-tokio = { version = "1", features = ["io-util", "macros", "net", "rt-multi-thread", "signal", "sync"] }
-
-[lints]
-workspace = true

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

@@ -1,34 +0,0 @@
-use std::env;
-
-use mock_anthropic_service::MockAnthropicService;
-
-#[tokio::main(flavor = "multi_thread")]
-async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let mut bind_addr = String::from("127.0.0.1:0");
-    let mut args = env::args().skip(1);
-    while let Some(arg) = args.next() {
-        match arg.as_str() {
-            "--bind" => {
-                bind_addr = args
-                    .next()
-                    .ok_or_else(|| "missing value for --bind".to_string())?;
-            }
-            flag if flag.starts_with("--bind=") => {
-                bind_addr = flag[7..].to_string();
-            }
-            "--help" | "-h" => {
-                println!("Usage: mock-anthropic-service [--bind HOST:PORT]");
-                return Ok(());
-            }
-            other => {
-                return Err(format!("unsupported argument: {other}").into());
-            }
-        }
-    }
-
-    let server = MockAnthropicService::spawn_on(&bind_addr).await?;
-    println!("MOCK_ANTHROPIC_BASE_URL={}", server.base_url());
-    tokio::signal::ctrl_c().await?;
-    drop(server);
-    Ok(())
-}

rust/crates/plugins/Cargo.toml

@@ -1,13 +0,0 @@
-[package]
-name = "plugins"
-version.workspace = true
-edition.workspace = true
-license.workspace = true
-publish.workspace = true
-
-[dependencies]
-serde = { version = "1", features = ["derive"] }
-serde_json.workspace = true
-
-[lints]
-workspace = true

rust/crates/plugins/bundled/example-bundled/.claude-plugin/plugin.json

@@ -1,10 +0,0 @@
-{
-  "name": "example-bundled",
-  "version": "0.1.0",
-  "description": "Example bundled plugin scaffold for the Rust plugin system",
-  "defaultEnabled": false,
-  "hooks": {
-    "PreToolUse": ["./hooks/pre.sh"],
-    "PostToolUse": ["./hooks/post.sh"]
-  }
-}

rust/crates/plugins/bundled/example-bundled/hooks/post.sh

@@ -1,2 +0,0 @@
-#!/bin/sh
-printf '%s\n' 'example bundled post hook'

rust/crates/plugins/bundled/example-bundled/hooks/pre.sh

@@ -1,2 +0,0 @@
-#!/bin/sh
-printf '%s\n' 'example bundled pre hook'

rust/crates/plugins/bundled/sample-hooks/.claude-plugin/plugin.json

@@ -1,10 +0,0 @@
-{
-  "name": "sample-hooks",
-  "version": "0.1.0",
-  "description": "Bundled sample plugin scaffold for hook integration tests.",
-  "defaultEnabled": false,
-  "hooks": {
-    "PreToolUse": ["./hooks/pre.sh"],
-    "PostToolUse": ["./hooks/post.sh"]
-  }
-}

rust/crates/plugins/bundled/sample-hooks/hooks/post.sh

@@ -1,2 +0,0 @@
-#!/bin/sh
-printf 'sample bundled post hook'

rust/crates/plugins/bundled/sample-hooks/hooks/pre.sh

@@ -1,2 +0,0 @@
-#!/bin/sh
-printf 'sample bundled pre hook'

rust/crates/plugins/src/hooks.rs

@@ -1,564 +0,0 @@
-use std::ffi::OsStr;
-use std::path::Path;
-use std::process::Command;
-
-use serde_json::json;
-
-use crate::{PluginError, PluginHooks, PluginRegistry};
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum HookEvent {
-    PreToolUse,
-    PostToolUse,
-    PostToolUseFailure,
-}
-
-impl HookEvent {
-    fn as_str(self) -> &'static str {
-        match self {
-            Self::PreToolUse => "PreToolUse",
-            Self::PostToolUse => "PostToolUse",
-            Self::PostToolUseFailure => "PostToolUseFailure",
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct HookRunResult {
-    denied: bool,
-    failed: bool,
-    messages: Vec<String>,
-}
-
-impl HookRunResult {
-    #[must_use]
-    pub fn allow(messages: Vec<String>) -> Self {
-        Self {
-            denied: false,
-            failed: false,
-            messages,
-        }
-    }
-
-    #[must_use]
-    pub fn is_denied(&self) -> bool {
-        self.denied
-    }
-
-    #[must_use]
-    pub fn is_failed(&self) -> bool {
-        self.failed
-    }
-
-    #[must_use]
-    pub fn messages(&self) -> &[String] {
-        &self.messages
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Default)]
-pub struct HookRunner {
-    hooks: PluginHooks,
-}
-
-impl HookRunner {
-    #[must_use]
-    pub fn new(hooks: PluginHooks) -> Self {
-        Self { hooks }
-    }
-
-    pub fn from_registry(plugin_registry: &PluginRegistry) -> Result<Self, PluginError> {
-        Ok(Self::new(plugin_registry.aggregated_hooks()?))
-    }
-
-    #[must_use]
-    pub fn run_pre_tool_use(&self, tool_name: &str, tool_input: &str) -> HookRunResult {
-        Self::run_commands(
-            HookEvent::PreToolUse,
-            &self.hooks.pre_tool_use,
-            tool_name,
-            tool_input,
-            None,
-            false,
-        )
-    }
-
-    #[must_use]
-    pub fn run_post_tool_use(
-        &self,
-        tool_name: &str,
-        tool_input: &str,
-        tool_output: &str,
-        is_error: bool,
-    ) -> HookRunResult {
-        Self::run_commands(
-            HookEvent::PostToolUse,
-            &self.hooks.post_tool_use,
-            tool_name,
-            tool_input,
-            Some(tool_output),
-            is_error,
-        )
-    }
-
-    #[must_use]
-    pub fn run_post_tool_use_failure(
-        &self,
-        tool_name: &str,
-        tool_input: &str,
-        tool_error: &str,
-    ) -> HookRunResult {
-        Self::run_commands(
-            HookEvent::PostToolUseFailure,
-            &self.hooks.post_tool_use_failure,
-            tool_name,
-            tool_input,
-            Some(tool_error),
-            true,
-        )
-    }
-
-    fn run_commands(
-        event: HookEvent,
-        commands: &[String],
-        tool_name: &str,
-        tool_input: &str,
-        tool_output: Option<&str>,
-        is_error: bool,
-    ) -> HookRunResult {
-        if commands.is_empty() {
-            return HookRunResult::allow(Vec::new());
-        }
-
-        let payload = hook_payload(event, tool_name, tool_input, tool_output, is_error).to_string();
-
-        let mut messages = Vec::new();
-
-        for command in commands {
-            match Self::run_command(
-                command,
-                event,
-                tool_name,
-                tool_input,
-                tool_output,
-                is_error,
-                &payload,
-            ) {
-                HookCommandOutcome::Allow { message } => {
-                    if let Some(message) = message {
-                        messages.push(message);
-                    }
-                }
-                HookCommandOutcome::Deny { message } => {
-                    messages.push(message.unwrap_or_else(|| {
-                        format!("{} hook denied tool `{tool_name}`", event.as_str())
-                    }));
-                    return HookRunResult {
-                        denied: true,
-                        failed: false,
-                        messages,
-                    };
-                }
-                HookCommandOutcome::Failed { message } => {
-                    messages.push(message);
-                    return HookRunResult {
-                        denied: false,
-                        failed: true,
-                        messages,
-                    };
-                }
-            }
-        }
-
-        HookRunResult::allow(messages)
-    }
-
-    #[allow(clippy::too_many_arguments)]
-    fn run_command(
-        command: &str,
-        event: HookEvent,
-        tool_name: &str,
-        tool_input: &str,
-        tool_output: Option<&str>,
-        is_error: bool,
-        payload: &str,
-    ) -> HookCommandOutcome {
-        let mut child = shell_command(command);
-        child.stdin(std::process::Stdio::piped());
-        child.stdout(std::process::Stdio::piped());
-        child.stderr(std::process::Stdio::piped());
-        child.env("HOOK_EVENT", event.as_str());
-        child.env("HOOK_TOOL_NAME", tool_name);
-        child.env("HOOK_TOOL_INPUT", tool_input);
-        child.env("HOOK_TOOL_IS_ERROR", if is_error { "1" } else { "0" });
-        if let Some(tool_output) = tool_output {
-            child.env("HOOK_TOOL_OUTPUT", tool_output);
-        }
-
-        match child.output_with_stdin(payload.as_bytes()) {
-            Ok(output) => {
-                let stdout = String::from_utf8_lossy(&output.stdout).trim().to_string();
-                let stderr = String::from_utf8_lossy(&output.stderr).trim().to_string();
-                let message = (!stdout.is_empty()).then_some(stdout);
-                match output.status.code() {
-                    Some(0) => HookCommandOutcome::Allow { message },
-                    Some(2) => HookCommandOutcome::Deny { message },
-                    Some(code) => HookCommandOutcome::Failed {
-                        message: format_hook_warning(
-                            command,
-                            code,
-                            message.as_deref(),
-                            stderr.as_str(),
-                        ),
-                    },
-                    None => HookCommandOutcome::Failed {
-                        message: format!(
-                            "{} hook `{command}` terminated by signal while handling `{tool_name}`",
-                            event.as_str()
-                        ),
-                    },
-                }
-            }
-            Err(error) => HookCommandOutcome::Failed {
-                message: format!(
-                    "{} hook `{command}` failed to start for `{tool_name}`: {error}",
-                    event.as_str()
-                ),
-            },
-        }
-    }
-}
-
-enum HookCommandOutcome {
-    Allow { message: Option<String> },
-    Deny { message: Option<String> },
-    Failed { message: String },
-}
-
-fn hook_payload(
-    event: HookEvent,
-    tool_name: &str,
-    tool_input: &str,
-    tool_output: Option<&str>,
-    is_error: bool,
-) -> serde_json::Value {
-    match event {
-        HookEvent::PostToolUseFailure => json!({
-            "hook_event_name": event.as_str(),
-            "tool_name": tool_name,
-            "tool_input": parse_tool_input(tool_input),
-            "tool_input_json": tool_input,
-            "tool_error": tool_output,
-            "tool_result_is_error": true,
-        }),
-        _ => json!({
-            "hook_event_name": event.as_str(),
-            "tool_name": tool_name,
-            "tool_input": parse_tool_input(tool_input),
-            "tool_input_json": tool_input,
-            "tool_output": tool_output,
-            "tool_result_is_error": is_error,
-        }),
-    }
-}
-
-fn parse_tool_input(tool_input: &str) -> serde_json::Value {
-    serde_json::from_str(tool_input).unwrap_or_else(|_| json!({ "raw": tool_input }))
-}
-
-fn format_hook_warning(command: &str, code: i32, stdout: Option<&str>, stderr: &str) -> String {
-    let mut message = format!("Hook `{command}` exited with status {code}");
-    if let Some(stdout) = stdout.filter(|stdout| !stdout.is_empty()) {
-        message.push_str(": ");
-        message.push_str(stdout);
-    } else if !stderr.is_empty() {
-        message.push_str(": ");
-        message.push_str(stderr);
-    }
-    message
-}
-
-fn shell_command(command: &str) -> CommandWithStdin {
-    #[cfg(windows)]
-    let command_builder = {
-        let mut command_builder = Command::new("cmd");
-        command_builder.arg("/C").arg(command);
-        CommandWithStdin::new(command_builder)
-    };
-
-    #[cfg(not(windows))]
-    let command_builder = if Path::new(command).exists() {
-        let mut command_builder = Command::new("sh");
-        command_builder.arg(command);
-        CommandWithStdin::new(command_builder)
-    } else {
-        let mut command_builder = Command::new("sh");
-        command_builder.arg("-lc").arg(command);
-        CommandWithStdin::new(command_builder)
-    };
-
-    command_builder
-}
-
-struct CommandWithStdin {
-    command: Command,
-}
-
-impl CommandWithStdin {
-    fn new(command: Command) -> Self {
-        Self { command }
-    }
-
-    fn stdin(&mut self, cfg: std::process::Stdio) -> &mut Self {
-        self.command.stdin(cfg);
-        self
-    }
-
-    fn stdout(&mut self, cfg: std::process::Stdio) -> &mut Self {
-        self.command.stdout(cfg);
-        self
-    }
-
-    fn stderr(&mut self, cfg: std::process::Stdio) -> &mut Self {
-        self.command.stderr(cfg);
-        self
-    }
-
-    fn env<K, V>(&mut self, key: K, value: V) -> &mut Self
-    where
-        K: AsRef<OsStr>,
-        V: AsRef<OsStr>,
-    {
-        self.command.env(key, value);
-        self
-    }
-
-    fn output_with_stdin(&mut self, stdin: &[u8]) -> std::io::Result<std::process::Output> {
-        let mut child = self.command.spawn()?;
-        if let Some(mut child_stdin) = child.stdin.take() {
-            use std::io::Write as _;
-            // Tolerate BrokenPipe: a hook script that runs to completion
-            // (or exits early without reading stdin) closes its stdin
-            // before the parent finishes writing the JSON payload, and
-            // the kernel raises EPIPE on the parent's write_all. That is
-            // not a hook failure — the child still exited cleanly and we
-            // still need to wait_with_output() to capture stdout/stderr
-            // and the real exit code. Other write errors (e.g. EIO,
-            // permission, OOM) still propagate.
-            //
-            // This was the root cause of the Linux CI flake on
-            // hooks::tests::collects_and_runs_hooks_from_enabled_plugins
-            // (ROADMAP #25, runs 24120271422 / 24120538408 / 24121392171
-            // / 24121776826): the test hook scripts run in microseconds
-            // and the parent's stdin write races against child exit.
-            // macOS pipes happen to buffer the small payload before the
-            // child exits; Linux pipes do not, so the race shows up
-            // deterministically on ubuntu runners.
-            match child_stdin.write_all(stdin) {
-                Ok(()) => {}
-                Err(error) if error.kind() == std::io::ErrorKind::BrokenPipe => {}
-                Err(error) => return Err(error),
-            }
-        }
-        child.wait_with_output()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::{HookRunResult, HookRunner};
-    use crate::{PluginManager, PluginManagerConfig};
-    use std::fs;
-    use std::path::{Path, PathBuf};
-    use std::time::{SystemTime, UNIX_EPOCH};
-
-    fn temp_dir(label: &str) -> PathBuf {
-        let nanos = SystemTime::now()
-            .duration_since(UNIX_EPOCH)
-            .expect("time should be after epoch")
-            .as_nanos();
-        std::env::temp_dir().join(format!("plugins-hook-runner-{label}-{nanos}"))
-    }
-
-    fn make_executable(path: &Path) {
-        #[cfg(unix)]
-        {
-            use std::os::unix::fs::PermissionsExt;
-            let perms = fs::Permissions::from_mode(0o755);
-            fs::set_permissions(path, perms)
-                .unwrap_or_else(|e| panic!("chmod +x {}: {e}", path.display()));
-        }
-        #[cfg(not(unix))]
-        let _ = path;
-    }
-
-    fn write_hook_plugin(
-        root: &Path,
-        name: &str,
-        pre_message: &str,
-        post_message: &str,
-        failure_message: &str,
-    ) {
-        fs::create_dir_all(root.join(".claude-plugin")).expect("manifest dir");
-        fs::create_dir_all(root.join("hooks")).expect("hooks dir");
-
-        let pre_path = root.join("hooks").join("pre.sh");
-        fs::write(
-            &pre_path,
-            format!("#!/bin/sh\nprintf '%s\\n' '{pre_message}'\n"),
-        )
-        .expect("write pre hook");
-        make_executable(&pre_path);
-
-        let post_path = root.join("hooks").join("post.sh");
-        fs::write(
-            &post_path,
-            format!("#!/bin/sh\nprintf '%s\\n' '{post_message}'\n"),
-        )
-        .expect("write post hook");
-        make_executable(&post_path);
-
-        let failure_path = root.join("hooks").join("failure.sh");
-        fs::write(
-            &failure_path,
-            format!("#!/bin/sh\nprintf '%s\\n' '{failure_message}'\n"),
-        )
-        .expect("write failure hook");
-        make_executable(&failure_path);
-        fs::write(
-            root.join(".claude-plugin").join("plugin.json"),
-            format!(
-                "{{\n  \"name\": \"{name}\",\n  \"version\": \"1.0.0\",\n  \"description\": \"hook plugin\",\n  \"hooks\": {{\n    \"PreToolUse\": [\"./hooks/pre.sh\"],\n    \"PostToolUse\": [\"./hooks/post.sh\"],\n    \"PostToolUseFailure\": [\"./hooks/failure.sh\"]\n  }}\n}}"
-            ),
-        )
-        .expect("write plugin manifest");
-    }
-
-    #[test]
-    fn collects_and_runs_hooks_from_enabled_plugins() {
-        // given
-        let config_home = temp_dir("config");
-        let first_source_root = temp_dir("source-a");
-        let second_source_root = temp_dir("source-b");
-        write_hook_plugin(
-            &first_source_root,
-            "first",
-            "plugin pre one",
-            "plugin post one",
-            "plugin failure one",
-        );
-        write_hook_plugin(
-            &second_source_root,
-            "second",
-            "plugin pre two",
-            "plugin post two",
-            "plugin failure two",
-        );
-
-        let mut manager = PluginManager::new(PluginManagerConfig::new(&config_home));
-        manager
-            .install(first_source_root.to_str().expect("utf8 path"))
-            .expect("first plugin install should succeed");
-        manager
-            .install(second_source_root.to_str().expect("utf8 path"))
-            .expect("second plugin install should succeed");
-        let registry = manager.plugin_registry().expect("registry should build");
-
-        // when
-        let runner = HookRunner::from_registry(&registry).expect("plugin hooks should load");
-
-        // then
-        assert_eq!(
-            runner.run_pre_tool_use("Read", r#"{"path":"README.md"}"#),
-            HookRunResult::allow(vec![
-                "plugin pre one".to_string(),
-                "plugin pre two".to_string(),
-            ])
-        );
-        assert_eq!(
-            runner.run_post_tool_use("Read", r#"{"path":"README.md"}"#, "ok", false),
-            HookRunResult::allow(vec![
-                "plugin post one".to_string(),
-                "plugin post two".to_string(),
-            ])
-        );
-        assert_eq!(
-            runner.run_post_tool_use_failure("Read", r#"{"path":"README.md"}"#, "tool failed",),
-            HookRunResult::allow(vec![
-                "plugin failure one".to_string(),
-                "plugin failure two".to_string(),
-            ])
-        );
-
-        let _ = fs::remove_dir_all(config_home);
-        let _ = fs::remove_dir_all(first_source_root);
-        let _ = fs::remove_dir_all(second_source_root);
-    }
-
-    #[test]
-    fn pre_tool_use_denies_when_plugin_hook_exits_two() {
-        // given
-        let runner = HookRunner::new(crate::PluginHooks {
-            pre_tool_use: vec!["printf 'blocked by plugin'; exit 2".to_string()],
-            post_tool_use: Vec::new(),
-            post_tool_use_failure: Vec::new(),
-        });
-
-        // when
-        let result = runner.run_pre_tool_use("Bash", r#"{"command":"pwd"}"#);
-
-        // then
-        assert!(result.is_denied());
-        assert_eq!(result.messages(), &["blocked by plugin".to_string()]);
-    }
-
-    #[test]
-    fn propagates_plugin_hook_failures() {
-        // given
-        let runner = HookRunner::new(crate::PluginHooks {
-            pre_tool_use: vec![
-                "printf 'broken plugin hook'; exit 1".to_string(),
-                "printf 'later plugin hook'".to_string(),
-            ],
-            post_tool_use: Vec::new(),
-            post_tool_use_failure: Vec::new(),
-        });
-
-        // when
-        let result = runner.run_pre_tool_use("Bash", r#"{"command":"pwd"}"#);
-
-        // then
-        assert!(result.is_failed());
-        assert!(result
-            .messages()
-            .iter()
-            .any(|message| message.contains("broken plugin hook")));
-        assert!(!result
-            .messages()
-            .iter()
-            .any(|message| message == "later plugin hook"));
-    }
-
-    #[test]
-    #[cfg(unix)]
-    fn generated_hook_scripts_are_executable() {
-        use std::os::unix::fs::PermissionsExt;
-
-        // given
-        let root = temp_dir("exec-guard");
-        write_hook_plugin(&root, "exec-check", "pre", "post", "fail");
-
-        // then
-        for script in ["pre.sh", "post.sh", "failure.sh"] {
-            let path = root.join("hooks").join(script);
-            let mode = fs::metadata(&path)
-                .unwrap_or_else(|e| panic!("{script} metadata: {e}"))
-                .permissions()
-                .mode();
-            assert!(
-                mode & 0o111 != 0,
-                "{script} must have at least one execute bit set, got mode {mode:#o}"
-            );
-        }
-    }
-}

rust/crates/plugins/src/test_isolation.rs

@@ -1,73 +0,0 @@
-// Test isolation utilities for plugin tests
-// ROADMAP #41: Stop ambient plugin state from skewing CLI regression checks
-
-use std::env;
-use std::path::PathBuf;
-use std::sync::atomic::{AtomicU64, Ordering};
-use std::sync::Mutex;
-
-static TEST_COUNTER: AtomicU64 = AtomicU64::new(0);
-static ENV_LOCK: Mutex<()> = Mutex::new(());
-
-/// Lock for test environment isolation
-pub struct EnvLock {
-    _guard: std::sync::MutexGuard<'static, ()>,
-    temp_home: PathBuf,
-}
-
-impl EnvLock {
-    /// Acquire environment lock for test isolation
-    pub fn lock() -> Self {
-        let guard = ENV_LOCK.lock().unwrap();
-        let count = TEST_COUNTER.fetch_add(1, Ordering::SeqCst);
-        let temp_home = std::env::temp_dir().join(format!("plugin-test-{count}"));
-
-        // Set up isolated environment
-        std::fs::create_dir_all(&temp_home).ok();
-        std::fs::create_dir_all(temp_home.join(".claude/plugins/installed")).ok();
-        std::fs::create_dir_all(temp_home.join(".config")).ok();
-
-        // Redirect HOME and XDG_CONFIG_HOME to temp directory
-        env::set_var("HOME", &temp_home);
-        env::set_var("XDG_CONFIG_HOME", temp_home.join(".config"));
-        env::set_var("XDG_DATA_HOME", temp_home.join(".local/share"));
-
-        EnvLock {
-            _guard: guard,
-            temp_home,
-        }
-    }
-
-    /// Get the temporary home directory for this test
-    #[must_use]
-    pub fn temp_home(&self) -> &PathBuf {
-        &self.temp_home
-    }
-}
-
-impl Drop for EnvLock {
-    fn drop(&mut self) {
-        // Cleanup temp directory
-        std::fs::remove_dir_all(&self.temp_home).ok();
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_env_lock_creates_isolated_home() {
-        let lock = EnvLock::lock();
-        let home = env::var("HOME").unwrap();
-        assert!(home.contains("plugin-test-"));
-        assert_eq!(home, lock.temp_home().to_str().unwrap());
-    }
-
-    #[test]
-    fn test_env_lock_creates_plugin_directories() {
-        let lock = EnvLock::lock();
-        let plugins_dir = lock.temp_home().join(".claude/plugins/installed");
-        assert!(plugins_dir.exists());
-    }
-}

rust/crates/runtime/Cargo.toml

@@ -8,12 +8,10 @@ publish.workspace = true
 [dependencies]
 sha2 = "0.10"
 glob = "0.3"
-plugins = { path = "../plugins" }
 regex = "1"
 serde = { version = "1", features = ["derive"] }
-serde_json.workspace = true
-telemetry = { path = "../telemetry" }
-tokio = { version = "1", features = ["io-std", "io-util", "macros", "process", "rt", "rt-multi-thread", "time"] }
+serde_json = "1"
+tokio = { version = "1", features = ["io-util", "macros", "process", "rt", "rt-multi-thread", "time"] }
 walkdir = "2"
 
 [lints]

rust/crates/runtime/src/approval_tokens.rs

@@ -1,502 +0,0 @@
-use std::collections::BTreeMap;
-
-/// Machine-readable policy exception scope that an approval token may override.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct ApprovalScope {
-    pub policy: String,
-    pub action: String,
-    pub repository: Option<String>,
-    pub branch: Option<String>,
-}
-
-impl ApprovalScope {
-    #[must_use]
-    pub fn new(policy: impl Into<String>, action: impl Into<String>) -> Self {
-        Self {
-            policy: policy.into(),
-            action: action.into(),
-            repository: None,
-            branch: None,
-        }
-    }
-
-    #[must_use]
-    pub fn with_repository(mut self, repository: impl Into<String>) -> Self {
-        self.repository = Some(repository.into());
-        self
-    }
-
-    #[must_use]
-    pub fn with_branch(mut self, branch: impl Into<String>) -> Self {
-        self.branch = Some(branch.into());
-        self
-    }
-}
-
-/// Actor/session hop recorded when an approval is delegated or consumed.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct ApprovalDelegationHop {
-    pub actor: String,
-    pub session_id: Option<String>,
-    pub reason: String,
-}
-
-impl ApprovalDelegationHop {
-    #[must_use]
-    pub fn new(actor: impl Into<String>, reason: impl Into<String>) -> Self {
-        Self {
-            actor: actor.into(),
-            session_id: None,
-            reason: reason.into(),
-        }
-    }
-
-    #[must_use]
-    pub fn with_session_id(mut self, session_id: impl Into<String>) -> Self {
-        self.session_id = Some(session_id.into());
-        self
-    }
-}
-
-/// Current lifecycle state for a policy-exception approval token.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum ApprovalTokenStatus {
-    Pending,
-    Granted,
-    Consumed,
-    Expired,
-    Revoked,
-}
-
-impl ApprovalTokenStatus {
-    #[must_use]
-    pub fn as_str(self) -> &'static str {
-        match self {
-            Self::Pending => "approval_pending",
-            Self::Granted => "approval_granted",
-            Self::Consumed => "approval_consumed",
-            Self::Expired => "approval_expired",
-            Self::Revoked => "approval_revoked",
-        }
-    }
-}
-
-/// Typed policy errors returned when a token cannot authorize a blocked action.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum ApprovalTokenError {
-    NoApproval,
-    ApprovalPending,
-    ApprovalExpired,
-    ApprovalRevoked,
-    ApprovalAlreadyConsumed,
-    ScopeMismatch {
-        expected: Box<ApprovalScope>,
-        actual: Box<ApprovalScope>,
-    },
-    UnauthorizedDelegate {
-        expected: String,
-        actual: String,
-    },
-}
-
-impl ApprovalTokenError {
-    #[must_use]
-    pub fn as_str(&self) -> &'static str {
-        match self {
-            Self::NoApproval => "no_approval",
-            Self::ApprovalPending => "approval_pending",
-            Self::ApprovalExpired => "approval_expired",
-            Self::ApprovalRevoked => "approval_revoked",
-            Self::ApprovalAlreadyConsumed => "approval_already_consumed",
-            Self::ScopeMismatch { .. } => "approval_scope_mismatch",
-            Self::UnauthorizedDelegate { .. } => "approval_unauthorized_delegate",
-        }
-    }
-}
-
-/// Approval grant bound to a policy/action scope, approving owner, and executor.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct ApprovalTokenGrant {
-    pub token: String,
-    pub scope: ApprovalScope,
-    pub approving_actor: String,
-    pub approved_executor: String,
-    pub status: ApprovalTokenStatus,
-    pub expires_at_epoch_seconds: Option<u64>,
-    pub max_uses: u32,
-    pub uses: u32,
-    delegation_chain: Vec<ApprovalDelegationHop>,
-}
-
-impl ApprovalTokenGrant {
-    #[must_use]
-    pub fn pending(
-        token: impl Into<String>,
-        scope: ApprovalScope,
-        approving_actor: impl Into<String>,
-        approved_executor: impl Into<String>,
-    ) -> Self {
-        Self {
-            token: token.into(),
-            scope,
-            approving_actor: approving_actor.into(),
-            approved_executor: approved_executor.into(),
-            status: ApprovalTokenStatus::Pending,
-            expires_at_epoch_seconds: None,
-            max_uses: 1,
-            uses: 0,
-            delegation_chain: Vec::new(),
-        }
-    }
-
-    #[must_use]
-    pub fn granted(
-        token: impl Into<String>,
-        scope: ApprovalScope,
-        approving_actor: impl Into<String>,
-        approved_executor: impl Into<String>,
-    ) -> Self {
-        Self::pending(token, scope, approving_actor, approved_executor).approve()
-    }
-
-    #[must_use]
-    pub fn approve(mut self) -> Self {
-        self.status = ApprovalTokenStatus::Granted;
-        self
-    }
-
-    #[must_use]
-    pub fn expires_at(mut self, epoch_seconds: u64) -> Self {
-        self.expires_at_epoch_seconds = Some(epoch_seconds);
-        self
-    }
-
-    #[must_use]
-    pub fn with_max_uses(mut self, max_uses: u32) -> Self {
-        self.max_uses = max_uses.max(1);
-        self
-    }
-
-    #[must_use]
-    pub fn with_delegation_hop(mut self, hop: ApprovalDelegationHop) -> Self {
-        self.delegation_chain.push(hop);
-        self
-    }
-
-    #[must_use]
-    pub fn delegation_chain(&self) -> &[ApprovalDelegationHop] {
-        &self.delegation_chain
-    }
-}
-
-/// Auditable result of verifying or consuming an approval token.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct ApprovalTokenAudit {
-    pub token: String,
-    pub scope: ApprovalScope,
-    pub approving_actor: String,
-    pub executing_actor: String,
-    pub status: ApprovalTokenStatus,
-    pub delegated_execution: bool,
-    pub delegation_chain: Vec<ApprovalDelegationHop>,
-    pub uses: u32,
-    pub max_uses: u32,
-}
-
-/// In-memory approval-token ledger with one-time-use and replay protection.
-#[derive(Debug, Clone, PartialEq, Eq, Default)]
-pub struct ApprovalTokenLedger {
-    grants: BTreeMap<String, ApprovalTokenGrant>,
-}
-
-impl ApprovalTokenLedger {
-    #[must_use]
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    pub fn insert(&mut self, grant: ApprovalTokenGrant) {
-        self.grants.insert(grant.token.clone(), grant);
-    }
-
-    #[must_use]
-    pub fn get(&self, token: &str) -> Option<&ApprovalTokenGrant> {
-        self.grants.get(token)
-    }
-
-    pub fn revoke(&mut self, token: &str) -> Result<ApprovalTokenAudit, ApprovalTokenError> {
-        let grant = self
-            .grants
-            .get_mut(token)
-            .ok_or(ApprovalTokenError::NoApproval)?;
-        grant.status = ApprovalTokenStatus::Revoked;
-        Ok(Self::audit_for(grant, &grant.approved_executor))
-    }
-
-    pub fn verify(
-        &self,
-        token: &str,
-        scope: &ApprovalScope,
-        executing_actor: &str,
-        now_epoch_seconds: u64,
-    ) -> Result<ApprovalTokenAudit, ApprovalTokenError> {
-        let grant = self
-            .grants
-            .get(token)
-            .ok_or(ApprovalTokenError::NoApproval)?;
-        Self::validate_grant(grant, scope, executing_actor, now_epoch_seconds)?;
-        Ok(Self::audit_for(grant, executing_actor))
-    }
-
-    pub fn consume(
-        &mut self,
-        token: &str,
-        scope: &ApprovalScope,
-        executing_actor: &str,
-        now_epoch_seconds: u64,
-    ) -> Result<ApprovalTokenAudit, ApprovalTokenError> {
-        let grant = self
-            .grants
-            .get_mut(token)
-            .ok_or(ApprovalTokenError::NoApproval)?;
-        Self::validate_grant(grant, scope, executing_actor, now_epoch_seconds)?;
-        grant.uses += 1;
-        if grant.uses >= grant.max_uses {
-            grant.status = ApprovalTokenStatus::Consumed;
-        }
-        Ok(Self::audit_for(grant, executing_actor))
-    }
-
-    fn validate_grant(
-        grant: &ApprovalTokenGrant,
-        scope: &ApprovalScope,
-        executing_actor: &str,
-        now_epoch_seconds: u64,
-    ) -> Result<(), ApprovalTokenError> {
-        match grant.status {
-            ApprovalTokenStatus::Pending => return Err(ApprovalTokenError::ApprovalPending),
-            ApprovalTokenStatus::Consumed => {
-                return Err(ApprovalTokenError::ApprovalAlreadyConsumed)
-            }
-            ApprovalTokenStatus::Expired => return Err(ApprovalTokenError::ApprovalExpired),
-            ApprovalTokenStatus::Revoked => return Err(ApprovalTokenError::ApprovalRevoked),
-            ApprovalTokenStatus::Granted => {}
-        }
-
-        if grant
-            .expires_at_epoch_seconds
-            .is_some_and(|expires_at| now_epoch_seconds > expires_at)
-        {
-            return Err(ApprovalTokenError::ApprovalExpired);
-        }
-
-        if grant.uses >= grant.max_uses {
-            return Err(ApprovalTokenError::ApprovalAlreadyConsumed);
-        }
-
-        if grant.scope != *scope {
-            return Err(ApprovalTokenError::ScopeMismatch {
-                expected: Box::new(grant.scope.clone()),
-                actual: Box::new(scope.clone()),
-            });
-        }
-
-        if grant.approved_executor != executing_actor {
-            return Err(ApprovalTokenError::UnauthorizedDelegate {
-                expected: grant.approved_executor.clone(),
-                actual: executing_actor.to_string(),
-            });
-        }
-
-        Ok(())
-    }
-
-    fn audit_for(grant: &ApprovalTokenGrant, executing_actor: &str) -> ApprovalTokenAudit {
-        let mut delegation_chain = grant.delegation_chain.clone();
-        if delegation_chain.is_empty() {
-            delegation_chain.push(ApprovalDelegationHop::new(
-                grant.approving_actor.clone(),
-                "approval granted",
-            ));
-        }
-        if grant.approving_actor != executing_actor
-            && !delegation_chain
-                .iter()
-                .any(|hop| hop.actor == executing_actor)
-        {
-            delegation_chain.push(ApprovalDelegationHop::new(
-                executing_actor.to_string(),
-                "delegated execution",
-            ));
-        }
-
-        ApprovalTokenAudit {
-            token: grant.token.clone(),
-            scope: grant.scope.clone(),
-            approving_actor: grant.approving_actor.clone(),
-            executing_actor: executing_actor.to_string(),
-            status: grant.status,
-            delegated_execution: grant.approving_actor != executing_actor,
-            delegation_chain,
-            uses: grant.uses,
-            max_uses: grant.max_uses,
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::{
-        ApprovalDelegationHop, ApprovalScope, ApprovalTokenError, ApprovalTokenGrant,
-        ApprovalTokenLedger, ApprovalTokenStatus,
-    };
-
-    #[test]
-    fn approval_token_blocks_until_owner_grants_policy_exception() {
-        let mut ledger = ApprovalTokenLedger::new();
-        let scope = ApprovalScope::new("main_push_forbidden", "git push")
-            .with_repository("sisyphus/claw-code")
-            .with_branch("main");
-        ledger.insert(ApprovalTokenGrant::pending(
-            "tok-pending",
-            scope.clone(),
-            "repo-owner",
-            "release-bot",
-        ));
-
-        assert!(matches!(
-            ledger.verify("tok-missing", &scope, "release-bot", 10),
-            Err(ApprovalTokenError::NoApproval)
-        ));
-        assert!(matches!(
-            ledger.verify("tok-pending", &scope, "release-bot", 10),
-            Err(ApprovalTokenError::ApprovalPending)
-        ));
-
-        ledger.insert(ApprovalTokenGrant::granted(
-            "tok-granted",
-            scope.clone(),
-            "repo-owner",
-            "release-bot",
-        ));
-        let audit = ledger
-            .verify("tok-granted", &scope, "release-bot", 10)
-            .expect("owner approval should verify");
-
-        assert_eq!(audit.status, ApprovalTokenStatus::Granted);
-        assert_eq!(audit.approving_actor, "repo-owner");
-        assert_eq!(audit.executing_actor, "release-bot");
-        assert!(audit.delegated_execution);
-    }
-
-    #[test]
-    fn approval_token_is_one_time_use_and_rejects_replay() {
-        let mut ledger = ApprovalTokenLedger::new();
-        let scope = ApprovalScope::new("release_requires_owner", "release publish")
-            .with_repository("sisyphus/claw-code");
-        ledger.insert(ApprovalTokenGrant::granted(
-            "tok-once",
-            scope.clone(),
-            "owner",
-            "release-bot",
-        ));
-
-        let first = ledger
-            .consume("tok-once", &scope, "release-bot", 10)
-            .expect("first use should consume token");
-        assert_eq!(first.status, ApprovalTokenStatus::Consumed);
-        assert_eq!(first.uses, 1);
-
-        assert!(matches!(
-            ledger.consume("tok-once", &scope, "release-bot", 11),
-            Err(ApprovalTokenError::ApprovalAlreadyConsumed)
-        ));
-        assert_eq!(
-            ledger.get("tok-once").map(|grant| grant.status),
-            Some(ApprovalTokenStatus::Consumed)
-        );
-    }
-
-    #[test]
-    fn approval_token_rejects_scope_expansion_expiry_and_revocation() {
-        let mut ledger = ApprovalTokenLedger::new();
-        let scope = ApprovalScope::new("main_push_forbidden", "git push")
-            .with_repository("sisyphus/claw-code")
-            .with_branch("main");
-        let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")
-            .with_repository("sisyphus/claw-code")
-            .with_branch("dev");
-
-        ledger.insert(
-            ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")
-                .expires_at(20),
-        );
-
-        assert!(matches!(
-            ledger.verify("tok-expiring", &dev_scope, "bot", 10),
-            Err(ApprovalTokenError::ScopeMismatch { .. })
-        ));
-        assert!(matches!(
-            ledger.verify("tok-expiring", &scope, "bot", 21),
-            Err(ApprovalTokenError::ApprovalExpired)
-        ));
-
-        ledger.insert(ApprovalTokenGrant::granted(
-            "tok-revoked",
-            scope.clone(),
-            "owner",
-            "bot",
-        ));
-        let revoked = ledger
-            .revoke("tok-revoked")
-            .expect("revocation should be audited");
-        assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);
-        assert!(matches!(
-            ledger.verify("tok-revoked", &scope, "bot", 10),
-            Err(ApprovalTokenError::ApprovalRevoked)
-        ));
-    }
-
-    #[test]
-    fn approval_token_preserves_delegation_traceability() {
-        let mut ledger = ApprovalTokenLedger::new();
-        let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");
-        ledger.insert(
-            ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")
-                .with_delegation_hop(
-                    ApprovalDelegationHop::new("owner", "owner approval")
-                        .with_session_id("session-owner"),
-                )
-                .with_delegation_hop(
-                    ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")
-                        .with_session_id("session-lead"),
-                ),
-        );
-
-        assert!(matches!(
-            ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),
-            Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })
-                if expected == "deploy-bot" && actual == "unexpected-bot"
-        ));
-
-        let audit = ledger
-            .consume("tok-delegated", &scope, "deploy-bot", 10)
-            .expect("approved delegate should consume token");
-        let actors = audit
-            .delegation_chain
-            .iter()
-            .map(|hop| hop.actor.as_str())
-            .collect::<Vec<_>>();
-
-        assert!(audit.delegated_execution);
-        assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);
-        assert_eq!(
-            audit.delegation_chain[0].session_id.as_deref(),
-            Some("session-owner")
-        );
-        assert_eq!(
-            audit.delegation_chain[1].session_id.as_deref(),
-            Some("session-lead")
-        );
-    }
-}

rust/crates/runtime/src/bash.rs

@@ -8,14 +8,12 @@ use tokio::process::Command as TokioCommand;
 use tokio::runtime::Builder;
 use tokio::time::timeout;
 
-use crate::lane_events::{LaneEvent, ShipMergeMethod, ShipProvenance};
 use crate::sandbox::{
     build_linux_sandbox_command, resolve_sandbox_status_for_request, FilesystemIsolationMode,
     SandboxConfig, SandboxStatus,
 };
 use crate::ConfigLoader;
 
-/// Input schema for the built-in bash execution tool.
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 pub struct BashCommandInput {
     pub command: String,
@@ -35,7 +33,6 @@ pub struct BashCommandInput {
     pub allowed_mounts: Option<Vec<String>>,
 }
 
-/// Output returned from a bash tool invocation.
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub struct BashCommandOutput {
     pub stdout: String,
@@ -67,7 +64,6 @@ pub struct BashCommandOutput {
     pub sandbox_status: Option<SandboxStatus>,
 }
 
-/// Executes a shell command with the requested sandbox settings.
 pub fn execute_bash(input: BashCommandInput) -> io::Result<BashCommandOutput> {
     let cwd = env::current_dir()?;
     let sandbox_status = sandbox_status_for_input(&input, &cwd);
@@ -103,76 +99,11 @@ pub fn execute_bash(input: BashCommandInput) -> io::Result<BashCommandOutput> {
     runtime.block_on(execute_bash_async(input, sandbox_status, cwd))
 }
 
-/// Detect git push to main and emit ship provenance event
-fn detect_and_emit_ship_prepared(command: &str) {
-    let trimmed = command.trim();
-    // Simple detection: git push with main/master
-    if trimmed.contains("git push") && (trimmed.contains("main") || trimmed.contains("master")) {
-        // Emit ship.prepared event
-        let now = std::time::SystemTime::now()
-            .duration_since(std::time::UNIX_EPOCH)
-            .unwrap_or_default()
-            .as_millis();
-        let provenance = ShipProvenance {
-            source_branch: get_current_branch().unwrap_or_else(|| "unknown".to_string()),
-            base_commit: get_head_commit().unwrap_or_default(),
-            commit_count: 0, // Would need to calculate from range
-            commit_range: "unknown..HEAD".to_string(),
-            merge_method: ShipMergeMethod::DirectPush,
-            actor: get_git_actor().unwrap_or_else(|| "unknown".to_string()),
-            pr_number: None,
-        };
-        let _event = LaneEvent::ship_prepared(format!("{now}"), &provenance);
-        // Log to stderr as interim routing before event stream integration
-        eprintln!(
-            "[ship.prepared] branch={} -> main, commits={}, actor={}",
-            provenance.source_branch, provenance.commit_count, provenance.actor
-        );
-    }
-}
-
-fn get_current_branch() -> Option<String> {
-    let output = Command::new("git")
-        .args(["branch", "--show-current"])
-        .output()
-        .ok()?;
-    if output.status.success() {
-        Some(String::from_utf8_lossy(&output.stdout).trim().to_string())
-    } else {
-        None
-    }
-}
-
-fn get_head_commit() -> Option<String> {
-    let output = Command::new("git")
-        .args(["rev-parse", "--short", "HEAD"])
-        .output()
-        .ok()?;
-    if output.status.success() {
-        Some(String::from_utf8_lossy(&output.stdout).trim().to_string())
-    } else {
-        None
-    }
-}
-
-fn get_git_actor() -> Option<String> {
-    let name = Command::new("git")
-        .args(["config", "user.name"])
-        .output()
-        .ok()
-        .filter(|o| o.status.success())
-        .map(|o| String::from_utf8_lossy(&o.stdout).trim().to_string())?;
-    Some(name)
-}
-
 async fn execute_bash_async(
     input: BashCommandInput,
     sandbox_status: SandboxStatus,
     cwd: std::path::PathBuf,
 ) -> io::Result<BashCommandOutput> {
-    // Detect and emit ship provenance for git push operations
-    detect_and_emit_ship_prepared(&input.command);
-
     let mut command = prepare_tokio_command(&input.command, &cwd, &sandbox_status, true);
 
     let output_result = if let Some(timeout_ms) = input.timeout {
@@ -203,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 {
@@ -350,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/bootstrap.rs

@@ -54,58 +54,3 @@ impl BootstrapPlan {
         &self.phases
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::{BootstrapPhase, BootstrapPlan};
-
-    #[test]
-    fn from_phases_deduplicates_while_preserving_order() {
-        // given
-        let phases = vec![
-            BootstrapPhase::CliEntry,
-            BootstrapPhase::FastPathVersion,
-            BootstrapPhase::CliEntry,
-            BootstrapPhase::MainRuntime,
-            BootstrapPhase::FastPathVersion,
-        ];
-
-        // when
-        let plan = BootstrapPlan::from_phases(phases);
-
-        // then
-        assert_eq!(
-            plan.phases(),
-            &[
-                BootstrapPhase::CliEntry,
-                BootstrapPhase::FastPathVersion,
-                BootstrapPhase::MainRuntime,
-            ]
-        );
-    }
-
-    #[test]
-    fn claude_code_default_covers_each_phase_once() {
-        // given
-        let expected = [
-            BootstrapPhase::CliEntry,
-            BootstrapPhase::FastPathVersion,
-            BootstrapPhase::StartupProfiler,
-            BootstrapPhase::SystemPromptFastPath,
-            BootstrapPhase::ChromeMcpFastPath,
-            BootstrapPhase::DaemonWorkerFastPath,
-            BootstrapPhase::BridgeFastPath,
-            BootstrapPhase::DaemonFastPath,
-            BootstrapPhase::BackgroundSessionFastPath,
-            BootstrapPhase::TemplateFastPath,
-            BootstrapPhase::EnvironmentRunnerFastPath,
-            BootstrapPhase::MainRuntime,
-        ];
-
-        // when
-        let plan = BootstrapPlan::claude_code_default();
-
-        // then
-        assert_eq!(plan.phases(), &expected);
-    }
-}

rust/crates/runtime/src/branch_lock.rs

@@ -1,144 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub struct BranchLockIntent {
-    #[serde(rename = "laneId")]
-    pub lane_id: String,
-    pub branch: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub worktree: Option<String>,
-    #[serde(default, skip_serializing_if = "Vec::is_empty")]
-    pub modules: Vec<String>,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub struct BranchLockCollision {
-    pub branch: String,
-    pub module: String,
-    #[serde(rename = "laneIds")]
-    pub lane_ids: Vec<String>,
-}
-
-#[must_use]
-pub fn detect_branch_lock_collisions(intents: &[BranchLockIntent]) -> Vec<BranchLockCollision> {
-    let mut collisions = Vec::new();
-
-    for (index, left) in intents.iter().enumerate() {
-        for right in &intents[index + 1..] {
-            if left.branch != right.branch {
-                continue;
-            }
-            for module in overlapping_modules(&left.modules, &right.modules) {
-                collisions.push(BranchLockCollision {
-                    branch: left.branch.clone(),
-                    module,
-                    lane_ids: vec![left.lane_id.clone(), right.lane_id.clone()],
-                });
-            }
-        }
-    }
-
-    collisions.sort_by(|a, b| {
-        a.branch
-            .cmp(&b.branch)
-            .then(a.module.cmp(&b.module))
-            .then(a.lane_ids.cmp(&b.lane_ids))
-    });
-    collisions.dedup();
-    collisions
-}
-
-fn overlapping_modules(left: &[String], right: &[String]) -> Vec<String> {
-    let mut overlaps = Vec::new();
-    for left_module in left {
-        for right_module in right {
-            if modules_overlap(left_module, right_module) {
-                overlaps.push(shared_scope(left_module, right_module));
-            }
-        }
-    }
-    overlaps.sort();
-    overlaps.dedup();
-    overlaps
-}
-
-fn modules_overlap(left: &str, right: &str) -> bool {
-    left == right
-        || left.starts_with(&format!("{right}/"))
-        || right.starts_with(&format!("{left}/"))
-}
-
-fn shared_scope(left: &str, right: &str) -> String {
-    if left.starts_with(&format!("{right}/")) || left == right {
-        right.to_string()
-    } else {
-        left.to_string()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::{detect_branch_lock_collisions, BranchLockIntent};
-
-    #[test]
-    fn detects_same_branch_same_module_collisions() {
-        let collisions = detect_branch_lock_collisions(&[
-            BranchLockIntent {
-                lane_id: "lane-a".to_string(),
-                branch: "feature/lock".to_string(),
-                worktree: Some("wt-a".to_string()),
-                modules: vec!["runtime/mcp".to_string()],
-            },
-            BranchLockIntent {
-                lane_id: "lane-b".to_string(),
-                branch: "feature/lock".to_string(),
-                worktree: Some("wt-b".to_string()),
-                modules: vec!["runtime/mcp".to_string()],
-            },
-        ]);
-
-        assert_eq!(collisions.len(), 1);
-        assert_eq!(collisions[0].branch, "feature/lock");
-        assert_eq!(collisions[0].module, "runtime/mcp");
-    }
-
-    #[test]
-    fn detects_nested_module_scope_collisions() {
-        let collisions = detect_branch_lock_collisions(&[
-            BranchLockIntent {
-                lane_id: "lane-a".to_string(),
-                branch: "feature/lock".to_string(),
-                worktree: None,
-                modules: vec!["runtime".to_string()],
-            },
-            BranchLockIntent {
-                lane_id: "lane-b".to_string(),
-                branch: "feature/lock".to_string(),
-                worktree: None,
-                modules: vec!["runtime/mcp".to_string()],
-            },
-        ]);
-
-        assert_eq!(collisions[0].module, "runtime");
-    }
-
-    #[test]
-    fn ignores_different_branches() {
-        let collisions = detect_branch_lock_collisions(&[
-            BranchLockIntent {
-                lane_id: "lane-a".to_string(),
-                branch: "feature/a".to_string(),
-                worktree: None,
-                modules: vec!["runtime/mcp".to_string()],
-            },
-            BranchLockIntent {
-                lane_id: "lane-b".to_string(),
-                branch: "feature/b".to_string(),
-                worktree: None,
-                modules: vec!["runtime/mcp".to_string()],
-            },
-        ]);
-
-        assert!(collisions.is_empty());
-    }
-}

rust/crates/runtime/src/compact.rs

@@ -1,11 +1,5 @@
 use crate::session::{ContentBlock, ConversationMessage, MessageRole, Session};
 
-const COMPACT_CONTINUATION_PREAMBLE: &str =
-    "This session is being continued from a previous conversation that ran out of context. The summary below covers the earlier portion of the conversation.\n\n";
-const COMPACT_RECENT_MESSAGES_NOTE: &str = "Recent messages are preserved verbatim.";
-const COMPACT_DIRECT_RESUME_INSTRUCTION: &str = "Continue the conversation from where it left off without asking the user any further questions. Resume directly — do not acknowledge the summary, do not recap what was happening, and do not preface with continuation text.";
-
-/// Thresholds controlling when and how a session is compacted.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct CompactionConfig {
     pub preserve_recent_messages: usize,
@@ -21,7 +15,6 @@ impl Default for CompactionConfig {
     }
 }
 
-/// Result of compacting a session into a summary plus preserved tail messages.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct CompactionResult {
     pub summary: String,
@@ -30,27 +23,17 @@ pub struct CompactionResult {
     pub removed_message_count: usize,
 }
 
-/// Roughly estimates the token footprint of the current session transcript.
 #[must_use]
 pub fn estimate_session_tokens(session: &Session) -> usize {
     session.messages.iter().map(estimate_message_tokens).sum()
 }
 
-/// Returns `true` when the session exceeds the configured compaction budget.
 #[must_use]
 pub fn should_compact(session: &Session, config: CompactionConfig) -> bool {
-    let start = compacted_summary_prefix_len(session);
-    let compactable = &session.messages[start..];
-
-    compactable.len() > config.preserve_recent_messages
-        && compactable
-            .iter()
-            .map(estimate_message_tokens)
-            .sum::<usize>()
-            >= config.max_estimated_tokens
+    session.messages.len() > config.preserve_recent_messages
+        && estimate_session_tokens(session) >= config.max_estimated_tokens
 }
 
-/// Normalizes a compaction summary into user-facing continuation text.
 #[must_use]
 pub fn format_compact_summary(summary: &str) -> String {
     let without_analysis = strip_tag_block(summary, "analysis");
@@ -66,7 +49,6 @@ pub fn format_compact_summary(summary: &str) -> String {
     collapse_blank_lines(&formatted).trim().to_string()
 }
 
-/// Builds the synthetic system message used after session compaction.
 #[must_use]
 pub fn get_compact_continuation_message(
     summary: &str,
@@ -74,24 +56,21 @@ pub fn get_compact_continuation_message(
     recent_messages_preserved: bool,
 ) -> String {
     let mut base = format!(
-        "{COMPACT_CONTINUATION_PREAMBLE}{}",
+        "This session is being continued from a previous conversation that ran out of context. The summary below covers the earlier portion of the conversation.\n\n{}",
         format_compact_summary(summary)
     );
 
     if recent_messages_preserved {
-        base.push_str("\n\n");
-        base.push_str(COMPACT_RECENT_MESSAGES_NOTE);
+        base.push_str("\n\nRecent messages are preserved verbatim.");
     }
 
     if suppress_follow_up_questions {
-        base.push('\n');
-        base.push_str(COMPACT_DIRECT_RESUME_INSTRUCTION);
+        base.push_str("\nContinue the conversation from where it left off without asking the user any further questions. Resume directly — do not acknowledge the summary, do not recap what was happening, and do not preface with continuation text.");
     }
 
     base
 }
 
-/// Compacts a session by summarizing older messages and preserving the recent tail.
 #[must_use]
 pub fn compact_session(session: &Session, config: CompactionConfig) -> CompactionResult {
     if !should_compact(session, config) {
@@ -103,63 +82,13 @@ pub fn compact_session(session: &Session, config: CompactionConfig) -> Compactio
         };
     }
 
-    let existing_summary = session
-        .messages
-        .first()
-        .and_then(extract_existing_compacted_summary);
-    let compacted_prefix_len = usize::from(existing_summary.is_some());
-    let raw_keep_from = session
+    let keep_from = session
         .messages
         .len()
         .saturating_sub(config.preserve_recent_messages);
-    // Ensure we do not split a tool-use / tool-result pair at the compaction
-    // boundary. If the first preserved message is a user message whose first
-    // block is a ToolResult, the assistant message with the matching ToolUse
-    // was slated for removal — that produces an orphaned tool role message on
-    // the OpenAI-compat path (400: tool message must follow assistant with
-    // tool_calls). Walk the boundary back until we start at a safe point.
-    let keep_from = {
-        let mut k = raw_keep_from;
-        // If the first preserved message is a tool-result turn, ensure its
-        // paired assistant tool-use turn is preserved too. Without this fix,
-        // the OpenAI-compat adapter sends an orphaned 'tool' role message
-        // with no preceding assistant 'tool_calls', which providers reject
-        // with a 400. We walk back only if the immediately preceding message
-        // is NOT an assistant message that contains a ToolUse block (i.e. the
-        // pair is actually broken at the boundary).
-        loop {
-            if k == 0 || k <= compacted_prefix_len {
-                break;
-            }
-            let first_preserved = &session.messages[k];
-            let starts_with_tool_result = first_preserved
-                .blocks
-                .first()
-                .is_some_and(|b| matches!(b, ContentBlock::ToolResult { .. }));
-            if !starts_with_tool_result {
-                break;
-            }
-            // Check the message just before the current boundary.
-            let preceding = &session.messages[k - 1];
-            let preceding_has_tool_use = preceding
-                .blocks
-                .iter()
-                .any(|b| matches!(b, ContentBlock::ToolUse { .. }));
-            if preceding_has_tool_use {
-                // Pair is intact — walk back one more to include the assistant turn.
-                k = k.saturating_sub(1);
-                break;
-            }
-            // Preceding message has no ToolUse but we have a ToolResult —
-            // this is already an orphaned pair; walk back to try to fix it.
-            k = k.saturating_sub(1);
-        }
-        k
-    };
-    let removed = &session.messages[compacted_prefix_len..keep_from];
+    let removed = &session.messages[..keep_from];
     let preserved = session.messages[keep_from..].to_vec();
-    let summary =
-        merge_compact_summaries(existing_summary.as_deref(), &summarize_messages(removed));
+    let summary = summarize_messages(removed);
     let formatted_summary = format_compact_summary(&summary);
     let continuation = get_compact_continuation_message(&summary, true, !preserved.is_empty());
 
@@ -170,28 +99,17 @@ pub fn compact_session(session: &Session, config: CompactionConfig) -> Compactio
     }];
     compacted_messages.extend(preserved);
 
-    let mut compacted_session = session.clone();
-    compacted_session.messages = compacted_messages;
-    compacted_session.record_compaction(summary.clone(), removed.len());
-
     CompactionResult {
         summary,
         formatted_summary,
-        compacted_session,
+        compacted_session: Session {
+            version: session.version,
+            messages: compacted_messages,
+        },
         removed_message_count: removed.len(),
     }
 }
 
-fn compacted_summary_prefix_len(session: &Session) -> usize {
-    usize::from(
-        session
-            .messages
-            .first()
-            .and_then(extract_existing_compacted_summary)
-            .is_some(),
-    )
-}
-
 fn summarize_messages(messages: &[ConversationMessage]) -> String {
     let user_messages = messages
         .iter()
@@ -212,7 +130,7 @@ fn summarize_messages(messages: &[ConversationMessage]) -> String {
         .filter_map(|block| match block {
             ContentBlock::ToolUse { name, .. } => Some(name.as_str()),
             ContentBlock::ToolResult { tool_name, .. } => Some(tool_name.as_str()),
-            ContentBlock::Text { .. } | ContentBlock::Thinking { .. } => None,
+            ContentBlock::Text { .. } => None,
         })
         .collect::<Vec<_>>();
     tool_names.sort_unstable();
@@ -279,47 +197,9 @@ fn summarize_messages(messages: &[ConversationMessage]) -> String {
     lines.join("\n")
 }
 
-fn merge_compact_summaries(existing_summary: Option<&str>, new_summary: &str) -> String {
-    let Some(existing_summary) = existing_summary else {
-        return new_summary.to_string();
-    };
-
-    let previous_highlights = extract_summary_highlights(existing_summary);
-    let new_formatted_summary = format_compact_summary(new_summary);
-    let new_highlights = extract_summary_highlights(&new_formatted_summary);
-    let new_timeline = extract_summary_timeline(&new_formatted_summary);
-
-    let mut lines = vec!["<summary>".to_string(), "Conversation summary:".to_string()];
-
-    if !previous_highlights.is_empty() {
-        lines.push("- Previously compacted context:".to_string());
-        lines.extend(
-            previous_highlights
-                .into_iter()
-                .map(|line| format!("  {line}")),
-        );
-    }
-
-    if !new_highlights.is_empty() {
-        lines.push("- Newly compacted context:".to_string());
-        lines.extend(new_highlights.into_iter().map(|line| format!("  {line}")));
-    }
-
-    if !new_timeline.is_empty() {
-        lines.push("- Key timeline:".to_string());
-        lines.extend(new_timeline.into_iter().map(|line| format!("  {line}")));
-    }
-
-    lines.push("</summary>".to_string());
-    lines.join("\n")
-}
-
 fn summarize_block(block: &ContentBlock) -> String {
     let raw = match block {
         ContentBlock::Text { text } => text.clone(),
-        ContentBlock::Thinking { thinking, .. } => {
-            format!("thinking ({} chars)", thinking.chars().count())
-        }
         ContentBlock::ToolUse { name, input, .. } => format!("tool_use {name}({input})"),
         ContentBlock::ToolResult {
             tool_name,
@@ -381,7 +261,6 @@ fn collect_key_files(messages: &[ConversationMessage]) -> Vec<String> {
             ContentBlock::Text { text } => text.as_str(),
             ContentBlock::ToolUse { input, .. } => input.as_str(),
             ContentBlock::ToolResult { output, .. } => output.as_str(),
-            ContentBlock::Thinking { thinking, .. } => thinking.as_str(),
         })
         .flat_map(extract_file_candidates)
         .collect::<Vec<_>>();
@@ -404,7 +283,6 @@ fn first_text_block(message: &ConversationMessage) -> Option<&str> {
         ContentBlock::Text { text } if !text.trim().is_empty() => Some(text.as_str()),
         ContentBlock::ToolUse { .. }
         | ContentBlock::ToolResult { .. }
-        | ContentBlock::Thinking { .. }
         | ContentBlock::Text { .. } => None,
     })
 }
@@ -455,10 +333,6 @@ fn estimate_message_tokens(message: &ConversationMessage) -> usize {
             ContentBlock::ToolResult {
                 tool_name, output, ..
             } => (tool_name.len() + output.len()) / 4 + 1,
-            ContentBlock::Thinking {
-                thinking,
-                signature,
-            } => thinking.len() / 4 + signature.as_ref().map_or(0, |value| value.len() / 4 + 1),
         })
         .sum()
 }
@@ -500,71 +374,11 @@ fn collapse_blank_lines(content: &str) -> String {
     result
 }
 
-fn extract_existing_compacted_summary(message: &ConversationMessage) -> Option<String> {
-    if message.role != MessageRole::System {
-        return None;
-    }
-
-    let text = first_text_block(message)?;
-    let summary = text.strip_prefix(COMPACT_CONTINUATION_PREAMBLE)?;
-    let summary = summary
-        .split_once(&format!("\n\n{COMPACT_RECENT_MESSAGES_NOTE}"))
-        .map_or(summary, |(value, _)| value);
-    let summary = summary
-        .split_once(&format!("\n{COMPACT_DIRECT_RESUME_INSTRUCTION}"))
-        .map_or(summary, |(value, _)| value);
-    Some(summary.trim().to_string())
-}
-
-fn extract_summary_highlights(summary: &str) -> Vec<String> {
-    let mut lines = Vec::new();
-    let mut in_timeline = false;
-
-    for line in format_compact_summary(summary).lines() {
-        let trimmed = line.trim_end();
-        if trimmed.is_empty() || trimmed == "Summary:" || trimmed == "Conversation summary:" {
-            continue;
-        }
-        if trimmed == "- Key timeline:" {
-            in_timeline = true;
-            continue;
-        }
-        if in_timeline {
-            continue;
-        }
-        lines.push(trimmed.to_string());
-    }
-
-    lines
-}
-
-fn extract_summary_timeline(summary: &str) -> Vec<String> {
-    let mut lines = Vec::new();
-    let mut in_timeline = false;
-
-    for line in format_compact_summary(summary).lines() {
-        let trimmed = line.trim_end();
-        if trimmed == "- Key timeline:" {
-            in_timeline = true;
-            continue;
-        }
-        if !in_timeline {
-            continue;
-        }
-        if trimmed.is_empty() {
-            break;
-        }
-        lines.push(trimmed.to_string());
-    }
-
-    lines
-}
-
 #[cfg(test)]
 mod tests {
     use super::{
-        collect_key_files, compact_session, format_compact_summary,
-        get_compact_continuation_message, infer_pending_work, should_compact, CompactionConfig,
+        collect_key_files, compact_session, estimate_session_tokens, format_compact_summary,
+        infer_pending_work, should_compact, CompactionConfig,
     };
     use crate::session::{ContentBlock, ConversationMessage, MessageRole, Session};
 
@@ -576,8 +390,10 @@ mod tests {
 
     #[test]
     fn leaves_small_sessions_unchanged() {
-        let mut session = Session::new();
-        session.messages = vec![ConversationMessage::user_text("hello")];
+        let session = Session {
+            version: 1,
+            messages: vec![ConversationMessage::user_text("hello")],
+        };
 
         let result = compact_session(&session, CompactionConfig::default());
         assert_eq!(result.removed_message_count, 0);
@@ -588,21 +404,23 @@ mod tests {
 
     #[test]
     fn compacts_older_messages_into_a_system_summary() {
-        let mut session = Session::new();
-        session.messages = vec![
-            ConversationMessage::user_text("one ".repeat(200)),
-            ConversationMessage::assistant(vec![ContentBlock::Text {
-                text: "two ".repeat(200),
-            }]),
-            ConversationMessage::tool_result("1", "bash", "ok ".repeat(200), false),
-            ConversationMessage {
-                role: MessageRole::Assistant,
-                blocks: vec![ContentBlock::Text {
-                    text: "recent".to_string(),
-                }],
-                usage: None,
-            },
-        ];
+        let session = Session {
+            version: 1,
+            messages: vec![
+                ConversationMessage::user_text("one ".repeat(200)),
+                ConversationMessage::assistant(vec![ContentBlock::Text {
+                    text: "two ".repeat(200),
+                }]),
+                ConversationMessage::tool_result("1", "bash", "ok ".repeat(200), false),
+                ConversationMessage {
+                    role: MessageRole::Assistant,
+                    blocks: vec![ContentBlock::Text {
+                        text: "recent".to_string(),
+                    }],
+                    usage: None,
+                },
+            ],
+        };
 
         let result = compact_session(
             &session,
@@ -612,14 +430,7 @@ mod tests {
             },
         );
 
-        // With the tool-use/tool-result boundary fix, the compaction preserves
-        // one extra message to avoid an orphaned tool result at the boundary.
-        // messages[1] (assistant) must be kept along with messages[2] (tool result).
-        assert!(
-            result.removed_message_count <= 2,
-            "expected at most 2 removed, got {}",
-            result.removed_message_count
-        );
+        assert_eq!(result.removed_message_count, 2);
         assert_eq!(
             result.compacted_session.messages[0].role,
             MessageRole::System
@@ -637,98 +448,11 @@ mod tests {
                 max_estimated_tokens: 1,
             }
         ));
-        // Note: with the tool-use/tool-result boundary guard the compacted session
-        // may preserve one extra message at the boundary, so token reduction is
-        // not guaranteed for small sessions. The invariant that matters is that
-        // the removed_message_count is non-zero (something was compacted).
         assert!(
-            result.removed_message_count > 0,
-            "compaction must remove at least one message"
+            estimate_session_tokens(&result.compacted_session) < estimate_session_tokens(&session)
         );
     }
 
-    #[test]
-    fn keeps_previous_compacted_context_when_compacting_again() {
-        let mut initial_session = Session::new();
-        initial_session.messages = vec![
-            ConversationMessage::user_text("Investigate rust/crates/runtime/src/compact.rs"),
-            ConversationMessage::assistant(vec![ContentBlock::Text {
-                text: "I will inspect the compact flow.".to_string(),
-            }]),
-            ConversationMessage::user_text("Also update rust/crates/runtime/src/conversation.rs"),
-            ConversationMessage::assistant(vec![ContentBlock::Text {
-                text: "Next: preserve prior summary context during auto compact.".to_string(),
-            }]),
-        ];
-        let config = CompactionConfig {
-            preserve_recent_messages: 2,
-            max_estimated_tokens: 1,
-        };
-
-        let first = compact_session(&initial_session, config);
-        let mut follow_up_messages = first.compacted_session.messages.clone();
-        follow_up_messages.extend([
-            ConversationMessage::user_text("Please add regression tests for compaction."),
-            ConversationMessage::assistant(vec![ContentBlock::Text {
-                text: "Working on regression coverage now.".to_string(),
-            }]),
-        ]);
-
-        let mut second_session = Session::new();
-        second_session.messages = follow_up_messages;
-        let second = compact_session(&second_session, config);
-
-        assert!(second
-            .formatted_summary
-            .contains("Previously compacted context:"));
-        assert!(second
-            .formatted_summary
-            .contains("Scope: 2 earlier messages compacted"));
-        assert!(second
-            .formatted_summary
-            .contains("Newly compacted context:"));
-        assert!(second
-            .formatted_summary
-            .contains("Also update rust/crates/runtime/src/conversation.rs"));
-        assert!(matches!(
-            &second.compacted_session.messages[0].blocks[0],
-            ContentBlock::Text { text }
-                if text.contains("Previously compacted context:")
-                    && text.contains("Newly compacted context:")
-        ));
-        assert!(matches!(
-            &second.compacted_session.messages[1].blocks[0],
-            ContentBlock::Text { text } if text.contains("Please add regression tests for compaction.")
-        ));
-    }
-
-    #[test]
-    fn ignores_existing_compacted_summary_when_deciding_to_recompact() {
-        let summary = "<summary>Conversation summary:\n- Scope: earlier work preserved.\n- Key timeline:\n  - user: large preserved context\n</summary>";
-        let mut session = Session::new();
-        session.messages = vec![
-            ConversationMessage {
-                role: MessageRole::System,
-                blocks: vec![ContentBlock::Text {
-                    text: get_compact_continuation_message(summary, true, true),
-                }],
-                usage: None,
-            },
-            ConversationMessage::user_text("tiny"),
-            ConversationMessage::assistant(vec![ContentBlock::Text {
-                text: "recent".to_string(),
-            }]),
-        ];
-
-        assert!(!should_compact(
-            &session,
-            CompactionConfig {
-                preserve_recent_messages: 2,
-                max_estimated_tokens: 1,
-            }
-        ));
-    }
-
     #[test]
     fn truncates_long_blocks_in_summary() {
         let summary = super::summarize_block(&ContentBlock::Text {
@@ -747,79 +471,6 @@ mod tests {
         assert!(files.contains(&"rust/crates/rusty-claude-cli/src/main.rs".to_string()));
     }
 
-    /// Regression: compaction must not split an assistant(ToolUse) /
-    /// user(ToolResult) pair at the boundary. An orphaned tool-result message
-    /// without the preceding assistant `tool_calls` causes a 400 on the
-    /// OpenAI-compat path (gaebal-gajae repro 2026-04-09).
-    #[test]
-    fn compaction_does_not_split_tool_use_tool_result_pair() {
-        use crate::session::{ContentBlock, Session};
-
-        let tool_id = "call_abc";
-        let mut session = Session::default();
-        // Turn 1: user prompt
-        session
-            .push_message(ConversationMessage::user_text("Search for files"))
-            .unwrap();
-        // Turn 2: assistant calls a tool
-        session
-            .push_message(ConversationMessage::assistant(vec![
-                ContentBlock::ToolUse {
-                    id: tool_id.to_string(),
-                    name: "search".to_string(),
-                    input: "{\"q\":\"*.rs\"}".to_string(),
-                },
-            ]))
-            .unwrap();
-        // Turn 3: tool result
-        session
-            .push_message(ConversationMessage::tool_result(
-                tool_id,
-                "search",
-                "found 5 files",
-                false,
-            ))
-            .unwrap();
-        // Turn 4: assistant final response
-        session
-            .push_message(ConversationMessage::assistant(vec![ContentBlock::Text {
-                text: "Done.".to_string(),
-            }]))
-            .unwrap();
-
-        // Compact preserving only 1 recent message — without the fix this
-        // would cut the boundary so that the tool result (turn 3) is first,
-        // without its preceding assistant tool_calls (turn 2).
-        let config = CompactionConfig {
-            preserve_recent_messages: 1,
-            ..CompactionConfig::default()
-        };
-        let result = compact_session(&session, config);
-        // After compaction, no two consecutive messages should have the pattern
-        // tool_result immediately following a non-assistant message (i.e. an
-        // orphaned tool result without a preceding assistant ToolUse).
-        let messages = &result.compacted_session.messages;
-        for i in 1..messages.len() {
-            let curr_is_tool_result = messages[i]
-                .blocks
-                .first()
-                .is_some_and(|b| matches!(b, ContentBlock::ToolResult { .. }));
-            if curr_is_tool_result {
-                let prev_has_tool_use = messages[i - 1]
-                    .blocks
-                    .iter()
-                    .any(|b| matches!(b, ContentBlock::ToolUse { .. }));
-                assert!(
-                    prev_has_tool_use,
-                    "message[{}] is a ToolResult but message[{}] has no ToolUse: {:?}",
-                    i,
-                    i - 1,
-                    &messages[i - 1].blocks
-                );
-            }
-        }
-    }
-
     #[test]
     fn infers_pending_work_from_recent_messages() {
         let pending = infer_pending_work(&[

rust/crates/runtime/src/config_validate.rs

@@ -1,901 +0,0 @@
-use std::collections::BTreeMap;
-use std::path::Path;
-
-use crate::config::ConfigError;
-use crate::json::JsonValue;
-
-/// Diagnostic emitted when a config file contains a suspect field.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct ConfigDiagnostic {
-    pub path: String,
-    pub field: String,
-    pub line: Option<usize>,
-    pub kind: DiagnosticKind,
-}
-
-/// Classification of the diagnostic.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum DiagnosticKind {
-    UnknownKey {
-        suggestion: Option<String>,
-    },
-    WrongType {
-        expected: &'static str,
-        got: &'static str,
-    },
-    Deprecated {
-        replacement: &'static str,
-    },
-}
-
-impl std::fmt::Display for ConfigDiagnostic {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let location = self
-            .line
-            .map_or_else(String::new, |line| format!(" (line {line})"));
-        match &self.kind {
-            DiagnosticKind::UnknownKey { suggestion: None } => {
-                write!(f, "{}: unknown key \"{}\"{location}", self.path, self.field)
-            }
-            DiagnosticKind::UnknownKey {
-                suggestion: Some(hint),
-            } => {
-                write!(
-                    f,
-                    "{}: unknown key \"{}\"{location}. Did you mean \"{}\"?",
-                    self.path, self.field, hint
-                )
-            }
-            DiagnosticKind::WrongType { expected, got } => {
-                write!(
-                    f,
-                    "{}: field \"{}\" must be {expected}, got {got}{location}",
-                    self.path, self.field
-                )
-            }
-            DiagnosticKind::Deprecated { replacement } => {
-                write!(
-                    f,
-                    "{}: field \"{}\" is deprecated{location}. Use \"{replacement}\" instead",
-                    self.path, self.field
-                )
-            }
-        }
-    }
-}
-
-/// Result of validating a single config file.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct ValidationResult {
-    pub errors: Vec<ConfigDiagnostic>,
-    pub warnings: Vec<ConfigDiagnostic>,
-}
-
-impl ValidationResult {
-    #[must_use]
-    pub fn is_ok(&self) -> bool {
-        self.errors.is_empty()
-    }
-
-    fn merge(&mut self, other: Self) {
-        self.errors.extend(other.errors);
-        self.warnings.extend(other.warnings);
-    }
-}
-
-// ---- known-key schema ----
-
-/// Expected type for a config field.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-enum FieldType {
-    String,
-    Bool,
-    Object,
-    StringArray,
-    Number,
-}
-
-impl FieldType {
-    fn label(self) -> &'static str {
-        match self {
-            Self::String => "a string",
-            Self::Bool => "a boolean",
-            Self::Object => "an object",
-            Self::StringArray => "an array of strings",
-            Self::Number => "a number",
-        }
-    }
-
-    fn matches(self, value: &JsonValue) -> bool {
-        match self {
-            Self::String => value.as_str().is_some(),
-            Self::Bool => value.as_bool().is_some(),
-            Self::Object => value.as_object().is_some(),
-            Self::StringArray => value
-                .as_array()
-                .is_some_and(|arr| arr.iter().all(|v| v.as_str().is_some())),
-            Self::Number => value.as_i64().is_some(),
-        }
-    }
-}
-
-fn json_type_label(value: &JsonValue) -> &'static str {
-    match value {
-        JsonValue::Null => "null",
-        JsonValue::Bool(_) => "a boolean",
-        JsonValue::Number(_) => "a number",
-        JsonValue::String(_) => "a string",
-        JsonValue::Array(_) => "an array",
-        JsonValue::Object(_) => "an object",
-    }
-}
-
-struct FieldSpec {
-    name: &'static str,
-    expected: FieldType,
-}
-
-struct DeprecatedField {
-    name: &'static str,
-    replacement: &'static str,
-}
-
-const TOP_LEVEL_FIELDS: &[FieldSpec] = &[
-    FieldSpec {
-        name: "$schema",
-        expected: FieldType::String,
-    },
-    FieldSpec {
-        name: "model",
-        expected: FieldType::String,
-    },
-    FieldSpec {
-        name: "hooks",
-        expected: FieldType::Object,
-    },
-    FieldSpec {
-        name: "permissions",
-        expected: FieldType::Object,
-    },
-    FieldSpec {
-        name: "permissionMode",
-        expected: FieldType::String,
-    },
-    FieldSpec {
-        name: "mcpServers",
-        expected: FieldType::Object,
-    },
-    FieldSpec {
-        name: "oauth",
-        expected: FieldType::Object,
-    },
-    FieldSpec {
-        name: "enabledPlugins",
-        expected: FieldType::Object,
-    },
-    FieldSpec {
-        name: "plugins",
-        expected: FieldType::Object,
-    },
-    FieldSpec {
-        name: "sandbox",
-        expected: FieldType::Object,
-    },
-    FieldSpec {
-        name: "env",
-        expected: FieldType::Object,
-    },
-    FieldSpec {
-        name: "aliases",
-        expected: FieldType::Object,
-    },
-    FieldSpec {
-        name: "providerFallbacks",
-        expected: FieldType::Object,
-    },
-    FieldSpec {
-        name: "trustedRoots",
-        expected: FieldType::StringArray,
-    },
-];
-
-const HOOKS_FIELDS: &[FieldSpec] = &[
-    FieldSpec {
-        name: "PreToolUse",
-        expected: FieldType::StringArray,
-    },
-    FieldSpec {
-        name: "PostToolUse",
-        expected: FieldType::StringArray,
-    },
-    FieldSpec {
-        name: "PostToolUseFailure",
-        expected: FieldType::StringArray,
-    },
-];
-
-const PERMISSIONS_FIELDS: &[FieldSpec] = &[
-    FieldSpec {
-        name: "defaultMode",
-        expected: FieldType::String,
-    },
-    FieldSpec {
-        name: "allow",
-        expected: FieldType::StringArray,
-    },
-    FieldSpec {
-        name: "deny",
-        expected: FieldType::StringArray,
-    },
-    FieldSpec {
-        name: "ask",
-        expected: FieldType::StringArray,
-    },
-];
-
-const PLUGINS_FIELDS: &[FieldSpec] = &[
-    FieldSpec {
-        name: "enabled",
-        expected: FieldType::Object,
-    },
-    FieldSpec {
-        name: "externalDirectories",
-        expected: FieldType::StringArray,
-    },
-    FieldSpec {
-        name: "installRoot",
-        expected: FieldType::String,
-    },
-    FieldSpec {
-        name: "registryPath",
-        expected: FieldType::String,
-    },
-    FieldSpec {
-        name: "bundledRoot",
-        expected: FieldType::String,
-    },
-    FieldSpec {
-        name: "maxOutputTokens",
-        expected: FieldType::Number,
-    },
-];
-
-const SANDBOX_FIELDS: &[FieldSpec] = &[
-    FieldSpec {
-        name: "enabled",
-        expected: FieldType::Bool,
-    },
-    FieldSpec {
-        name: "namespaceRestrictions",
-        expected: FieldType::Bool,
-    },
-    FieldSpec {
-        name: "networkIsolation",
-        expected: FieldType::Bool,
-    },
-    FieldSpec {
-        name: "filesystemMode",
-        expected: FieldType::String,
-    },
-    FieldSpec {
-        name: "allowedMounts",
-        expected: FieldType::StringArray,
-    },
-];
-
-const OAUTH_FIELDS: &[FieldSpec] = &[
-    FieldSpec {
-        name: "clientId",
-        expected: FieldType::String,
-    },
-    FieldSpec {
-        name: "authorizeUrl",
-        expected: FieldType::String,
-    },
-    FieldSpec {
-        name: "tokenUrl",
-        expected: FieldType::String,
-    },
-    FieldSpec {
-        name: "callbackPort",
-        expected: FieldType::Number,
-    },
-    FieldSpec {
-        name: "manualRedirectUrl",
-        expected: FieldType::String,
-    },
-    FieldSpec {
-        name: "scopes",
-        expected: FieldType::StringArray,
-    },
-];
-
-const DEPRECATED_FIELDS: &[DeprecatedField] = &[
-    DeprecatedField {
-        name: "permissionMode",
-        replacement: "permissions.defaultMode",
-    },
-    DeprecatedField {
-        name: "enabledPlugins",
-        replacement: "plugins.enabled",
-    },
-];
-
-// ---- line-number resolution ----
-
-/// Find the 1-based line number where a JSON key first appears in the raw source.
-fn find_key_line(source: &str, key: &str) -> Option<usize> {
-    // Search for `"key"` followed by optional whitespace and a colon.
-    let needle = format!("\"{key}\"");
-    let mut search_start = 0;
-    while let Some(offset) = source[search_start..].find(&needle) {
-        let absolute = search_start + offset;
-        let after = absolute + needle.len();
-        // Verify the next non-whitespace char is `:` to confirm this is a key, not a value.
-        if source[after..].chars().find(|ch| !ch.is_ascii_whitespace()) == Some(':') {
-            return Some(source[..absolute].chars().filter(|&ch| ch == '\n').count() + 1);
-        }
-        search_start = after;
-    }
-    None
-}
-
-// ---- core validation ----
-
-fn validate_object_keys(
-    object: &BTreeMap<String, JsonValue>,
-    known_fields: &[FieldSpec],
-    prefix: &str,
-    source: &str,
-    path_display: &str,
-) -> ValidationResult {
-    let mut result = ValidationResult {
-        errors: Vec::new(),
-        warnings: Vec::new(),
-    };
-
-    let known_names: Vec<&str> = known_fields.iter().map(|f| f.name).collect();
-
-    for (key, value) in object {
-        let field_path = if prefix.is_empty() {
-            key.clone()
-        } else {
-            format!("{prefix}.{key}")
-        };
-
-        if let Some(spec) = known_fields.iter().find(|f| f.name == key) {
-            // Type check.
-            if !spec.expected.matches(value) {
-                result.errors.push(ConfigDiagnostic {
-                    path: path_display.to_string(),
-                    field: field_path,
-                    line: find_key_line(source, key),
-                    kind: DiagnosticKind::WrongType {
-                        expected: spec.expected.label(),
-                        got: json_type_label(value),
-                    },
-                });
-            }
-        } else if DEPRECATED_FIELDS.iter().any(|d| d.name == key) {
-            // Deprecated key — handled separately, not an unknown-key error.
-        } else {
-            // Unknown key.
-            let suggestion = suggest_field(key, &known_names);
-            result.errors.push(ConfigDiagnostic {
-                path: path_display.to_string(),
-                field: field_path,
-                line: find_key_line(source, key),
-                kind: DiagnosticKind::UnknownKey { suggestion },
-            });
-        }
-    }
-
-    result
-}
-
-fn suggest_field(input: &str, candidates: &[&str]) -> Option<String> {
-    let input_lower = input.to_ascii_lowercase();
-    candidates
-        .iter()
-        .filter_map(|candidate| {
-            let distance = simple_edit_distance(&input_lower, &candidate.to_ascii_lowercase());
-            (distance <= 3).then_some((distance, *candidate))
-        })
-        .min_by_key(|(distance, _)| *distance)
-        .map(|(_, name)| name.to_string())
-}
-
-fn simple_edit_distance(left: &str, right: &str) -> usize {
-    if left.is_empty() {
-        return right.len();
-    }
-    if right.is_empty() {
-        return left.len();
-    }
-    let right_chars: Vec<char> = right.chars().collect();
-    let mut previous: Vec<usize> = (0..=right_chars.len()).collect();
-    let mut current = vec![0; right_chars.len() + 1];
-
-    for (left_index, left_char) in left.chars().enumerate() {
-        current[0] = left_index + 1;
-        for (right_index, right_char) in right_chars.iter().enumerate() {
-            let cost = usize::from(left_char != *right_char);
-            current[right_index + 1] = (previous[right_index + 1] + 1)
-                .min(current[right_index] + 1)
-                .min(previous[right_index] + cost);
-        }
-        previous.clone_from(&current);
-    }
-
-    previous[right_chars.len()]
-}
-
-/// Validate a parsed config file's keys and types against the known schema.
-///
-/// Returns diagnostics (errors and deprecation warnings) without blocking the load.
-pub fn validate_config_file(
-    object: &BTreeMap<String, JsonValue>,
-    source: &str,
-    file_path: &Path,
-) -> ValidationResult {
-    let path_display = file_path.display().to_string();
-    let mut result = validate_object_keys(object, TOP_LEVEL_FIELDS, "", source, &path_display);
-
-    // Check deprecated fields.
-    for deprecated in DEPRECATED_FIELDS {
-        if object.contains_key(deprecated.name) {
-            result.warnings.push(ConfigDiagnostic {
-                path: path_display.clone(),
-                field: deprecated.name.to_string(),
-                line: find_key_line(source, deprecated.name),
-                kind: DiagnosticKind::Deprecated {
-                    replacement: deprecated.replacement,
-                },
-            });
-        }
-    }
-
-    // Validate known nested objects.
-    if let Some(hooks) = object.get("hooks").and_then(JsonValue::as_object) {
-        result.merge(validate_object_keys(
-            hooks,
-            HOOKS_FIELDS,
-            "hooks",
-            source,
-            &path_display,
-        ));
-    }
-    if let Some(permissions) = object.get("permissions").and_then(JsonValue::as_object) {
-        result.merge(validate_object_keys(
-            permissions,
-            PERMISSIONS_FIELDS,
-            "permissions",
-            source,
-            &path_display,
-        ));
-    }
-    if let Some(plugins) = object.get("plugins").and_then(JsonValue::as_object) {
-        result.merge(validate_object_keys(
-            plugins,
-            PLUGINS_FIELDS,
-            "plugins",
-            source,
-            &path_display,
-        ));
-    }
-    if let Some(sandbox) = object.get("sandbox").and_then(JsonValue::as_object) {
-        result.merge(validate_object_keys(
-            sandbox,
-            SANDBOX_FIELDS,
-            "sandbox",
-            source,
-            &path_display,
-        ));
-    }
-    if let Some(oauth) = object.get("oauth").and_then(JsonValue::as_object) {
-        result.merge(validate_object_keys(
-            oauth,
-            OAUTH_FIELDS,
-            "oauth",
-            source,
-            &path_display,
-        ));
-    }
-
-    result
-}
-
-/// Check whether a file path uses an unsupported config format (e.g. TOML).
-pub fn check_unsupported_format(file_path: &Path) -> Result<(), ConfigError> {
-    if let Some(ext) = file_path.extension().and_then(|e| e.to_str()) {
-        if ext.eq_ignore_ascii_case("toml") {
-            return Err(ConfigError::Parse(format!(
-                "{}: TOML config files are not supported. Use JSON (settings.json) instead",
-                file_path.display()
-            )));
-        }
-    }
-    Ok(())
-}
-
-/// Format all diagnostics into a human-readable report.
-#[must_use]
-pub fn format_diagnostics(result: &ValidationResult) -> String {
-    let mut lines = Vec::new();
-    for warning in &result.warnings {
-        lines.push(format!("warning: {warning}"));
-    }
-    for error in &result.errors {
-        lines.push(format!("error: {error}"));
-    }
-    lines.join("\n")
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use std::path::PathBuf;
-
-    fn test_path() -> PathBuf {
-        PathBuf::from("/test/settings.json")
-    }
-
-    #[test]
-    fn detects_unknown_top_level_key() {
-        // given
-        let source = r#"{"model": "opus", "unknownField": true}"#;
-        let parsed = JsonValue::parse(source).expect("valid json");
-        let object = parsed.as_object().expect("object");
-
-        // when
-        let result = validate_config_file(object, source, &test_path());
-
-        // then
-        assert_eq!(result.errors.len(), 1);
-        assert_eq!(result.errors[0].field, "unknownField");
-        assert!(matches!(
-            result.errors[0].kind,
-            DiagnosticKind::UnknownKey { .. }
-        ));
-    }
-
-    #[test]
-    fn detects_wrong_type_for_model() {
-        // given
-        let source = r#"{"model": 123}"#;
-        let parsed = JsonValue::parse(source).expect("valid json");
-        let object = parsed.as_object().expect("object");
-
-        // when
-        let result = validate_config_file(object, source, &test_path());
-
-        // then
-        assert_eq!(result.errors.len(), 1);
-        assert_eq!(result.errors[0].field, "model");
-        assert!(matches!(
-            result.errors[0].kind,
-            DiagnosticKind::WrongType {
-                expected: "a string",
-                got: "a number"
-            }
-        ));
-    }
-
-    #[test]
-    fn detects_deprecated_permission_mode() {
-        // given
-        let source = r#"{"permissionMode": "plan"}"#;
-        let parsed = JsonValue::parse(source).expect("valid json");
-        let object = parsed.as_object().expect("object");
-
-        // when
-        let result = validate_config_file(object, source, &test_path());
-
-        // then
-        assert_eq!(result.warnings.len(), 1);
-        assert_eq!(result.warnings[0].field, "permissionMode");
-        assert!(matches!(
-            result.warnings[0].kind,
-            DiagnosticKind::Deprecated {
-                replacement: "permissions.defaultMode"
-            }
-        ));
-    }
-
-    #[test]
-    fn detects_deprecated_enabled_plugins() {
-        // given
-        let source = r#"{"enabledPlugins": {"tool-guard@builtin": true}}"#;
-        let parsed = JsonValue::parse(source).expect("valid json");
-        let object = parsed.as_object().expect("object");
-
-        // when
-        let result = validate_config_file(object, source, &test_path());
-
-        // then
-        assert_eq!(result.warnings.len(), 1);
-        assert_eq!(result.warnings[0].field, "enabledPlugins");
-        assert!(matches!(
-            result.warnings[0].kind,
-            DiagnosticKind::Deprecated {
-                replacement: "plugins.enabled"
-            }
-        ));
-    }
-
-    #[test]
-    fn reports_line_number_for_unknown_key() {
-        // given
-        let source = "{\n  \"model\": \"opus\",\n  \"badKey\": true\n}";
-        let parsed = JsonValue::parse(source).expect("valid json");
-        let object = parsed.as_object().expect("object");
-
-        // when
-        let result = validate_config_file(object, source, &test_path());
-
-        // then
-        assert_eq!(result.errors.len(), 1);
-        assert_eq!(result.errors[0].line, Some(3));
-        assert_eq!(result.errors[0].field, "badKey");
-    }
-
-    #[test]
-    fn reports_line_number_for_wrong_type() {
-        // given
-        let source = "{\n  \"model\": 42\n}";
-        let parsed = JsonValue::parse(source).expect("valid json");
-        let object = parsed.as_object().expect("object");
-
-        // when
-        let result = validate_config_file(object, source, &test_path());
-
-        // then
-        assert_eq!(result.errors.len(), 1);
-        assert_eq!(result.errors[0].line, Some(2));
-    }
-
-    #[test]
-    fn validates_nested_hooks_keys() {
-        // given
-        let source = r#"{"hooks": {"PreToolUse": ["cmd"], "BadHook": ["x"]}}"#;
-        let parsed = JsonValue::parse(source).expect("valid json");
-        let object = parsed.as_object().expect("object");
-
-        // when
-        let result = validate_config_file(object, source, &test_path());
-
-        // then
-        assert_eq!(result.errors.len(), 1);
-        assert_eq!(result.errors[0].field, "hooks.BadHook");
-    }
-
-    #[test]
-    fn validates_nested_permissions_keys() {
-        // given
-        let source = r#"{"permissions": {"allow": ["Read"], "denyAll": true}}"#;
-        let parsed = JsonValue::parse(source).expect("valid json");
-        let object = parsed.as_object().expect("object");
-
-        // when
-        let result = validate_config_file(object, source, &test_path());
-
-        // then
-        assert_eq!(result.errors.len(), 1);
-        assert_eq!(result.errors[0].field, "permissions.denyAll");
-    }
-
-    #[test]
-    fn validates_nested_sandbox_keys() {
-        // given
-        let source = r#"{"sandbox": {"enabled": true, "containerMode": "strict"}}"#;
-        let parsed = JsonValue::parse(source).expect("valid json");
-        let object = parsed.as_object().expect("object");
-
-        // when
-        let result = validate_config_file(object, source, &test_path());
-
-        // then
-        assert_eq!(result.errors.len(), 1);
-        assert_eq!(result.errors[0].field, "sandbox.containerMode");
-    }
-
-    #[test]
-    fn validates_nested_plugins_keys() {
-        // given
-        let source = r#"{"plugins": {"installRoot": "/tmp", "autoUpdate": true}}"#;
-        let parsed = JsonValue::parse(source).expect("valid json");
-        let object = parsed.as_object().expect("object");
-
-        // when
-        let result = validate_config_file(object, source, &test_path());
-
-        // then
-        assert_eq!(result.errors.len(), 1);
-        assert_eq!(result.errors[0].field, "plugins.autoUpdate");
-    }
-
-    #[test]
-    fn validates_nested_oauth_keys() {
-        // given
-        let source = r#"{"oauth": {"clientId": "abc", "secret": "hidden"}}"#;
-        let parsed = JsonValue::parse(source).expect("valid json");
-        let object = parsed.as_object().expect("object");
-
-        // when
-        let result = validate_config_file(object, source, &test_path());
-
-        // then
-        assert_eq!(result.errors.len(), 1);
-        assert_eq!(result.errors[0].field, "oauth.secret");
-    }
-
-    #[test]
-    fn valid_config_produces_no_diagnostics() {
-        // given
-        let source = r#"{
-  "model": "opus",
-  "hooks": {"PreToolUse": ["guard"]},
-  "permissions": {"defaultMode": "plan", "allow": ["Read"]},
-  "mcpServers": {},
-  "sandbox": {"enabled": false}
-}"#;
-        let parsed = JsonValue::parse(source).expect("valid json");
-        let object = parsed.as_object().expect("object");
-
-        // when
-        let result = validate_config_file(object, source, &test_path());
-
-        // then
-        assert!(result.is_ok());
-        assert!(result.warnings.is_empty());
-    }
-
-    #[test]
-    fn suggests_close_field_name() {
-        // given
-        let source = r#"{"modle": "opus"}"#;
-        let parsed = JsonValue::parse(source).expect("valid json");
-        let object = parsed.as_object().expect("object");
-
-        // when
-        let result = validate_config_file(object, source, &test_path());
-
-        // then
-        assert_eq!(result.errors.len(), 1);
-        match &result.errors[0].kind {
-            DiagnosticKind::UnknownKey {
-                suggestion: Some(s),
-            } => assert_eq!(s, "model"),
-            other => panic!("expected suggestion, got {other:?}"),
-        }
-    }
-
-    #[test]
-    fn format_diagnostics_includes_all_entries() {
-        // given
-        let source = r#"{"permissionMode": "plan", "badKey": 1}"#;
-        let parsed = JsonValue::parse(source).expect("valid json");
-        let object = parsed.as_object().expect("object");
-        let result = validate_config_file(object, source, &test_path());
-
-        // when
-        let output = format_diagnostics(&result);
-
-        // then
-        assert!(output.contains("warning:"));
-        assert!(output.contains("error:"));
-        assert!(output.contains("badKey"));
-        assert!(output.contains("permissionMode"));
-    }
-
-    #[test]
-    fn check_unsupported_format_rejects_toml() {
-        // given
-        let path = PathBuf::from("/home/.claw/settings.toml");
-
-        // when
-        let result = check_unsupported_format(&path);
-
-        // then
-        assert!(result.is_err());
-        let message = result.unwrap_err().to_string();
-        assert!(message.contains("TOML"));
-        assert!(message.contains("settings.toml"));
-    }
-
-    #[test]
-    fn check_unsupported_format_allows_json() {
-        // given
-        let path = PathBuf::from("/home/.claw/settings.json");
-
-        // when / then
-        assert!(check_unsupported_format(&path).is_ok());
-    }
-
-    #[test]
-    fn wrong_type_in_nested_sandbox_field() {
-        // given
-        let source = r#"{"sandbox": {"enabled": "yes"}}"#;
-        let parsed = JsonValue::parse(source).expect("valid json");
-        let object = parsed.as_object().expect("object");
-
-        // when
-        let result = validate_config_file(object, source, &test_path());
-
-        // then
-        assert_eq!(result.errors.len(), 1);
-        assert_eq!(result.errors[0].field, "sandbox.enabled");
-        assert!(matches!(
-            result.errors[0].kind,
-            DiagnosticKind::WrongType {
-                expected: "a boolean",
-                got: "a string"
-            }
-        ));
-    }
-
-    #[test]
-    fn display_format_unknown_key_with_line() {
-        // given
-        let diag = ConfigDiagnostic {
-            path: "/test/settings.json".to_string(),
-            field: "badKey".to_string(),
-            line: Some(5),
-            kind: DiagnosticKind::UnknownKey { suggestion: None },
-        };
-
-        // when
-        let output = diag.to_string();
-
-        // then
-        assert_eq!(
-            output,
-            r#"/test/settings.json: unknown key "badKey" (line 5)"#
-        );
-    }
-
-    #[test]
-    fn display_format_wrong_type_with_line() {
-        // given
-        let diag = ConfigDiagnostic {
-            path: "/test/settings.json".to_string(),
-            field: "model".to_string(),
-            line: Some(2),
-            kind: DiagnosticKind::WrongType {
-                expected: "a string",
-                got: "a number",
-            },
-        };
-
-        // when
-        let output = diag.to_string();
-
-        // then
-        assert_eq!(
-            output,
-            r#"/test/settings.json: field "model" must be a string, got a number (line 2)"#
-        );
-    }
-
-    #[test]
-    fn display_format_deprecated_with_line() {
-        // given
-        let diag = ConfigDiagnostic {
-            path: "/test/settings.json".to_string(),
-            field: "permissionMode".to_string(),
-            line: Some(3),
-            kind: DiagnosticKind::Deprecated {
-                replacement: "permissions.defaultMode",
-            },
-        };
-
-        // when
-        let output = diag.to_string();
-
-        // then
-        assert_eq!(
-            output,
-            r#"/test/settings.json: field "permissionMode" is deprecated (line 3). Use "permissions.defaultMode" instead"#
-        );
-    }
-}

rust/crates/runtime/src/file_ops.rs

@@ -1,5 +1,4 @@
 use std::cmp::Reverse;
-use std::collections::HashSet;
 use std::fs;
 use std::io;
 use std::path::{Path, PathBuf};
@@ -8,52 +7,8 @@ use std::time::Instant;
 use glob::Pattern;
 use regex::RegexBuilder;
 use serde::{Deserialize, Serialize};
-use walkdir::{DirEntry, WalkDir};
+use walkdir::WalkDir;
 
-/// Maximum file size that can be read (10 MB).
-const MAX_READ_SIZE: u64 = 10 * 1024 * 1024;
-
-/// Maximum file size that can be written (10 MB).
-const MAX_WRITE_SIZE: usize = 10 * 1024 * 1024;
-
-const GLOB_SEARCH_IGNORED_DIRS: &[&str] = &[
-    ".git",
-    "node_modules",
-    ".build",
-    "target",
-    "dist",
-    "coverage",
-];
-
-/// Check whether a file appears to contain binary content by examining
-/// the first chunk for NUL bytes.
-fn is_binary_file(path: &Path) -> io::Result<bool> {
-    use std::io::Read;
-    let mut file = fs::File::open(path)?;
-    let mut buffer = [0u8; 8192];
-    let bytes_read = file.read(&mut buffer)?;
-    Ok(buffer[..bytes_read].contains(&0))
-}
-
-/// 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(
-            io::ErrorKind::PermissionDenied,
-            format!(
-                "path {} escapes workspace boundary {}",
-                resolved.display(),
-                workspace_root.display()
-            ),
-        ));
-    }
-    Ok(())
-}
-
-/// Text payload returned by file-reading operations.
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 pub struct TextFilePayload {
     #[serde(rename = "filePath")]
@@ -67,7 +22,6 @@ pub struct TextFilePayload {
     pub total_lines: usize,
 }
 
-/// Output envelope for the `read_file` tool.
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 pub struct ReadFileOutput {
     #[serde(rename = "type")]
@@ -75,7 +29,6 @@ pub struct ReadFileOutput {
     pub file: TextFilePayload,
 }
 
-/// Structured patch hunk emitted by write and edit operations.
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 pub struct StructuredPatchHunk {
     #[serde(rename = "oldStart")]
@@ -89,7 +42,6 @@ pub struct StructuredPatchHunk {
     pub lines: Vec<String>,
 }
 
-/// Output envelope for full-file write operations.
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 pub struct WriteFileOutput {
     #[serde(rename = "type")]
@@ -105,7 +57,6 @@ pub struct WriteFileOutput {
     pub git_diff: Option<serde_json::Value>,
 }
 
-/// Output envelope for targeted string-replacement edits.
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 pub struct EditFileOutput {
     #[serde(rename = "filePath")]
@@ -126,7 +77,6 @@ pub struct EditFileOutput {
     pub git_diff: Option<serde_json::Value>,
 }
 
-/// Result of a glob-based filename search.
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub struct GlobSearchOutput {
     #[serde(rename = "durationMs")]
@@ -137,7 +87,6 @@ pub struct GlobSearchOutput {
     pub truncated: bool,
 }
 
-/// Parameters accepted by the grep-style search tool.
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 pub struct GrepSearchInput {
     pub pattern: String,
@@ -163,7 +112,6 @@ pub struct GrepSearchInput {
     pub multiline: Option<bool>,
 }
 
-/// Result payload returned by the grep-style search tool.
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 pub struct GrepSearchOutput {
     pub mode: Option<String>,
@@ -181,35 +129,12 @@ pub struct GrepSearchOutput {
     pub applied_offset: Option<usize>,
 }
 
-/// Reads a text file and returns a line-windowed payload.
 pub fn read_file(
     path: &str,
     offset: Option<usize>,
     limit: Option<usize>,
 ) -> io::Result<ReadFileOutput> {
     let absolute_path = normalize_path(path)?;
-
-    // Check file size before reading
-    let metadata = fs::metadata(&absolute_path)?;
-    if metadata.len() > MAX_READ_SIZE {
-        return Err(io::Error::new(
-            io::ErrorKind::InvalidData,
-            format!(
-                "file is too large ({} bytes, max {} bytes)",
-                metadata.len(),
-                MAX_READ_SIZE
-            ),
-        ));
-    }
-
-    // Detect binary files
-    if is_binary_file(&absolute_path)? {
-        return Err(io::Error::new(
-            io::ErrorKind::InvalidData,
-            "file appears to be binary",
-        ));
-    }
-
     let content = fs::read_to_string(&absolute_path)?;
     let lines: Vec<&str> = content.lines().collect();
     let start_index = offset.unwrap_or(0).min(lines.len());
@@ -230,19 +155,7 @@ pub fn read_file(
     })
 }
 
-/// Replaces a file's contents and returns patch metadata.
 pub fn write_file(path: &str, content: &str) -> io::Result<WriteFileOutput> {
-    if content.len() > MAX_WRITE_SIZE {
-        return Err(io::Error::new(
-            io::ErrorKind::InvalidData,
-            format!(
-                "content is too large ({} bytes, max {} bytes)",
-                content.len(),
-                MAX_WRITE_SIZE
-            ),
-        ));
-    }
-
     let absolute_path = normalize_path_allow_missing(path)?;
     let original_file = fs::read_to_string(&absolute_path).ok();
     if let Some(parent) = absolute_path.parent() {
@@ -264,7 +177,6 @@ pub fn write_file(path: &str, content: &str) -> io::Result<WriteFileOutput> {
     })
 }
 
-/// Performs an in-file string replacement and returns patch metadata.
 pub fn edit_file(
     path: &str,
     old_string: &str,
@@ -305,63 +217,24 @@ pub fn edit_file(
     })
 }
 
-/// Expands a glob pattern and returns matching filenames.
 pub fn glob_search(pattern: &str, path: Option<&str>) -> io::Result<GlobSearchOutput> {
-    glob_search_impl(pattern, path, None)
-}
-
-fn glob_search_impl(
-    pattern: &str,
-    path: Option<&str>,
-    workspace_root: Option<&Path>,
-) -> io::Result<GlobSearchOutput> {
     let started = Instant::now();
     let base_dir = path
         .map(normalize_path)
         .transpose()?
         .unwrap_or(std::env::current_dir()?);
-    let canonical_root = workspace_root.map(canonicalize_workspace_root);
-    if let Some(root) = canonical_root.as_deref() {
-        validate_workspace_boundary(&base_dir, root)?;
-    }
     let search_pattern = if Path::new(pattern).is_absolute() {
         pattern.to_owned()
     } else {
         base_dir.join(pattern).to_string_lossy().into_owned()
     };
 
-    // The `glob` crate does not support brace expansion ({a,b,c}).
-    // Expand braces into multiple patterns so patterns like
-    // `Assets/**/*.{cs,uxml,uss}` work correctly.
-    let expanded = expand_braces(&search_pattern);
-
-    let mut seen = HashSet::new();
     let mut matches = Vec::new();
-    for pat in &expanded {
-        let compiled = Pattern::new(pat)
-            .map_err(|error| io::Error::new(io::ErrorKind::InvalidInput, error.to_string()))?;
-        let walk_root = derive_glob_walk_root(pat);
-        if let Some(root) = canonical_root.as_deref() {
-            let canonical_walk_root = walk_root
-                .canonicalize()
-                .unwrap_or_else(|_| walk_root.clone());
-            validate_workspace_boundary(&canonical_walk_root, root)?;
-        }
-        let entries = WalkDir::new(&walk_root)
-            .into_iter()
-            .filter_entry(|entry| !should_skip_glob_dir(entry));
-        for entry in entries.flatten() {
-            let candidate = entry.path();
-            if entry.file_type().is_file()
-                && compiled.matches_path(candidate)
-                && seen.insert(candidate.to_path_buf())
-            {
-                if let Some(root) = canonical_root.as_deref() {
-                    let canonical_candidate = candidate.canonicalize()?;
-                    validate_workspace_boundary(&canonical_candidate, root)?;
-                }
-                matches.push(candidate.to_path_buf());
-            }
+    let entries = glob::glob(&search_pattern)
+        .map_err(|error| io::Error::new(io::ErrorKind::InvalidInput, error.to_string()))?;
+    for entry in entries.flatten() {
+        if entry.is_file() {
+            matches.push(entry);
         }
     }
 
@@ -387,25 +260,13 @@ fn glob_search_impl(
     })
 }
 
-/// Runs a regex search over workspace files with optional context lines.
 pub fn grep_search(input: &GrepSearchInput) -> io::Result<GrepSearchOutput> {
-    grep_search_impl(input, None)
-}
-
-fn grep_search_impl(
-    input: &GrepSearchInput,
-    workspace_root: Option<&Path>,
-) -> io::Result<GrepSearchOutput> {
     let base_path = input
         .path
         .as_deref()
         .map(normalize_path)
         .transpose()?
         .unwrap_or(std::env::current_dir()?);
-    let canonical_root = workspace_root.map(canonicalize_workspace_root);
-    if let Some(root) = canonical_root.as_deref() {
-        validate_workspace_boundary(&base_path, root)?;
-    }
 
     let regex = RegexBuilder::new(&input.pattern)
         .case_insensitive(input.case_insensitive.unwrap_or(false))
@@ -431,10 +292,6 @@ fn grep_search_impl(
     let mut total_matches = 0usize;
 
     for file_path in collect_search_files(&base_path)? {
-        if let Some(root) = canonical_root.as_deref() {
-            let canonical_file = file_path.canonicalize()?;
-            validate_workspace_boundary(&canonical_file, root)?;
-        }
         if !matches_optional_filters(&file_path, glob_filter.as_ref(), file_type) {
             continue;
         }
@@ -484,21 +341,27 @@ fn grep_search_impl(
 
     let (filenames, applied_limit, applied_offset) =
         apply_limit(filenames, input.head_limit, input.offset);
-    if output_mode == "content" {
-        return Ok(build_grep_content_output(
-            output_mode,
+    let content_output = if output_mode == "content" {
+        let (lines, limit, offset) = apply_limit(content_lines, input.head_limit, input.offset);
+        return Ok(GrepSearchOutput {
+            mode: Some(output_mode),
+            num_files: filenames.len(),
             filenames,
-            content_lines,
-            input.head_limit,
-            input.offset,
-        ));
-    }
+            num_lines: Some(lines.len()),
+            content: Some(lines.join("\n")),
+            num_matches: None,
+            applied_limit: limit,
+            applied_offset: offset,
+        });
+    } else {
+        None
+    };
 
     Ok(GrepSearchOutput {
         mode: Some(output_mode.clone()),
         num_files: filenames.len(),
         filenames,
-        content: None,
+        content: content_output,
         num_lines: None,
         num_matches: (output_mode == "count").then_some(total_matches),
         applied_limit,
@@ -506,65 +369,6 @@ fn grep_search_impl(
     })
 }
 
-fn build_grep_content_output(
-    output_mode: String,
-    filenames: Vec<String>,
-    content_lines: Vec<String>,
-    head_limit: Option<usize>,
-    offset: Option<usize>,
-) -> GrepSearchOutput {
-    let (lines, limit, offset) = apply_limit(content_lines, head_limit, offset);
-    GrepSearchOutput {
-        mode: Some(output_mode),
-        num_files: filenames.len(),
-        filenames,
-        num_lines: Some(lines.len()),
-        content: Some(lines.join("\n")),
-        num_matches: None,
-        applied_limit: limit,
-        applied_offset: offset,
-    }
-}
-
-fn canonicalize_workspace_root(workspace_root: &Path) -> PathBuf {
-    workspace_root
-        .canonicalize()
-        .unwrap_or_else(|_| workspace_root.to_path_buf())
-}
-
-fn should_skip_glob_dir(entry: &DirEntry) -> bool {
-    entry.file_type().is_dir()
-        && entry
-            .file_name()
-            .to_str()
-            .is_some_and(|name| GLOB_SEARCH_IGNORED_DIRS.contains(&name))
-}
-
-fn derive_glob_walk_root(pattern: &str) -> PathBuf {
-    let path = Path::new(pattern);
-    let mut prefix = PathBuf::new();
-    let mut saw_component = false;
-
-    for component in path.components() {
-        let text = component.as_os_str().to_string_lossy();
-        if component_contains_glob(&text) {
-            break;
-        }
-        prefix.push(component.as_os_str());
-        saw_component = true;
-    }
-
-    if saw_component {
-        prefix
-    } else {
-        std::env::current_dir().unwrap_or_else(|_| PathBuf::from("."))
-    }
-}
-
-fn component_contains_glob(component: &str) -> bool {
-    component.contains('*') || component.contains('?') || component.contains('[')
-}
-
 fn collect_search_files(base_path: &Path) -> io::Result<Vec<PathBuf>> {
     if base_path.is_file() {
         return Ok(vec![base_path.to_path_buf()]);
@@ -673,113 +477,11 @@ fn normalize_path_allow_missing(path: &str) -> io::Result<PathBuf> {
     Ok(candidate)
 }
 
-/// Read a file with workspace boundary enforcement.
-#[allow(dead_code)]
-pub fn read_file_in_workspace(
-    path: &str,
-    offset: Option<usize>,
-    limit: Option<usize>,
-    workspace_root: &Path,
-) -> io::Result<ReadFileOutput> {
-    let absolute_path = normalize_path(path)?;
-    let canonical_root = canonicalize_workspace_root(workspace_root);
-    validate_workspace_boundary(&absolute_path, &canonical_root)?;
-    read_file(path, offset, limit)
-}
-
-/// Write a file with workspace boundary enforcement.
-#[allow(dead_code)]
-pub fn write_file_in_workspace(
-    path: &str,
-    content: &str,
-    workspace_root: &Path,
-) -> io::Result<WriteFileOutput> {
-    let absolute_path = normalize_path_allow_missing(path)?;
-    let canonical_root = canonicalize_workspace_root(workspace_root);
-    validate_workspace_boundary(&absolute_path, &canonical_root)?;
-    write_file(path, content)
-}
-
-/// Edit a file with workspace boundary enforcement.
-#[allow(dead_code)]
-pub fn edit_file_in_workspace(
-    path: &str,
-    old_string: &str,
-    new_string: &str,
-    replace_all: bool,
-    workspace_root: &Path,
-) -> io::Result<EditFileOutput> {
-    let absolute_path = normalize_path(path)?;
-    let canonical_root = canonicalize_workspace_root(workspace_root);
-    validate_workspace_boundary(&absolute_path, &canonical_root)?;
-    edit_file(path, old_string, new_string, replace_all)
-}
-
-/// Expand a glob pattern with workspace boundary enforcement.
-#[allow(dead_code)]
-pub fn glob_search_in_workspace(
-    pattern: &str,
-    path: Option<&str>,
-    workspace_root: &Path,
-) -> io::Result<GlobSearchOutput> {
-    glob_search_impl(pattern, path, Some(workspace_root))
-}
-
-/// Search file contents with workspace boundary enforcement.
-#[allow(dead_code)]
-pub fn grep_search_in_workspace(
-    input: &GrepSearchInput,
-    workspace_root: &Path,
-) -> io::Result<GrepSearchOutput> {
-    grep_search_impl(input, Some(workspace_root))
-}
-
-/// 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() {
-        return Ok(false);
-    }
-    let resolved = path.canonicalize()?;
-    let canonical_root = workspace_root
-        .canonicalize()
-        .unwrap_or_else(|_| workspace_root.to_path_buf());
-    Ok(!resolved.starts_with(&canonical_root))
-}
-
-/// Expand shell-style brace groups in a glob pattern.
-///
-/// Handles one level of braces: `foo.{a,b,c}` → `["foo.a", "foo.b", "foo.c"]`.
-/// Nested braces are not expanded (uncommon in practice).
-/// Patterns without braces pass through unchanged.
-fn expand_braces(pattern: &str) -> Vec<String> {
-    let Some(open) = pattern.find('{') else {
-        return vec![pattern.to_owned()];
-    };
-    let Some(close) = pattern[open..].find('}').map(|i| open + i) else {
-        // Unmatched brace — treat as literal.
-        return vec![pattern.to_owned()];
-    };
-    let prefix = &pattern[..open];
-    let suffix = &pattern[close + 1..];
-    let alternatives = &pattern[open + 1..close];
-    alternatives
-        .split(',')
-        .flat_map(|alt| expand_braces(&format!("{prefix}{alt}{suffix}")))
-        .collect()
-}
-
 #[cfg(test)]
 mod tests {
-    use std::path::PathBuf;
     use std::time::{SystemTime, UNIX_EPOCH};
 
-    use super::{
-        component_contains_glob, derive_glob_walk_root, edit_file, expand_braces, glob_search,
-        grep_search, is_symlink_escape, read_file, read_file_in_workspace, write_file,
-        write_file_in_workspace, GrepSearchInput, MAX_WRITE_SIZE,
-    };
+    use super::{edit_file, glob_search, grep_search, read_file, write_file, GrepSearchInput};
 
     fn temp_path(name: &str) -> std::path::PathBuf {
         let unique = SystemTime::now()
@@ -811,135 +513,6 @@ mod tests {
         assert!(output.replace_all);
     }
 
-    #[test]
-    fn rejects_binary_files() {
-        let path = temp_path("binary-test.bin");
-        std::fs::write(&path, b"\x00\x01\x02\x03binary content").expect("write should succeed");
-        let result = read_file(path.to_string_lossy().as_ref(), None, None);
-        assert!(result.is_err());
-        let error = result.unwrap_err();
-        assert_eq!(error.kind(), std::io::ErrorKind::InvalidData);
-        assert!(error.to_string().contains("binary"));
-    }
-
-    #[test]
-    fn rejects_oversized_writes() {
-        let path = temp_path("oversize-write.txt");
-        let huge = "x".repeat(MAX_WRITE_SIZE + 1);
-        let result = write_file(path.to_string_lossy().as_ref(), &huge);
-        assert!(result.is_err());
-        let error = result.unwrap_err();
-        assert_eq!(error.kind(), std::io::ErrorKind::InvalidData);
-        assert!(error.to_string().contains("too large"));
-    }
-
-    #[test]
-    fn enforces_workspace_boundary() {
-        let workspace = temp_path("workspace-boundary");
-        std::fs::create_dir_all(&workspace).expect("workspace dir should be created");
-        let inside = workspace.join("inside.txt");
-        write_file(inside.to_string_lossy().as_ref(), "safe content")
-            .expect("write inside workspace should succeed");
-
-        // Reading inside workspace should succeed
-        let result =
-            read_file_in_workspace(inside.to_string_lossy().as_ref(), None, None, &workspace);
-        assert!(result.is_ok());
-
-        // Reading outside workspace should fail
-        let outside = temp_path("outside-boundary.txt");
-        write_file(outside.to_string_lossy().as_ref(), "unsafe content")
-            .expect("write outside should succeed");
-        let result =
-            read_file_in_workspace(outside.to_string_lossy().as_ref(), None, None, &workspace);
-        assert!(result.is_err());
-        let error = result.unwrap_err();
-        assert_eq!(error.kind(), std::io::ErrorKind::PermissionDenied);
-        assert!(error.to_string().contains("escapes workspace"));
-    }
-
-    #[test]
-    fn detects_symlink_escape() {
-        let workspace = temp_path("symlink-workspace");
-        std::fs::create_dir_all(&workspace).expect("workspace dir should be created");
-        let outside = temp_path("symlink-target.txt");
-        std::fs::write(&outside, "target content").expect("target should write");
-
-        let link_path = workspace.join("escape-link.txt");
-        #[cfg(unix)]
-        {
-            std::os::unix::fs::symlink(&outside, &link_path).expect("symlink should create");
-            assert!(is_symlink_escape(&link_path, &workspace).expect("check should succeed"));
-        }
-
-        // Non-symlink file should not be an escape
-        let normal = workspace.join("normal.txt");
-        std::fs::write(&normal, "normal content").expect("normal file should write");
-        assert!(!is_symlink_escape(&normal, &workspace).expect("check should succeed"));
-    }
-
-    #[test]
-    #[cfg(unix)]
-    fn workspace_read_rejects_symlink_escape_regression_3007_class() {
-        let workspace = temp_path("workspace-read-symlink-escape");
-        let outside = temp_path("workspace-read-symlink-target");
-        std::fs::create_dir_all(&workspace).expect("workspace dir should be created");
-        std::fs::create_dir_all(&outside).expect("outside dir should be created");
-        let outside_file = outside.join("secret.txt");
-        std::fs::write(&outside_file, "outside secret").expect("outside file should write");
-
-        let link_path = workspace.join("linked-secret.txt");
-        std::os::unix::fs::symlink(&outside_file, &link_path).expect("symlink should create");
-
-        let result =
-            read_file_in_workspace(link_path.to_string_lossy().as_ref(), None, None, &workspace);
-
-        assert!(result.is_err(), "symlink escape must be rejected");
-        let error = result.unwrap_err();
-        assert_eq!(error.kind(), std::io::ErrorKind::PermissionDenied);
-        assert!(
-            error.to_string().contains("escapes workspace"),
-            "error should explain workspace escape: {error}"
-        );
-
-        let _ = std::fs::remove_dir_all(&workspace);
-        let _ = std::fs::remove_dir_all(&outside);
-    }
-
-    #[test]
-    #[cfg(unix)]
-    fn workspace_write_rejects_parent_symlink_escape_regression_3007_class() {
-        let workspace = temp_path("workspace-write-symlink-escape");
-        let outside = temp_path("workspace-write-symlink-target");
-        std::fs::create_dir_all(&workspace).expect("workspace dir should be created");
-        std::fs::create_dir_all(&outside).expect("outside dir should be created");
-
-        let link_dir = workspace.join("linked-outside");
-        std::os::unix::fs::symlink(&outside, &link_dir).expect("symlink dir should create");
-        let escaped_child = link_dir.join("created.txt");
-
-        let result = write_file_in_workspace(
-            escaped_child.to_string_lossy().as_ref(),
-            "must not escape",
-            &workspace,
-        );
-
-        assert!(result.is_err(), "parent symlink escape must be rejected");
-        let error = result.unwrap_err();
-        assert_eq!(error.kind(), std::io::ErrorKind::PermissionDenied);
-        assert!(
-            error.to_string().contains("escapes workspace"),
-            "error should explain workspace escape: {error}"
-        );
-        assert!(
-            !outside.join("created.txt").exists(),
-            "write should not create through an escaping symlink"
-        );
-
-        let _ = std::fs::remove_dir_all(&workspace);
-        let _ = std::fs::remove_dir_all(&outside);
-    }
-
     #[test]
     fn globs_and_greps_directory() {
         let dir = temp_path("search-dir");
@@ -974,97 +547,4 @@ mod tests {
         .expect("grep should succeed");
         assert!(grep_output.content.unwrap_or_default().contains("hello"));
     }
-
-    #[test]
-    fn expand_braces_no_braces() {
-        assert_eq!(expand_braces("*.rs"), vec!["*.rs"]);
-    }
-
-    #[test]
-    fn expand_braces_single_group() {
-        let mut result = expand_braces("Assets/**/*.{cs,uxml,uss}");
-        result.sort();
-        assert_eq!(
-            result,
-            vec!["Assets/**/*.cs", "Assets/**/*.uss", "Assets/**/*.uxml",]
-        );
-    }
-
-    #[test]
-    fn expand_braces_nested() {
-        let mut result = expand_braces("src/{a,b}.{rs,toml}");
-        result.sort();
-        assert_eq!(
-            result,
-            vec!["src/a.rs", "src/a.toml", "src/b.rs", "src/b.toml"]
-        );
-    }
-
-    #[test]
-    fn expand_braces_unmatched() {
-        assert_eq!(expand_braces("foo.{bar"), vec!["foo.{bar"]);
-    }
-
-    #[test]
-    fn glob_search_with_braces_finds_files() {
-        let dir = temp_path("glob-braces");
-        std::fs::create_dir_all(&dir).unwrap();
-        std::fs::write(dir.join("a.rs"), "fn main() {}").unwrap();
-        std::fs::write(dir.join("b.toml"), "[package]").unwrap();
-        std::fs::write(dir.join("c.txt"), "hello").unwrap();
-
-        let result =
-            glob_search("*.{rs,toml}", Some(dir.to_str().unwrap())).expect("glob should succeed");
-        assert_eq!(
-            result.num_files, 2,
-            "should match .rs and .toml but not .txt"
-        );
-        let _ = std::fs::remove_dir_all(&dir);
-    }
-
-    #[test]
-    fn glob_search_skips_common_heavy_directories() {
-        let dir = temp_path("glob-ignored-dirs");
-        std::fs::create_dir_all(dir.join("src")).unwrap();
-        std::fs::create_dir_all(dir.join("docs")).unwrap();
-        std::fs::create_dir_all(dir.join("node_modules/pkg")).unwrap();
-        std::fs::create_dir_all(dir.join(".build/checkouts/pkg")).unwrap();
-        std::fs::create_dir_all(dir.join("target/debug/deps")).unwrap();
-
-        std::fs::write(dir.join("src/AGENTS.md"), "src").unwrap();
-        std::fs::write(dir.join("docs/AGENTS.md"), "docs").unwrap();
-        std::fs::write(dir.join("node_modules/pkg/AGENTS.md"), "node_modules").unwrap();
-        std::fs::write(dir.join(".build/checkouts/pkg/AGENTS.md"), ".build").unwrap();
-        std::fs::write(dir.join("target/debug/deps/AGENTS.md"), "target").unwrap();
-
-        let result =
-            glob_search("**/AGENTS.md", Some(dir.to_str().unwrap())).expect("glob should succeed");
-
-        assert_eq!(result.num_files, 2, "ignored dirs should be pruned");
-        assert!(result
-            .filenames
-            .iter()
-            .any(|path| path.ends_with("src/AGENTS.md")));
-        assert!(result
-            .filenames
-            .iter()
-            .any(|path| path.ends_with("docs/AGENTS.md")));
-        assert!(!result
-            .filenames
-            .iter()
-            .any(|path| path.contains("node_modules")
-                || path.contains(".build")
-                || path.contains("/target/")));
-
-        let _ = std::fs::remove_dir_all(&dir);
-    }
-
-    #[test]
-    fn derive_glob_walk_root_stops_at_first_glob_component() {
-        let root = derive_glob_walk_root("/tmp/demo/**/AGENTS.md");
-        assert_eq!(root, PathBuf::from("/tmp/demo"));
-        assert!(component_contains_glob("**"));
-        assert!(component_contains_glob("*.rs"));
-        assert!(!component_contains_glob("src"));
-    }
 }

rust/crates/runtime/src/g004_conformance.rs

@@ -1,399 +0,0 @@
-//! Machine-checkable conformance helpers for G004 event/report contract bundles.
-//!
-//! The harness intentionally validates JSON-shaped artifacts instead of owning the
-//! lane-event, report, or approval-token implementations. This keeps it usable by
-//! independent implementation lanes and by golden fixtures produced outside the
-//! runtime crate.
-
-use serde_json::Value;
-
-const BUNDLE_SCHEMA_VERSION: &str = "g004.contract.bundle.v1";
-const REPORT_SCHEMA_VERSION: &str = "g004.report.v1";
-
-/// A single conformance validation failure.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct G004ConformanceError {
-    /// JSON pointer-ish path to the invalid field.
-    pub path: String,
-    /// Human-readable reason the field failed validation.
-    pub message: String,
-}
-
-impl G004ConformanceError {
-    fn new(path: impl Into<String>, message: impl Into<String>) -> Self {
-        Self {
-            path: path.into(),
-            message: message.into(),
-        }
-    }
-}
-
-/// Validate a G004 golden contract bundle.
-///
-/// The bundle shape is deliberately small and cross-lane:
-/// - `laneEvents[]` must expose stable event identity, ordering/provenance, and
-///   terminal dedupe fingerprints.
-/// - `reports[]` must expose schema identity, content hash, projection/redaction
-///   provenance, capability negotiation, fact/hypothesis/negative-evidence
-///   labels, confidence, and field-level delta attribution.
-/// - `approvalTokens[]` must expose owner/scope, delegation chain, one-time-use,
-///   and replay-prevention fields.
-#[must_use]
-pub fn validate_g004_contract_bundle(bundle: &Value) -> Vec<G004ConformanceError> {
-    let mut errors = Vec::new();
-
-    require_string_eq(bundle, "/schemaVersion", BUNDLE_SCHEMA_VERSION, &mut errors);
-    validate_lane_events(bundle.get("laneEvents"), "/laneEvents", &mut errors);
-    validate_reports(bundle.get("reports"), "/reports", &mut errors);
-    validate_approval_tokens(bundle.get("approvalTokens"), "/approvalTokens", &mut errors);
-
-    errors
-}
-
-#[must_use]
-pub fn is_g004_contract_bundle_valid(bundle: &Value) -> bool {
-    validate_g004_contract_bundle(bundle).is_empty()
-}
-
-fn validate_lane_events(value: Option<&Value>, path: &str, errors: &mut Vec<G004ConformanceError>) {
-    let Some(events) = non_empty_array(value, path, errors) else {
-        return;
-    };
-
-    let mut previous_seq = None;
-    for (index, event) in events.iter().enumerate() {
-        let base = format!("{path}/{index}");
-        require_non_empty_string_at(event, "/event", &format!("{base}/event"), errors);
-        require_non_empty_string_at(event, "/status", &format!("{base}/status"), errors);
-        require_non_empty_string_at(event, "/emittedAt", &format!("{base}/emittedAt"), errors);
-        require_non_empty_string_at(
-            event,
-            "/metadata/provenance",
-            &format!("{base}/metadata/provenance"),
-            errors,
-        );
-        require_non_empty_string_at(
-            event,
-            "/metadata/emitterIdentity",
-            &format!("{base}/metadata/emitterIdentity"),
-            errors,
-        );
-        require_non_empty_string_at(
-            event,
-            "/metadata/environmentLabel",
-            &format!("{base}/metadata/environmentLabel"),
-            errors,
-        );
-
-        match get_path(event, "/metadata/seq").and_then(Value::as_u64) {
-            Some(seq) => {
-                if let Some(previous) = previous_seq {
-                    if seq <= previous {
-                        errors.push(G004ConformanceError::new(
-                            format!("{base}/metadata/seq"),
-                            "sequence must be strictly increasing",
-                        ));
-                    }
-                }
-                previous_seq = Some(seq);
-            }
-            None => errors.push(G004ConformanceError::new(
-                format!("{base}/metadata/seq"),
-                "required u64 field missing",
-            )),
-        }
-
-        if is_terminal_event_value(event.get("event")) {
-            require_non_empty_string_at(
-                event,
-                "/metadata/eventFingerprint",
-                &format!("{base}/metadata/eventFingerprint"),
-                errors,
-            );
-        }
-    }
-}
-
-fn validate_reports(value: Option<&Value>, path: &str, errors: &mut Vec<G004ConformanceError>) {
-    let Some(reports) = non_empty_array(value, path, errors) else {
-        return;
-    };
-
-    for (index, report) in reports.iter().enumerate() {
-        let base = format!("{path}/{index}");
-        require_string_eq_at(
-            report,
-            "/schemaVersion",
-            &format!("{base}/schemaVersion"),
-            REPORT_SCHEMA_VERSION,
-            errors,
-        );
-        require_non_empty_string_at(report, "/reportId", &format!("{base}/reportId"), errors);
-        require_non_empty_string_at(
-            report,
-            "/identity/contentHash",
-            &format!("{base}/identity/contentHash"),
-            errors,
-        );
-        require_non_empty_string_at(
-            report,
-            "/projection/provenance",
-            &format!("{base}/projection/provenance"),
-            errors,
-        );
-        require_non_empty_string_at(
-            report,
-            "/redaction/provenance",
-            &format!("{base}/redaction/provenance"),
-            errors,
-        );
-        non_empty_array(
-            get_path(report, "/consumerCapabilities"),
-            &format!("{base}/consumerCapabilities"),
-            errors,
-        );
-        validate_findings(
-            get_path(report, "/findings"),
-            &format!("{base}/findings"),
-            errors,
-        );
-        validate_field_deltas(
-            get_path(report, "/fieldDeltas"),
-            &format!("{base}/fieldDeltas"),
-            errors,
-        );
-    }
-}
-
-fn validate_findings(value: Option<&Value>, path: &str, errors: &mut Vec<G004ConformanceError>) {
-    let Some(findings) = non_empty_array(value, path, errors) else {
-        return;
-    };
-
-    for (index, finding) in findings.iter().enumerate() {
-        let base = format!("{path}/{index}");
-        require_one_of_at(
-            finding,
-            "/kind",
-            &format!("{base}/kind"),
-            &["fact", "hypothesis", "negative_evidence"],
-            errors,
-        );
-        require_one_of_at(
-            finding,
-            "/confidence",
-            &format!("{base}/confidence"),
-            &["low", "medium", "high"],
-            errors,
-        );
-        require_non_empty_string_at(finding, "/statement", &format!("{base}/statement"), errors);
-    }
-}
-
-fn validate_field_deltas(
-    value: Option<&Value>,
-    path: &str,
-    errors: &mut Vec<G004ConformanceError>,
-) {
-    let Some(deltas) = non_empty_array(value, path, errors) else {
-        return;
-    };
-
-    for (index, delta) in deltas.iter().enumerate() {
-        let base = format!("{path}/{index}");
-        require_non_empty_string_at(delta, "/field", &format!("{base}/field"), errors);
-        require_non_empty_string_at(
-            delta,
-            "/previousHash",
-            &format!("{base}/previousHash"),
-            errors,
-        );
-        require_non_empty_string_at(
-            delta,
-            "/currentHash",
-            &format!("{base}/currentHash"),
-            errors,
-        );
-        require_non_empty_string_at(
-            delta,
-            "/attribution",
-            &format!("{base}/attribution"),
-            errors,
-        );
-    }
-}
-
-fn validate_approval_tokens(
-    value: Option<&Value>,
-    path: &str,
-    errors: &mut Vec<G004ConformanceError>,
-) {
-    let Some(tokens) = non_empty_array(value, path, errors) else {
-        return;
-    };
-
-    for (index, token) in tokens.iter().enumerate() {
-        let base = format!("{path}/{index}");
-        require_non_empty_string_at(token, "/tokenId", &format!("{base}/tokenId"), errors);
-        require_non_empty_string_at(token, "/owner", &format!("{base}/owner"), errors);
-        require_non_empty_string_at(token, "/scope", &format!("{base}/scope"), errors);
-        require_non_empty_string_at(token, "/issuedAt", &format!("{base}/issuedAt"), errors);
-        require_bool_true_at(token, "/oneTimeUse", &format!("{base}/oneTimeUse"), errors);
-        require_non_empty_string_at(
-            token,
-            "/replayPreventionNonce",
-            &format!("{base}/replayPreventionNonce"),
-            errors,
-        );
-        validate_delegation_chain(
-            get_path(token, "/delegationChain"),
-            &format!("{base}/delegationChain"),
-            errors,
-        );
-    }
-}
-
-fn validate_delegation_chain(
-    value: Option<&Value>,
-    path: &str,
-    errors: &mut Vec<G004ConformanceError>,
-) {
-    let Some(chain) = non_empty_array(value, path, errors) else {
-        return;
-    };
-
-    for (index, hop) in chain.iter().enumerate() {
-        let base = format!("{path}/{index}");
-        require_non_empty_string_at(hop, "/from", &format!("{base}/from"), errors);
-        require_non_empty_string_at(hop, "/to", &format!("{base}/to"), errors);
-        require_non_empty_string_at(hop, "/action", &format!("{base}/action"), errors);
-        require_non_empty_string_at(hop, "/at", &format!("{base}/at"), errors);
-    }
-}
-
-fn non_empty_array<'a>(
-    value: Option<&'a Value>,
-    path: &str,
-    errors: &mut Vec<G004ConformanceError>,
-) -> Option<&'a Vec<Value>> {
-    match value.and_then(Value::as_array) {
-        Some(array) if !array.is_empty() => Some(array),
-        Some(_) => {
-            errors.push(G004ConformanceError::new(path, "array must not be empty"));
-            None
-        }
-        None => {
-            errors.push(G004ConformanceError::new(
-                path,
-                "required array field missing",
-            ));
-            None
-        }
-    }
-}
-
-fn require_string_eq(
-    root: &Value,
-    path: &str,
-    expected: &str,
-    errors: &mut Vec<G004ConformanceError>,
-) {
-    require_string_eq_at(root, path, path, expected, errors);
-}
-
-fn require_string_eq_at(
-    root: &Value,
-    pointer: &str,
-    error_path: &str,
-    expected: &str,
-    errors: &mut Vec<G004ConformanceError>,
-) {
-    match get_path(root, pointer).and_then(Value::as_str) {
-        Some(actual) if actual == expected => {}
-        Some(actual) => errors.push(G004ConformanceError::new(
-            error_path,
-            format!("expected '{expected}', got '{actual}'"),
-        )),
-        None => errors.push(G004ConformanceError::new(
-            error_path,
-            "required string field missing",
-        )),
-    }
-}
-
-fn require_non_empty_string_at(
-    root: &Value,
-    pointer: &str,
-    error_path: &str,
-    errors: &mut Vec<G004ConformanceError>,
-) {
-    match get_path(root, pointer).and_then(Value::as_str) {
-        Some(value) if !value.trim().is_empty() => {}
-        Some(_) => errors.push(G004ConformanceError::new(
-            error_path,
-            "string must not be empty",
-        )),
-        None => errors.push(G004ConformanceError::new(
-            error_path,
-            "required string field missing",
-        )),
-    }
-}
-
-fn require_one_of_at(
-    root: &Value,
-    pointer: &str,
-    error_path: &str,
-    allowed: &[&str],
-    errors: &mut Vec<G004ConformanceError>,
-) {
-    match get_path(root, pointer).and_then(Value::as_str) {
-        Some(value) if allowed.contains(&value) => {}
-        Some(value) => errors.push(G004ConformanceError::new(
-            error_path,
-            format!("'{value}' is not one of {}", allowed.join(", ")),
-        )),
-        None => errors.push(G004ConformanceError::new(
-            error_path,
-            "required string field missing",
-        )),
-    }
-}
-
-fn require_bool_true_at(
-    root: &Value,
-    pointer: &str,
-    error_path: &str,
-    errors: &mut Vec<G004ConformanceError>,
-) {
-    match get_path(root, pointer).and_then(Value::as_bool) {
-        Some(true) => {}
-        Some(false) => errors.push(G004ConformanceError::new(error_path, "must be true")),
-        None => errors.push(G004ConformanceError::new(
-            error_path,
-            "required boolean field missing",
-        )),
-    }
-}
-
-fn is_terminal_event_value(value: Option<&Value>) -> bool {
-    matches!(
-        value.and_then(Value::as_str),
-        Some("lane.finished" | "lane.failed" | "lane.merged" | "lane.superseded" | "lane.closed")
-    )
-}
-
-fn get_path<'a>(root: &'a Value, path: &str) -> Option<&'a Value> {
-    if let Some(value) = root.pointer(path) {
-        return Some(value);
-    }
-
-    let segments = path.trim_start_matches('/').split('/').collect::<Vec<_>>();
-    for index in 1..segments.len() {
-        let relative = format!("/{}", segments[index..].join("/"));
-        if let Some(value) = root.pointer(&relative) {
-            return Some(value);
-        }
-    }
-    None
-}

rust/crates/runtime/src/git_context.rs

@@ -1,324 +0,0 @@
-use std::path::Path;
-use std::process::Command;
-
-/// A single git commit entry from the log.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct GitCommitEntry {
-    pub hash: String,
-    pub subject: String,
-}
-
-/// Git-aware context gathered at startup for injection into the system prompt.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct GitContext {
-    pub branch: Option<String>,
-    pub recent_commits: Vec<GitCommitEntry>,
-    pub staged_files: Vec<String>,
-}
-
-const MAX_RECENT_COMMITS: usize = 5;
-
-impl GitContext {
-    /// Detect the git context from the given working directory.
-    ///
-    /// Returns `None` when the directory is not inside a git repository.
-    #[must_use]
-    pub fn detect(cwd: &Path) -> Option<Self> {
-        // Quick gate: is this a git repo at all?
-        let rev_parse = Command::new("git")
-            .args(["rev-parse", "--is-inside-work-tree"])
-            .current_dir(cwd)
-            .output()
-            .ok()?;
-        if !rev_parse.status.success() {
-            return None;
-        }
-
-        Some(Self {
-            branch: read_branch(cwd),
-            recent_commits: read_recent_commits(cwd),
-            staged_files: read_staged_files(cwd),
-        })
-    }
-
-    /// Render a human-readable summary suitable for system-prompt injection.
-    #[must_use]
-    pub fn render(&self) -> String {
-        let mut lines = Vec::new();
-
-        if let Some(branch) = &self.branch {
-            lines.push(format!("Git branch: {branch}"));
-        }
-
-        if !self.recent_commits.is_empty() {
-            lines.push(String::new());
-            lines.push("Recent commits:".to_string());
-            for entry in &self.recent_commits {
-                lines.push(format!("  {} {}", entry.hash, entry.subject));
-            }
-        }
-
-        if !self.staged_files.is_empty() {
-            lines.push(String::new());
-            lines.push("Staged files:".to_string());
-            for file in &self.staged_files {
-                lines.push(format!("  {file}"));
-            }
-        }
-
-        lines.join("\n")
-    }
-}
-
-fn read_branch(cwd: &Path) -> Option<String> {
-    let output = Command::new("git")
-        .args(["rev-parse", "--abbrev-ref", "HEAD"])
-        .current_dir(cwd)
-        .output()
-        .ok()?;
-    if !output.status.success() {
-        return None;
-    }
-    let branch = String::from_utf8(output.stdout).ok()?;
-    let trimmed = branch.trim();
-    if trimmed.is_empty() || trimmed == "HEAD" {
-        None
-    } else {
-        Some(trimmed.to_string())
-    }
-}
-
-fn read_recent_commits(cwd: &Path) -> Vec<GitCommitEntry> {
-    let output = Command::new("git")
-        .args([
-            "--no-optional-locks",
-            "log",
-            "--oneline",
-            "-n",
-            &MAX_RECENT_COMMITS.to_string(),
-            "--no-decorate",
-        ])
-        .current_dir(cwd)
-        .output()
-        .ok();
-    let Some(output) = output else {
-        return Vec::new();
-    };
-    if !output.status.success() {
-        return Vec::new();
-    }
-    let stdout = String::from_utf8(output.stdout).unwrap_or_default();
-    stdout
-        .lines()
-        .filter_map(|line| {
-            let line = line.trim();
-            if line.is_empty() {
-                return None;
-            }
-            let (hash, subject) = line.split_once(' ')?;
-            Some(GitCommitEntry {
-                hash: hash.to_string(),
-                subject: subject.to_string(),
-            })
-        })
-        .collect()
-}
-
-fn read_staged_files(cwd: &Path) -> Vec<String> {
-    let output = Command::new("git")
-        .args(["--no-optional-locks", "diff", "--cached", "--name-only"])
-        .current_dir(cwd)
-        .output()
-        .ok();
-    let Some(output) = output else {
-        return Vec::new();
-    };
-    if !output.status.success() {
-        return Vec::new();
-    }
-    let stdout = String::from_utf8(output.stdout).unwrap_or_default();
-    stdout
-        .lines()
-        .filter(|line| !line.trim().is_empty())
-        .map(|line| line.trim().to_string())
-        .collect()
-}
-
-#[cfg(test)]
-mod tests {
-    use super::{GitCommitEntry, GitContext};
-    use std::fs;
-    use std::process::Command;
-    use std::time::{SystemTime, UNIX_EPOCH};
-
-    fn temp_dir(label: &str) -> 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-git-context-{label}-{nanos}"))
-    }
-
-    fn env_lock() -> std::sync::MutexGuard<'static, ()> {
-        crate::test_env_lock()
-    }
-
-    fn ensure_valid_cwd() {
-        if std::env::current_dir().is_err() {
-            std::env::set_current_dir(env!("CARGO_MANIFEST_DIR"))
-                .expect("test cwd should be recoverable");
-        }
-    }
-
-    #[test]
-    fn returns_none_for_non_git_directory() {
-        // given
-        let _guard = env_lock();
-        ensure_valid_cwd();
-        let root = temp_dir("non-git");
-        fs::create_dir_all(&root).expect("create dir");
-
-        // when
-        let context = GitContext::detect(&root);
-
-        // then
-        assert!(context.is_none());
-        fs::remove_dir_all(root).expect("cleanup");
-    }
-
-    #[test]
-    fn detects_branch_name_and_commits() {
-        // given
-        let _guard = env_lock();
-        ensure_valid_cwd();
-        let root = temp_dir("branch-commits");
-        fs::create_dir_all(&root).expect("create dir");
-        git(&root, &["init", "--quiet", "--initial-branch=main"]);
-        git(&root, &["config", "user.email", "tests@example.com"]);
-        git(&root, &["config", "user.name", "Git Context Tests"]);
-        fs::write(root.join("a.txt"), "a\n").expect("write a");
-        git(&root, &["add", "a.txt"]);
-        git(&root, &["commit", "-m", "first commit", "--quiet"]);
-        fs::write(root.join("b.txt"), "b\n").expect("write b");
-        git(&root, &["add", "b.txt"]);
-        git(&root, &["commit", "-m", "second commit", "--quiet"]);
-
-        // when
-        let context = GitContext::detect(&root).expect("should detect git repo");
-
-        // then
-        assert_eq!(context.branch.as_deref(), Some("main"));
-        assert_eq!(context.recent_commits.len(), 2);
-        assert_eq!(context.recent_commits[0].subject, "second commit");
-        assert_eq!(context.recent_commits[1].subject, "first commit");
-        assert!(context.staged_files.is_empty());
-        fs::remove_dir_all(root).expect("cleanup");
-    }
-
-    #[test]
-    fn detects_staged_files() {
-        // given
-        let _guard = env_lock();
-        ensure_valid_cwd();
-        let root = temp_dir("staged");
-        fs::create_dir_all(&root).expect("create dir");
-        git(&root, &["init", "--quiet", "--initial-branch=main"]);
-        git(&root, &["config", "user.email", "tests@example.com"]);
-        git(&root, &["config", "user.name", "Git Context Tests"]);
-        fs::write(root.join("init.txt"), "init\n").expect("write init");
-        git(&root, &["add", "init.txt"]);
-        git(&root, &["commit", "-m", "initial", "--quiet"]);
-        fs::write(root.join("staged.txt"), "staged\n").expect("write staged");
-        git(&root, &["add", "staged.txt"]);
-
-        // when
-        let context = GitContext::detect(&root).expect("should detect git repo");
-
-        // then
-        assert_eq!(context.staged_files, vec!["staged.txt"]);
-        fs::remove_dir_all(root).expect("cleanup");
-    }
-
-    #[test]
-    fn render_formats_all_sections() {
-        // given
-        let context = GitContext {
-            branch: Some("feat/test".to_string()),
-            recent_commits: vec![
-                GitCommitEntry {
-                    hash: "abc1234".to_string(),
-                    subject: "add feature".to_string(),
-                },
-                GitCommitEntry {
-                    hash: "def5678".to_string(),
-                    subject: "fix bug".to_string(),
-                },
-            ],
-            staged_files: vec!["src/main.rs".to_string()],
-        };
-
-        // when
-        let rendered = context.render();
-
-        // then
-        assert!(rendered.contains("Git branch: feat/test"));
-        assert!(rendered.contains("abc1234 add feature"));
-        assert!(rendered.contains("def5678 fix bug"));
-        assert!(rendered.contains("src/main.rs"));
-    }
-
-    #[test]
-    fn render_omits_empty_sections() {
-        // given
-        let context = GitContext {
-            branch: Some("main".to_string()),
-            recent_commits: Vec::new(),
-            staged_files: Vec::new(),
-        };
-
-        // when
-        let rendered = context.render();
-
-        // then
-        assert!(rendered.contains("Git branch: main"));
-        assert!(!rendered.contains("Recent commits:"));
-        assert!(!rendered.contains("Staged files:"));
-    }
-
-    #[test]
-    fn limits_to_five_recent_commits() {
-        // given
-        let _guard = env_lock();
-        ensure_valid_cwd();
-        let root = temp_dir("five-commits");
-        fs::create_dir_all(&root).expect("create dir");
-        git(&root, &["init", "--quiet", "--initial-branch=main"]);
-        git(&root, &["config", "user.email", "tests@example.com"]);
-        git(&root, &["config", "user.name", "Git Context Tests"]);
-        for i in 1..=8 {
-            let name = format!("file{i}.txt");
-            fs::write(root.join(&name), format!("{i}\n")).expect("write file");
-            git(&root, &["add", &name]);
-            git(&root, &["commit", "-m", &format!("commit {i}"), "--quiet"]);
-        }
-
-        // when
-        let context = GitContext::detect(&root).expect("should detect git repo");
-
-        // then
-        assert_eq!(context.recent_commits.len(), 5);
-        assert_eq!(context.recent_commits[0].subject, "commit 8");
-        assert_eq!(context.recent_commits[4].subject, "commit 4");
-        fs::remove_dir_all(root).expect("cleanup");
-    }
-
-    fn git(cwd: &std::path::Path, args: &[&str]) {
-        let status = Command::new("git")
-            .args(args)
-            .current_dir(cwd)
-            .output()
-            .unwrap_or_else(|_| panic!("git {args:?} should run"))
-            .status;
-        assert!(status.success(), "git {args:?} failed");
-    }
-}

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,123 +1,60 @@
-//! Core runtime primitives for the `claw` CLI and supporting crates.
-//!
-//! This crate owns session persistence, permission evaluation, prompt assembly,
-//! MCP plumbing, tool-facing file operations, and the core conversation loop
-//! that drives interactive and one-shot turns.
-
-mod approval_tokens;
 mod bash;
-pub mod bash_validation;
 mod bootstrap;
-pub mod branch_lock;
 mod compact;
 mod config;
-pub mod config_validate;
 mod conversation;
 mod file_ops;
-pub mod g004_conformance;
-mod git_context;
-pub mod green_contract;
 mod hooks;
 mod json;
-mod lane_events;
-pub mod lsp_client;
 mod mcp;
 mod mcp_client;
-pub mod mcp_lifecycle_hardened;
-pub mod mcp_server;
 mod mcp_stdio;
-pub mod mcp_tool_bridge;
 mod oauth;
-pub mod permission_enforcer;
 mod permissions;
-pub mod plugin_lifecycle;
-mod policy_engine;
 mod prompt;
-pub mod recovery_recipes;
 mod remote;
-mod report_schema;
 pub mod sandbox;
 mod session;
-pub mod session_control;
-pub use session_control::SessionStore;
-mod sse;
-pub mod stale_base;
-pub mod stale_branch;
-pub mod summary_compression;
-pub mod task_packet;
-pub mod task_registry;
-pub mod team_cron_registry;
-#[cfg(test)]
-mod trust_resolver;
 mod usage;
-pub mod worker_boot;
 
-pub use approval_tokens::{
-    ApprovalDelegationHop, ApprovalScope, ApprovalTokenAudit, ApprovalTokenError,
-    ApprovalTokenGrant, ApprovalTokenLedger, ApprovalTokenStatus,
-};
 pub use bash::{execute_bash, BashCommandInput, BashCommandOutput};
 pub use bootstrap::{BootstrapPhase, BootstrapPlan};
-pub use branch_lock::{detect_branch_lock_collisions, BranchLockCollision, BranchLockIntent};
 pub use compact::{
     compact_session, estimate_session_tokens, format_compact_summary,
     get_compact_continuation_message, should_compact, CompactionConfig, CompactionResult,
 };
 pub use config::{
-    ConfigEntry, ConfigError, ConfigLoader, ConfigSource, McpConfigCollection,
-    McpManagedProxyServerConfig, McpOAuthConfig, McpRemoteServerConfig, McpSdkServerConfig,
+    ConfigEntry, ConfigError, ConfigLoader, ConfigSource, McpClaudeAiProxyServerConfig,
+    McpConfigCollection, McpOAuthConfig, McpRemoteServerConfig, McpSdkServerConfig,
     McpServerConfig, McpStdioServerConfig, McpTransport, McpWebSocketServerConfig, OAuthConfig,
-    ProviderFallbackConfig, ResolvedPermissionMode, RuntimeConfig, RuntimeFeatureConfig,
-    RuntimeHookConfig, RuntimePermissionRuleConfig, RuntimePluginConfig, ScopedMcpServerConfig,
-    CLAW_SETTINGS_SCHEMA_NAME,
-};
-pub use config_validate::{
-    check_unsupported_format, format_diagnostics, validate_config_file, ConfigDiagnostic,
-    DiagnosticKind, ValidationResult,
+    ResolvedPermissionMode, RuntimeConfig, RuntimeFeatureConfig, RuntimeHookConfig,
+    ScopedMcpServerConfig, CLAUDE_CODE_SETTINGS_SCHEMA_NAME,
 };
 pub use conversation::{
-    auto_compaction_threshold_from_env, ApiClient, ApiRequest, AssistantEvent, AutoCompactionEvent,
-    ConversationRuntime, PromptCacheEvent, RuntimeError, StaticToolExecutor, ToolError,
-    ToolExecutor, TurnSummary,
+    ApiClient, ApiRequest, AssistantEvent, ConversationRuntime, RuntimeError, StaticToolExecutor,
+    ToolError, ToolExecutor, TurnSummary,
 };
 pub use file_ops::{
-    edit_file, edit_file_in_workspace, glob_search, glob_search_in_workspace, grep_search,
-    grep_search_in_workspace, read_file, read_file_in_workspace, write_file,
-    write_file_in_workspace, EditFileOutput, GlobSearchOutput, GrepSearchInput, GrepSearchOutput,
-    ReadFileOutput, StructuredPatchHunk, TextFilePayload, WriteFileOutput,
-};
-pub use git_context::{GitCommitEntry, GitContext};
-pub use hooks::{
-    HookAbortSignal, HookEvent, HookProgressEvent, HookProgressReporter, HookRunResult, HookRunner,
-};
-pub use lane_events::{
-    compute_event_fingerprint, dedupe_superseded_commit_events, dedupe_terminal_events,
-    is_terminal_event, BlockedSubphase, EventProvenance, LaneCommitProvenance, LaneEvent,
-    LaneEventBlocker, LaneEventBuilder, LaneEventMetadata, LaneEventName, LaneEventStatus,
-    LaneFailureClass, LaneOwnership, SessionIdentity, ShipMergeMethod, ShipProvenance,
-    WatcherAction,
+    edit_file, glob_search, grep_search, read_file, write_file, EditFileOutput, GlobSearchOutput,
+    GrepSearchInput, GrepSearchOutput, ReadFileOutput, StructuredPatchHunk, TextFilePayload,
+    WriteFileOutput,
 };
+pub use hooks::{HookEvent, HookRunResult, HookRunner};
 pub use mcp::{
     mcp_server_signature, mcp_tool_name, mcp_tool_prefix, normalize_name_for_mcp,
     scoped_mcp_config_hash, unwrap_ccr_proxy_url,
 };
 pub use mcp_client::{
-    McpClientAuth, McpClientBootstrap, McpClientTransport, McpManagedProxyTransport,
+    McpClaudeAiProxyTransport, McpClientAuth, McpClientBootstrap, McpClientTransport,
     McpRemoteTransport, McpSdkTransport, McpStdioTransport,
 };
-pub use mcp_lifecycle_hardened::{
-    McpDegradedReport, McpErrorSurface, McpFailedServer, McpLifecyclePhase, McpLifecycleState,
-    McpLifecycleValidator, McpPhaseResult,
-};
-pub use mcp_server::{McpServer, McpServerSpec, ToolCallHandler, MCP_SERVER_PROTOCOL_VERSION};
 pub use mcp_stdio::{
     spawn_mcp_stdio_process, JsonRpcError, JsonRpcId, JsonRpcRequest, JsonRpcResponse,
-    ManagedMcpTool, McpDiscoveryFailure, McpInitializeClientInfo, McpInitializeParams,
-    McpInitializeResult, McpInitializeServerInfo, McpListResourcesParams, McpListResourcesResult,
-    McpListToolsParams, McpListToolsResult, McpReadResourceParams, McpReadResourceResult,
-    McpResource, McpResourceContents, McpServerManager, McpServerManagerError, McpStdioProcess,
-    McpTool, McpToolCallContent, McpToolCallParams, McpToolCallResult, McpToolDiscoveryReport,
-    UnsupportedMcpServer,
+    ManagedMcpTool, McpInitializeClientInfo, McpInitializeParams, McpInitializeResult,
+    McpInitializeServerInfo, McpListResourcesParams, McpListResourcesResult, McpListToolsParams,
+    McpListToolsResult, McpReadResourceParams, McpReadResourceResult, McpResource,
+    McpResourceContents, McpServerManager, McpServerManagerError, McpStdioProcess, McpTool,
+    McpToolCallContent, McpToolCallParams, McpToolCallResult, UnsupportedMcpServer,
 };
 pub use oauth::{
     clear_oauth_credentials, code_challenge_s256, credentials_path, generate_pkce_pair,
@@ -127,66 +64,22 @@ pub use oauth::{
     PkceChallengeMethod, PkceCodePair,
 };
 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 policy_engine::{
-    evaluate, DiffScope, GreenLevel, LaneBlocker, LaneContext, PolicyAction, PolicyCondition,
-    PolicyEngine, PolicyRule, ReconcileReason, ReviewStatus,
+    PermissionMode, PermissionOutcome, PermissionPolicy, PermissionPromptDecision,
+    PermissionPrompter, PermissionRequest,
 };
 pub use prompt::{
-    load_system_prompt, prepend_bullets, ContextFile, ModelFamilyIdentity, ProjectContext,
-    PromptBuildError, SystemPromptBuilder, FRONTIER_MODEL_NAME, SYSTEM_PROMPT_DYNAMIC_BOUNDARY,
-};
-pub use recovery_recipes::{
-    attempt_recovery, recipe_for, EscalationPolicy, FailureScenario, RecoveryContext,
-    RecoveryEvent, RecoveryRecipe, RecoveryResult, RecoveryStep,
+    load_system_prompt, prepend_bullets, ContextFile, ProjectContext, PromptBuildError,
+    SystemPromptBuilder, FRONTIER_MODEL_NAME, SYSTEM_PROMPT_DYNAMIC_BOUNDARY,
 };
 pub use remote::{
     inherited_upstream_proxy_env, no_proxy_list, read_token, upstream_proxy_ws_url,
     RemoteSessionContext, UpstreamProxyBootstrap, UpstreamProxyState, DEFAULT_REMOTE_BASE_URL,
     DEFAULT_SESSION_TOKEN_PATH, DEFAULT_SYSTEM_CA_BUNDLE, NO_PROXY_HOSTS, UPSTREAM_PROXY_ENV_KEYS,
 };
-pub use report_schema::{
-    canonicalize_report, project_report, report_content_hash, report_schema_v1_registry,
-    CanonicalReportV1, ClaimKind, ConsumerCapabilities, FieldDelta, FieldDeltaState,
-    NegativeEvidence, NegativeFindingStatus, ProjectionProvenance, RedactionProvenance,
-    ReportClaim, ReportConfidence, ReportIdentity, ReportProjectionV1, ReportSchemaField,
-    ReportSchemaRegistry, SensitivityClass, DEFAULT_PROJECTION_POLICY_V1, REPORT_SCHEMA_V1,
-};
-pub use sandbox::{
-    build_linux_sandbox_command, detect_container_environment, detect_container_environment_from,
-    resolve_sandbox_status, resolve_sandbox_status_for_request, ContainerEnvironment,
-    FilesystemIsolationMode, LinuxSandboxCommand, SandboxConfig, SandboxDetectionInputs,
-    SandboxRequest, SandboxStatus,
-};
-pub use session::{
-    ContentBlock, ConversationMessage, MessageRole, Session, SessionCompaction, SessionError,
-    SessionFork, SessionPromptEntry,
-};
-pub use sse::{IncrementalSseParser, SseEvent};
-pub use stale_base::{
-    check_base_commit, format_stale_base_warning, read_claw_base_file, resolve_expected_base,
-    BaseCommitSource, BaseCommitState,
-};
-pub use stale_branch::{
-    apply_policy, check_freshness, BranchFreshness, StaleBranchAction, StaleBranchEvent,
-    StaleBranchPolicy,
-};
-pub use task_packet::{validate_packet, TaskPacket, TaskPacketValidationError, ValidatedPacket};
-#[cfg(test)]
-pub use trust_resolver::{TrustConfig, TrustDecision, TrustEvent, TrustPolicy, TrustResolver};
+pub use session::{ContentBlock, ConversationMessage, MessageRole, Session, SessionError};
 pub use usage::{
     format_usd, pricing_for_model, ModelPricing, TokenUsage, UsageCostEstimate, UsageTracker,
 };
-pub use worker_boot::{
-    Worker, WorkerEvent, WorkerEventKind, WorkerEventPayload, WorkerFailure, WorkerFailureKind,
-    WorkerPromptTarget, WorkerReadySnapshot, WorkerRegistry, WorkerStatus, WorkerTrustResolution,
-};
 
 #[cfg(test)]
 pub(crate) fn test_env_lock() -> std::sync::MutexGuard<'static, ()> {