diff --git a/.claude/skills/acp-harness/assets/docker-compose.acp.yml b/.claude/skills/acp-harness/assets/docker-compose.acp.yml
deleted file mode 100644
index bc867dc..0000000
--- a/.claude/skills/acp-harness/assets/docker-compose.acp.yml
+++ /dev/null
@@ -1,19 +0,0 @@
-# ACP Harness Docker Compose Configuration
-#
-# Example docker-compose for running ACP evaluations.
-# Copy this to your project and customize as needed.
-#
-# Usage:
-#   ANTHROPIC_API_KEY=sk-... docker compose -f docker-compose.acp.yml run --rm acp-harness
-
-services:
-  acp-harness:
-    build:
-      context: .
-      dockerfile: Dockerfile.acp
-    environment:
-      - ANTHROPIC_API_KEY
-    volumes:
-      # Mount output directory to persist results
-      - ./results:/app/results
-    command: ["bunx", "@plaited/acp-harness", "prompts.jsonl", "-o", "results/output.jsonl"]
diff --git a/.claude/skills/acp-harness/SKILL.md b/.claude/skills/agent-eval-harness/SKILL.md
similarity index 62%
rename from .claude/skills/acp-harness/SKILL.md
rename to .claude/skills/agent-eval-harness/SKILL.md
index 053d7d2..c9074cf 100644
--- a/.claude/skills/acp-harness/SKILL.md
+++ b/.claude/skills/agent-eval-harness/SKILL.md
@@ -1,20 +1,20 @@
 ---
-name: acp-harness
-description: CLI tool for capturing agent trajectories. Execute prompts against ACP-compatible agents, capture full trajectories (tools, thoughts, plans), and output structured JSONL for downstream scoring.
+name: agent-eval-harness
+description: CLI tool for capturing agent trajectories. Execute prompts against headless CLI agents via schema-driven adapters, capture full trajectories (tools, thoughts, plans), and output structured JSONL for downstream scoring.
 compatibility: Bun >= 1.2.9
 ---
 
-# ACP Harness
+# Agent Eval Harness
 
 ## Purpose
 
-CLI tool for capturing trajectories from ACP-compatible agents, optimized for TypeScript/JavaScript projects using Bun.
+CLI tool for capturing trajectories from headless CLI agents, optimized for TypeScript/JavaScript projects using Bun.
 
 **The harness captures. You score.**
 
 | Harness Provides | You Provide |
 |------------------|-------------|
-| Prompt execution against ACP agents | Scoring logic (Braintrust, custom scripts) |
+| Prompt execution via headless adapters | Scoring logic (Braintrust, custom scripts) |
 | Full trajectory capture (thoughts, tools, plans) | Pass/fail determination via graders |
 | Structured JSONL output | LLM-as-judge prompts |
 | Reproducible execution environment | CI integration, golden file comparison |
@@ -29,10 +29,10 @@ CLI tool for capturing trajectories from ACP-compatible agents, optimized for Ty
 
 ```bash
 # Run without installing (recommended)
-bunx @plaited/acp-harness capture prompts.jsonl bunx claude-code-acp -o results.jsonl
+bunx @plaited/agent-eval-harness capture prompts.jsonl --schema ./claude.json -o results.jsonl
 
 # Or install as project dependency
-bun add @plaited/acp-harness
+bun add @plaited/agent-eval-harness
 ```
 
 ## Core Principle: Capture Once, Derive Many Views
@@ -40,7 +40,7 @@ bun add @plaited/acp-harness
 ```mermaid
 flowchart LR
     Prompts["prompts.jsonl"] --> Capture["capture/trials"]
-    Agent["ACP Agent"] --> Capture
+    Schema["headless schema"] --> Capture
     Capture --> Results["results.jsonl (full trajectory)"]
     Results --> Summarize["summarize"]
     Results --> Calibrate["calibrate"]
@@ -56,16 +56,28 @@ flowchart LR
 
 ## Commands
 
+### Core Commands
+
 | Command | Input | Output | Purpose |
 |---------|-------|--------|---------|
-| `capture` | prompts.jsonl + agent | results.jsonl | Trajectory capture (full) |
-| `trials` | prompts.jsonl + agent | trials.jsonl | Multi-run + optional metrics |
+| `capture` | prompts.jsonl + schema | results.jsonl | Trajectory capture (full) |
+| `trials` | prompts.jsonl + schema | trials.jsonl | Multi-run + optional metrics |
 | `summarize` | results.jsonl | summary.jsonl or .md | Derive compact views |
 | `calibrate` | results.jsonl | calibration.md | Sample failures for review |
 | `validate-refs` | prompts.jsonl | validation.jsonl | Check reference solutions |
 | `balance` | prompts.jsonl | balance.json | Analyze test set coverage |
 | `schemas` | (none) | JSON Schema | Export schemas for non-TS users |
 
+### Pipeline Commands (Unix-style)
+
+| Command | Input | Output | Purpose |
+|---------|-------|--------|---------|
+| `run` | prompts.jsonl + schema | raw.jsonl | Execute prompts, raw output |
+| `extract` | raw.jsonl + schema | extracted.jsonl | Parse trajectories |
+| `grade` | extracted.jsonl + grader | graded.jsonl | Apply grader scoring |
+| `format` | results.jsonl | jsonl/markdown/csv | Convert output format |
+| `compare` | multiple results.jsonl | comparison.jsonl | Compare multiple runs |
+
 All commands support optional `--grader ./grader.ts` for scoring.
 
 ## Capture Command
@@ -73,7 +85,7 @@ All commands support optional `--grader ./grader.ts` for scoring.
 ### Basic Usage
 
 ```bash
-bunx @plaited/acp-harness capture <prompts.jsonl> <command> [args...] [options]
+bunx @plaited/agent-eval-harness capture <prompts.jsonl> --schema <schema.json> [options]
 ```
 
 ### Arguments
@@ -81,25 +93,26 @@ bunx @plaited/acp-harness capture <prompts.jsonl> <command> [args...] [options]
 | Argument/Flag | Description | Default |
 |------|-------------|---------|
 | `prompts.jsonl` | Input file with prompts to execute | Required |
-| `command [args]` | ACP agent command (e.g., `bunx claude-code-acp`) | Required |
+| `-s, --schema` | Path to headless adapter schema | Required |
 | `-o, --output` | Output file/path | stdout |
-| `-c, --cwd` | Working directory for agent (agents auto-discover MCP configs from here) | current |
+| `-c, --cwd` | Working directory for agent | current |
 | `-t, --timeout` | Request timeout in ms | `60000` |
 | `--progress` | Show progress to stderr | false |
 | `--append` | Append to output file | false |
 | `-g, --grader` | Path to grader module | none |
+| `--debug` | Show detailed CLI output for debugging | false |
 
 ### Examples
 
 ```bash
 # Basic capture
-bunx @plaited/acp-harness capture prompts.jsonl bunx claude-code-acp -o results.jsonl
+bunx @plaited/agent-eval-harness capture prompts.jsonl --schema ./claude.json -o results.jsonl
 
 # Using a local adapter script
-bunx @plaited/acp-harness capture prompts.jsonl bun ./my-adapter.ts -o results.jsonl
+bunx @plaited/agent-eval-harness capture prompts.jsonl bun ./my-adapter.ts -o results.jsonl
 
 # With grader (adds score to each result)
-bunx @plaited/acp-harness capture prompts.jsonl bunx claude-code-acp --grader ./grader.ts -o results.jsonl
+bunx @plaited/agent-eval-harness capture prompts.jsonl --schema ./claude.json --grader ./grader.ts -o results.jsonl
 ```
 
 ## Trials Command
@@ -108,10 +121,10 @@ Run each prompt multiple times for pass@k/pass^k analysis.
 
 ```bash
 # Capture only (no grader)
-bunx @plaited/acp-harness trials prompts.jsonl bunx claude-code-acp -k 5 -o trials.jsonl
+bunx @plaited/agent-eval-harness trials prompts.jsonl --schema ./claude.json -k 5 -o trials.jsonl
 
 # With grader (computes pass@k, pass^k)
-bunx @plaited/acp-harness trials prompts.jsonl bunx claude-code-acp -k 5 --grader ./grader.ts -o trials.jsonl
+bunx @plaited/agent-eval-harness trials prompts.jsonl --schema ./claude.json -k 5 --grader ./grader.ts -o trials.jsonl
 ```
 
 ### Output
@@ -132,10 +145,10 @@ Derive compact views from full trajectory results.
 
 ```bash
 # Summary JSONL (for jq analysis)
-bunx @plaited/acp-harness summarize results.jsonl -o summary.jsonl
+bunx @plaited/agent-eval-harness summarize results.jsonl -o summary.jsonl
 
 # Markdown (for LLM-as-judge)
-bunx @plaited/acp-harness summarize results.jsonl --markdown -o results.md
+bunx @plaited/agent-eval-harness summarize results.jsonl --markdown -o results.md
 ```
 
 ## Calibrate Command
@@ -144,10 +157,10 @@ Sample failures for grader review. Calibration helps you distinguish between **a
 
 ```bash
 # Sample failures for human review
-bunx @plaited/acp-harness calibrate results.jsonl --sample 10 -o calibration.md
+bunx @plaited/agent-eval-harness calibrate results.jsonl --sample 10 -o calibration.md
 
 # Re-score with different grader to compare
-bunx @plaited/acp-harness calibrate results.jsonl --grader ./loose-grader.ts --sample 10 -o comparison.md
+bunx @plaited/agent-eval-harness calibrate results.jsonl --grader ./loose-grader.ts --sample 10 -o comparison.md
 ```
 
 See [eval-concepts.md](references/eval-concepts.md#grader-calibration) for why calibration matters.
@@ -158,7 +171,7 @@ Check that reference solutions pass your grader before evaluating agents.
 
 ```bash
 # Validate reference solutions
-bunx @plaited/acp-harness validate-refs prompts.jsonl --grader ./grader.ts -o validation.jsonl
+bunx @plaited/agent-eval-harness validate-refs prompts.jsonl --grader ./grader.ts -o validation.jsonl
 
 # Check for failures
 cat validation.jsonl | jq 'select(.pass == false)'
@@ -193,10 +206,10 @@ Analyze test set coverage to ensure balanced evaluation.
 
 ```bash
 # Analyze prompt distribution
-bunx @plaited/acp-harness balance prompts.jsonl -o balance.json
+bunx @plaited/agent-eval-harness balance prompts.jsonl -o balance.json
 
 # Pretty print
-bunx @plaited/acp-harness balance prompts.jsonl | jq .
+bunx @plaited/agent-eval-harness balance prompts.jsonl | jq .
 ```
 
 ### Why Use This?
@@ -235,21 +248,151 @@ Include both positive and negative cases:
 
 See [eval-concepts.md](references/eval-concepts.md#test-set-balance) for more on balanced test sets.
 
+## Pipeline Workflow
+
+The pipeline commands enable Unix-style composition for flexible evaluation workflows.
+
+### Full Pipeline Example
+
+```bash
+# Execute → Extract → Grade → Format in one pipeline
+cat prompts.jsonl | \
+  bunx @plaited/agent-eval-harness run -s claude.json | \
+  bunx @plaited/agent-eval-harness extract -s claude.json | \
+  bunx @plaited/agent-eval-harness grade -g ./grader.ts | \
+  bunx @plaited/agent-eval-harness format -f markdown > report.md
+```
+
+### Run Command
+
+Execute prompts and output raw results. Three modes available:
+
+```bash
+# Schema mode (recommended)
+bunx @plaited/agent-eval-harness run prompts.jsonl --schema claude.json
+
+# Simple mode: {} placeholder substitution
+bunx @plaited/agent-eval-harness run prompts.jsonl --simple "claude -p {} --output-format stream-json"
+
+# Shell mode: $PROMPT environment variable
+bunx @plaited/agent-eval-harness run prompts.jsonl --shell 'claude -p "$PROMPT" --output-format stream-json'
+```
+
+> **⚠️ Security Warning:** The `--simple` and `--shell` modes execute prompts via shell commands. Prompts are escaped but **do not use untrusted prompt content** with these modes. Malicious prompt text could potentially escape the quoting and execute arbitrary commands. Use `--schema` mode (headless adapter) for untrusted inputs.
+
+### Extract Command
+
+Parse raw output into structured trajectories:
+
+```bash
+# From file
+bunx @plaited/agent-eval-harness extract raw.jsonl --schema claude.json -o extracted.jsonl
+
+# Piped from run
+bunx @plaited/agent-eval-harness run prompts.jsonl -s claude.json | \
+  bunx @plaited/agent-eval-harness extract -s claude.json
+```
+
+### Grade Command
+
+Apply grader to extracted results:
+
+```bash
+bunx @plaited/agent-eval-harness grade extracted.jsonl --grader ./grader.ts -o graded.jsonl
+```
+
+### Format Command
+
+Convert results to different output formats:
+
+```bash
+# Markdown report
+bunx @plaited/agent-eval-harness format results.jsonl --style markdown -o report.md
+
+# CSV for spreadsheets
+bunx @plaited/agent-eval-harness format results.jsonl --style csv -o results.csv
+
+# JSONL (pass-through, default)
+bunx @plaited/agent-eval-harness format results.jsonl --style jsonl
+```
+
+### Compare Command
+
+Compare multiple runs of the same prompts:
+
+```bash
+# Compare multiple result files
+bunx @plaited/agent-eval-harness compare run1.jsonl run2.jsonl run3.jsonl \
+  --grader ./compare-grader.ts -o comparison.jsonl
+
+# With explicit labels
+bunx @plaited/agent-eval-harness compare \
+  --run "with-mcp:results-mcp.jsonl" \
+  --run "vanilla:results-vanilla.jsonl" \
+  --grader ./compare-grader.ts
+```
+
+**Use cases for compare:**
+- Same agent, different MCP servers
+- Same agent, different skills enabled
+- Same agent, different model versions
+- Different agents entirely
+
+### Comparison Grader Interface
+
+```typescript
+import type { ComparisonGrader } from '@plaited/agent-eval-harness/pipeline'
+
+export const grade: ComparisonGrader = async ({ id, input, hint, runs }) => {
+  // runs is Record<string, { output: string; trajectory?: TrajectoryStep[] }>
+  // Return rankings from best to worst
+  return {
+    rankings: [
+      { run: 'with-mcp', rank: 1, score: 0.9 },
+      { run: 'vanilla', rank: 2, score: 0.7 },
+    ],
+    reasoning: 'MCP run produced more accurate output'
+  }
+}
+```
+
+### Pipeline Workflow Diagram
+
+```mermaid
+flowchart LR
+    Prompts["prompts.jsonl"] --> Run["run"]
+    Schema["headless schema"] --> Run
+    Run --> Raw["raw.jsonl"]
+    Raw --> Extract["extract"]
+    Schema --> Extract
+    Extract --> Extracted["extracted.jsonl"]
+    Extracted --> Grade["grade"]
+    Grader["grader.ts"] --> Grade
+    Grade --> Graded["graded.jsonl"]
+    Graded --> Format["format"]
+    Format --> Output["report.md / .csv / .jsonl"]
+
+    Graded --> Compare["compare"]
+    Results2["other runs..."] --> Compare
+    CompareGrader["compare-grader.ts"] --> Compare
+    Compare --> Comparison["comparison.jsonl"]
+```
+
 ## Schemas Command
 
 Export JSON schemas for non-TypeScript tools.
 
 ```bash
 # List available schemas
-bunx @plaited/acp-harness schemas
+bunx @plaited/agent-eval-harness schemas
 
 # Export all schemas as JSON
-bunx @plaited/acp-harness schemas --json -o schemas.json
+bunx @plaited/agent-eval-harness schemas --json -o schemas.json
 
 # Export specific schema
-bunx @plaited/acp-harness schemas CaptureResult --json
-bunx @plaited/acp-harness schemas TrialResult --json
-bunx @plaited/acp-harness schemas GraderResult --json
+bunx @plaited/agent-eval-harness schemas CaptureResult --json
+bunx @plaited/agent-eval-harness schemas TrialResult --json
+bunx @plaited/agent-eval-harness schemas GraderResult --json
 ```
 
 ### Available Schemas
@@ -269,7 +412,7 @@ Export schemas for validation in Python, Go, etc.:
 
 ```bash
 # Export all schemas
-bunx @plaited/acp-harness schemas --json -o schemas.json
+bunx @plaited/agent-eval-harness schemas --json -o schemas.json
 
 # Use in Python with jsonschema
 python -c "
@@ -295,7 +438,7 @@ Graders provide semantic pass/fail scoring for captured trajectories. The harnes
 
 ```typescript
 // my-grader.ts
-import type { Grader } from '@plaited/acp-harness/schemas'
+import type { Grader } from '@plaited/agent-eval-harness/schemas'
 
 export const grade: Grader = async ({ input, output, hint, trajectory }) => {
   const pass = output.toLowerCase().includes(hint?.toLowerCase() ?? '')
@@ -331,7 +474,7 @@ print(json.dumps({
 
 ```bash
 chmod +x ./grader.py
-bunx @plaited/acp-harness capture prompts.jsonl bunx claude-code-acp --grader ./grader.py -o results.jsonl
+bunx @plaited/agent-eval-harness capture prompts.jsonl --schema ./claude.json --grader ./grader.py -o results.jsonl
 ```
 
 See [graders.md](references/graders.md) for complete polyglot grader documentation including shell scripts and LLM-as-judge patterns.
@@ -375,7 +518,7 @@ Full trajectory JSONL (always):
   ],
   "metadata": {
     "category": "search",
-    "agent": "bunx claude-code-acp",
+    "agent": "--schema ./claude.json",
     "trajectoryRichness": "full",
     "turnCount": 1
   },
@@ -413,7 +556,7 @@ Full trajectory JSONL (always):
 Consumers can import Zod schemas directly:
 
 ```typescript
-import { CaptureResultSchema, TrialResultSchema } from '@plaited/acp-harness/schemas'
+import { CaptureResultSchema, TrialResultSchema } from '@plaited/agent-eval-harness/schemas'
 
 // Validate external data
 const result = CaptureResultSchema.parse(jsonData)
@@ -426,8 +569,8 @@ const jsonSchema = z.toJSONSchema(CaptureResultSchema)
 Or export JSON schemas for non-TypeScript tools:
 
 ```bash
-bunx @plaited/acp-harness schemas --json -o schemas.json
-bunx @plaited/acp-harness schemas CaptureResult --json
+bunx @plaited/agent-eval-harness schemas --json -o schemas.json
+bunx @plaited/agent-eval-harness schemas CaptureResult --json
 ```
 
 ## Execution Environment
@@ -436,10 +579,10 @@ bunx @plaited/acp-harness schemas CaptureResult --json
 
 ```bash
 # Run integration tests via Docker
-docker compose -f docker-compose.test.yml run --rm acp-test
+docker compose -f docker-compose.test.yml run --rm test
 
 # Or with explicit API keys
-ANTHROPIC_API_KEY=sk-... GEMINI_API_KEY=... docker compose -f docker-compose.test.yml run --rm acp-test
+ANTHROPIC_API_KEY=sk-... GEMINI_API_KEY=... docker compose -f docker-compose.test.yml run --rm test
 ```
 
 ### Docker Requirements
@@ -465,13 +608,13 @@ Run with the headless adapter:
 
 ```bash
 # Using Claude Code via headless adapter
-bunx @plaited/acp-harness capture multi-turn.jsonl \
-  bunx @plaited/acp-harness headless --schema ./claude-headless.json \
+bunx @plaited/agent-eval-harness capture multi-turn.jsonl \
+  bunx @plaited/agent-eval-harness headless --schema ./claude-headless.json \
   -o results.jsonl
 
 # Using Gemini CLI via headless adapter
-GEMINI_API_KEY=... bunx @plaited/acp-harness capture multi-turn.jsonl \
-  bunx @plaited/acp-harness headless --schema ./gemini-headless.json \
+GEMINI_API_KEY=... bunx @plaited/agent-eval-harness capture multi-turn.jsonl \
+  bunx @plaited/agent-eval-harness headless --schema ./gemini-headless.json \
   -o results.jsonl
 ```
 
@@ -493,7 +636,7 @@ cat results.jsonl | jq 'select(.metadata.category == "ui")'
 cat results.jsonl | jq -s 'map(.trajectory | map(select(.type == "tool_call")) | length) | add'
 
 # Summarize for quick analysis
-bunx @plaited/acp-harness summarize results.jsonl -o summary.jsonl
+bunx @plaited/agent-eval-harness summarize results.jsonl -o summary.jsonl
 ```
 
 See [downstream.md](references/downstream.md) for integration patterns with Braintrust, Gemini, and custom scorers.
@@ -502,7 +645,7 @@ See [downstream.md](references/downstream.md) for integration patterns with Brai
 
 | Resource | Description |
 |----------|-------------|
-| `bunx @plaited/acp-harness` | CLI help |
+| `bunx @plaited/agent-eval-harness` | CLI help |
 | [output-formats.md](references/output-formats.md) | JSONL schemas, command details |
 | [downstream.md](references/downstream.md) | Integration patterns (Braintrust, jq, custom scorers) |
 | [graders.md](references/graders.md) | Polyglot grader documentation (TypeScript, Python, shell) |
@@ -511,5 +654,4 @@ See [downstream.md](references/downstream.md) for integration patterns with Brai
 
 ## Related
 
-- **[@agentclientprotocol/sdk](https://www.npmjs.com/package/@agentclientprotocol/sdk)** - ACP SDK for programmatic access
-- **[@zed-industries/claude-code-acp](https://www.npmjs.com/package/@zed-industries/claude-code-acp)** - Claude Code ACP adapter
+- **[headless-adapters skill](../headless-adapters/SKILL.md)** - Schema-driven adapters for headless CLI agents
diff --git a/.claude/skills/acp-harness/assets/Dockerfile.acp b/.claude/skills/agent-eval-harness/assets/Dockerfile.eval
similarity index 59%
rename from .claude/skills/acp-harness/assets/Dockerfile.acp
rename to .claude/skills/agent-eval-harness/assets/Dockerfile.eval
index 14e6a8a..f1241e5 100644
--- a/.claude/skills/acp-harness/assets/Dockerfile.acp
+++ b/.claude/skills/agent-eval-harness/assets/Dockerfile.eval
@@ -1,11 +1,11 @@
-# ACP Harness Docker Configuration
+# Agent Eval Harness Docker Configuration
 #
-# Example Dockerfile for running ACP evaluations in an isolated container.
+# Example Dockerfile for running agent evaluations in an isolated container.
 # Copy this to your project and customize as needed.
 #
 # Usage:
-#   docker build -f Dockerfile.acp -t acp-harness .
-#   docker run --rm -e ANTHROPIC_API_KEY acp-harness bunx @plaited/acp-harness prompts.jsonl
+#   docker build -f Dockerfile.acp -t agent-eval-harness .
+#   docker run --rm -e ANTHROPIC_API_KEY agent-eval-harness bunx @plaited/agent-eval-harness capture prompts.jsonl --schema ./claude.json
 
 FROM oven/bun:1.2.9
 
diff --git a/.claude/skills/agent-eval-harness/assets/docker-compose.eval.yml b/.claude/skills/agent-eval-harness/assets/docker-compose.eval.yml
new file mode 100644
index 0000000..9b8e4b0
--- /dev/null
+++ b/.claude/skills/agent-eval-harness/assets/docker-compose.eval.yml
@@ -0,0 +1,19 @@
+# Agent Eval Harness Docker Compose Configuration
+#
+# Example docker-compose for running agent evaluations.
+# Copy this to your project and customize as needed.
+#
+# Usage:
+#   ANTHROPIC_API_KEY=sk-... docker compose -f docker-compose.eval.yml run --rm agent-eval-harness
+
+services:
+  agent-eval-harness:
+    build:
+      context: .
+      dockerfile: Dockerfile.eval
+    environment:
+      - ANTHROPIC_API_KEY
+    volumes:
+      # Mount output directory to persist results
+      - ./results:/app/results
+    command: ["bunx", "@plaited/agent-eval-harness", "capture", "prompts.jsonl", "--schema", "./claude.json", "-o", "results/output.jsonl"]
diff --git a/.claude/skills/acp-harness/references/docker-evals.md b/.claude/skills/agent-eval-harness/references/docker-evals.md
similarity index 89%
rename from .claude/skills/acp-harness/references/docker-evals.md
rename to .claude/skills/agent-eval-harness/references/docker-evals.md
index 283473b..89a2769 100644
--- a/.claude/skills/acp-harness/references/docker-evals.md
+++ b/.claude/skills/agent-eval-harness/references/docker-evals.md
@@ -1,6 +1,6 @@
 # Running Evals in Docker
 
-Docker provides a consistent, isolated environment for running ACP evaluations. This guide covers lessons learned from real debugging sessions.
+Docker provides a consistent, isolated environment for running agent evaluations. This guide covers lessons learned from real debugging sessions.
 
 ## Why Docker?
 
@@ -98,7 +98,7 @@ which gemini  # fails
 **Solution:** Verify symlinks point to accessible locations:
 ```bash
 # Debug inside container
-docker compose run --rm acp-test bash -c 'which gemini && ls -la $(which gemini)'
+docker compose run --rm test bash -c 'which gemini && ls -la $(which gemini)'
 ```
 
 ### 5. Environment Variables Not Passed
@@ -118,7 +118,7 @@ When tests fail in Docker, run these checks:
 
 ```bash
 # 1. Verify CLI installation and access
-docker compose run --rm acp-test bash -c '
+docker compose run --rm test bash -c '
   echo "=== Node.js ===" && node --version &&
   echo "=== Bun ===" && bun --version &&
   echo "=== Claude ===" && which claude && claude --version &&
@@ -126,18 +126,18 @@ docker compose run --rm acp-test bash -c '
 '
 
 # 2. Verify environment variables
-docker compose run --rm acp-test bash -c '
+docker compose run --rm test bash -c '
   echo "ANTHROPIC_API_KEY: ${ANTHROPIC_API_KEY:+set}"
   echo "GEMINI_API_KEY: ${GEMINI_API_KEY:+set}"
 '
 
 # 3. Test CLI directly
-docker compose run --rm acp-test bash -c '
+docker compose run --rm test bash -c '
   gemini -p "Say hello" --output-format stream-json 2>&1 | head -5
 '
 
 # 4. Run as root to isolate permission issues
-docker compose run --rm --user root acp-test bash -c 'whoami && which claude'
+docker compose run --rm --user root test bash -c 'whoami && which claude'
 ```
 
 ## CI Integration (GitHub Actions)
@@ -147,11 +147,11 @@ test-integration:
   runs-on: ubuntu-latest
   steps:
     - uses: actions/checkout@v4
-    - name: Run ACP integration tests
+    - name: Run integration tests
       env:
         ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
         GEMINI_API_KEY: ${{ secrets.GEMINI_API_KEY }}
-      run: docker compose -f docker-compose.test.yml run --rm acp-test
+      run: docker compose -f docker-compose.test.yml run --rm test
 ```
 
 ## Version Matrix
@@ -169,7 +169,7 @@ Tested configurations:
 
 ```yaml
 services:
-  acp-test:
+  test:
     build:
       context: .
       dockerfile: Dockerfile.test
diff --git a/.claude/skills/acp-harness/references/downstream.md b/.claude/skills/agent-eval-harness/references/downstream.md
similarity index 90%
rename from .claude/skills/acp-harness/references/downstream.md
rename to .claude/skills/agent-eval-harness/references/downstream.md
index 691337c..d3edace 100644
--- a/.claude/skills/acp-harness/references/downstream.md
+++ b/.claude/skills/agent-eval-harness/references/downstream.md
@@ -21,7 +21,7 @@ Use `summarize` command for quick jq analysis:
 
 ```bash
 # First derive summary
-acp-harness summarize results.jsonl -o summary.jsonl
+agent-eval-harness summarize results.jsonl -o summary.jsonl
 
 # Calculate average duration
 cat summary.jsonl | jq -s 'map(.duration) | add / length'
@@ -172,7 +172,7 @@ Use the `--grader` flag to add scoring to capture results. The harness supports
 
 ```typescript
 // my-grader.ts
-import type { Grader } from '@plaited/acp-harness/schemas'
+import type { Grader } from '@plaited/agent-eval-harness/schemas'
 
 export const grade: Grader = async ({ input, output, hint, trajectory }) => {
   const pass = output.toLowerCase().includes(hint?.toLowerCase() ?? '')
@@ -185,7 +185,7 @@ export const grade: Grader = async ({ input, output, hint, trajectory }) => {
 ```
 
 ```bash
-acp-harness capture prompts.jsonl bunx claude-code-acp --grader ./my-grader.ts -o results.jsonl
+agent-eval-harness capture prompts.jsonl bunx claude-code-acp --grader ./my-grader.ts -o results.jsonl
 ```
 
 ### Python Grader
@@ -228,7 +228,7 @@ print(json.dumps({
 
 ```bash
 chmod +x ./grader.py
-acp-harness capture prompts.jsonl bunx claude-code-acp --grader ./grader.py -o results.jsonl
+agent-eval-harness capture prompts.jsonl bunx claude-code-acp --grader ./grader.py -o results.jsonl
 ```
 
 ### Detection Logic
@@ -301,7 +301,7 @@ Use markdown summary for smaller context:
 import Anthropic from '@anthropic-ai/sdk'
 
 // Generate markdown summary first
-await Bun.$`acp-harness summarize results.jsonl --markdown -o results.md`
+await Bun.$`agent-eval-harness summarize results.jsonl --markdown -o results.md`
 
 const client = new Anthropic()
 const markdown = await Bun.file('results.md').text()
@@ -372,25 +372,25 @@ jobs:
       - uses: actions/checkout@v4
       - uses: oven-sh/setup-bun@v2
 
-      - name: Install ACP adapter
+      - name: Install harness
         run: npm install -g @zed-industries/claude-code-acp
 
       - name: Install dependencies
-        run: bun add @plaited/acp-harness
+        run: bun add @plaited/agent-eval-harness
 
       - name: Run harness
         env:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
         run: |
-          bunx @plaited/acp-harness capture prompts.jsonl \
+          bunx @plaited/agent-eval-harness capture prompts.jsonl \
             bunx claude-code-acp \
             --progress \
             -o results.jsonl
 
       - name: Generate summary
         run: |
-          bunx @plaited/acp-harness summarize results.jsonl -o summary.jsonl
-          bunx @plaited/acp-harness summarize results.jsonl --markdown -o results.md
+          bunx @plaited/agent-eval-harness summarize results.jsonl -o summary.jsonl
+          bunx @plaited/agent-eval-harness summarize results.jsonl --markdown -o results.md
 
       - name: Upload results
         uses: actions/upload-artifact@v4
@@ -408,8 +408,8 @@ Combine multiple runs:
 
 ```bash
 # Append mode during runs
-acp-harness capture prompts-1.jsonl bunx claude-code-acp --append -o combined.jsonl
-acp-harness capture prompts-2.jsonl bunx claude-code-acp --append -o combined.jsonl
+agent-eval-harness capture prompts-1.jsonl bunx claude-code-acp --append -o combined.jsonl
+agent-eval-harness capture prompts-2.jsonl bunx claude-code-acp --append -o combined.jsonl
 
 # Merge separate files
 cat run1.jsonl run2.jsonl run3.jsonl > combined.jsonl
@@ -422,7 +422,7 @@ cat run1.jsonl run2.jsonl run3.jsonl > combined.jsonl
 Use the `trials` command to measure pass@k/pass^k:
 
 ```bash
-acp-harness trials prompts.jsonl bunx claude-code-acp -k 5 --grader ./grader.ts -o trials.jsonl
+agent-eval-harness trials prompts.jsonl bunx claude-code-acp -k 5 --grader ./grader.ts -o trials.jsonl
 ```
 
 ```typescript
diff --git a/.claude/skills/acp-harness/references/eval-concepts.md b/.claude/skills/agent-eval-harness/references/eval-concepts.md
similarity index 93%
rename from .claude/skills/acp-harness/references/eval-concepts.md
rename to .claude/skills/agent-eval-harness/references/eval-concepts.md
index 5060f78..e5d6f70 100644
--- a/.claude/skills/acp-harness/references/eval-concepts.md
+++ b/.claude/skills/agent-eval-harness/references/eval-concepts.md
@@ -55,7 +55,7 @@ Run a prompt 5 times, 3 pass (60% raw pass rate):
 
 ```bash
 # Run many trials to assess capability
-acp-harness trials new-prompts.jsonl bunx agent -k 10 --grader ./grader.ts -o capability.jsonl
+agent-eval-harness trials new-prompts.jsonl bunx agent -k 10 --grader ./grader.ts -o capability.jsonl
 
 # Analyze results
 cat capability.jsonl | jq 'select(.passAtK > 0.9) | {id, passAtK}'
@@ -70,7 +70,7 @@ Questions answered:
 
 ```bash
 # Run fewer trials for known-good tasks
-acp-harness trials regression-suite.jsonl bunx agent -k 3 --grader ./grader.ts -o regression.jsonl
+agent-eval-harness trials regression-suite.jsonl bunx agent -k 3 --grader ./grader.ts -o regression.jsonl
 
 # Fail CI if reliability drops
 cat regression.jsonl | jq -e 'all(.passExpK > 0.8)'
@@ -118,7 +118,7 @@ Week 3: 60% grader pass → 80% actually correct (grader rejected 20% valid)
 
 ```bash
 # Sample 10 failures for human review
-acp-harness calibrate results.jsonl --sample 10 -o calibration.md
+agent-eval-harness calibrate results.jsonl --sample 10 -o calibration.md
 ```
 
 Review the markdown output and label each sample:
@@ -171,7 +171,7 @@ Reference solutions prove a task is solvable before blaming the agent.
 
 ```bash
 # Check that reference solutions pass your grader
-acp-harness validate-refs prompts.jsonl --grader ./grader.ts -o validation.jsonl
+agent-eval-harness validate-refs prompts.jsonl --grader ./grader.ts -o validation.jsonl
 
 # If references fail, your grader or task is broken
 cat validation.jsonl | jq 'select(.pass == false)'
@@ -199,7 +199,7 @@ An eval with only "make X work" misses "don't break Y".
 ### Using the Balance Command
 
 ```bash
-acp-harness balance prompts.jsonl -o balance.json
+agent-eval-harness balance prompts.jsonl -o balance.json
 ```
 
 Analyzes:
diff --git a/.claude/skills/acp-harness/references/graders.md b/.claude/skills/agent-eval-harness/references/graders.md
similarity index 93%
rename from .claude/skills/acp-harness/references/graders.md
rename to .claude/skills/agent-eval-harness/references/graders.md
index a2457e0..fc187af 100644
--- a/.claude/skills/acp-harness/references/graders.md
+++ b/.claude/skills/agent-eval-harness/references/graders.md
@@ -17,7 +17,7 @@ Export a `grade` function matching the `Grader` type:
 
 ```typescript
 // my-grader.ts
-import type { Grader } from '@plaited/acp-harness/schemas'
+import type { Grader } from '@plaited/agent-eval-harness/schemas'
 
 export const grade: Grader = async ({ input, output, hint, trajectory }) => {
   // Your scoring logic
@@ -32,7 +32,7 @@ export const grade: Grader = async ({ input, output, hint, trajectory }) => {
 
 **Usage:**
 ```bash
-acp-harness capture prompts.jsonl bunx claude-code-acp --grader ./my-grader.ts -o results.jsonl
+agent-eval-harness capture prompts.jsonl bunx claude-code-acp --grader ./my-grader.ts -o results.jsonl
 ```
 
 ## Python Grader
@@ -69,7 +69,7 @@ print(json.dumps({
 **Usage:**
 ```bash
 chmod +x ./grader.py
-acp-harness capture prompts.jsonl bunx claude-code-acp --grader ./grader.py -o results.jsonl
+agent-eval-harness capture prompts.jsonl bunx claude-code-acp --grader ./grader.py -o results.jsonl
 ```
 
 ## Executable Protocol
@@ -141,7 +141,7 @@ Wrap an LLM call in your grader for semantic evaluation:
 ```typescript
 // llm-judge.ts
 import Anthropic from '@anthropic-ai/sdk'
-import type { Grader } from '@plaited/acp-harness/schemas'
+import type { Grader } from '@plaited/agent-eval-harness/schemas'
 
 const client = new Anthropic()
 
diff --git a/.claude/skills/acp-harness/references/output-formats.md b/.claude/skills/agent-eval-harness/references/output-formats.md
similarity index 82%
rename from .claude/skills/acp-harness/references/output-formats.md
rename to .claude/skills/agent-eval-harness/references/output-formats.md
index 8cab355..c70d6ce 100644
--- a/.claude/skills/acp-harness/references/output-formats.md
+++ b/.claude/skills/agent-eval-harness/references/output-formats.md
@@ -7,27 +7,31 @@ The harness uses a "capture once, derive many views" approach. The `capture` com
 The `capture` command always outputs full trajectory JSONL:
 
 ```bash
-acp-harness capture prompts.jsonl bunx claude-code-acp -o results.jsonl
+agent-eval-harness capture prompts.jsonl bunx claude-code-acp -o results.jsonl
 ```
 
 ### Schema
 
 ```typescript
 type CaptureResult = {
-  id: string                    // Prompt identifier
-  input: string                 // Original prompt text
-  output: string                // Final agent response
-  hint?: string                 // Grader context (if provided in prompt)
-  trajectory: TrajectoryStep[]  // Full execution trajectory
+  id: string                      // Prompt identifier
+  input: string | string[]        // Single prompt or multi-turn conversation
+  output: string                  // Final agent response
+  hint?: string                   // Grader context (if provided in prompt)
+  trajectory: TrajectoryStep[]    // Full execution trajectory
   metadata: Record<string, unknown>  // Prompt metadata
   timing: {
-    start: number               // Unix timestamp (ms)
-    end: number                 // Unix timestamp (ms)
-    firstResponse?: number      // Time to first response (ms)
+    start: number                 // Unix timestamp (ms)
+    end: number                   // Unix timestamp (ms)
+    firstResponse?: number        // Time to first response (ms)
+    sessionCreation: number       // Time to create session (ms)
+    total: number                 // Total duration (end - start, ms)
+    inputTokens?: number          // Input tokens consumed (if available)
+    outputTokens?: number         // Output tokens generated (if available)
   }
-  toolErrors: boolean           // Whether any tool calls failed
-  errors?: string[]             // Error messages (if any)
-  score?: GraderResult          // Grader score (if grader was provided)
+  toolErrors: boolean             // Whether any tool calls failed
+  errors?: string[]               // Error messages (if any)
+  score?: GraderResult            // Grader score (if grader was provided)
 }
 
 type TrajectoryStep =
@@ -35,7 +39,7 @@ type TrajectoryStep =
   | { type: 'message'; content: string; timestamp: number; stepId?: string }
   | {
       type: 'tool_call'
-      name: string              // Tool title from ACP SDK
+      name: string              // Tool title
       status: string            // pending, in_progress, completed, failed
       input?: unknown           // Raw input parameters
       output?: unknown          // Raw output
@@ -63,7 +67,7 @@ type GraderResult = {
 The `summarize` command derives compact JSONL from full trajectory:
 
 ```bash
-acp-harness summarize results.jsonl -o summary.jsonl
+agent-eval-harness summarize results.jsonl -o summary.jsonl
 ```
 
 ### Schema
@@ -103,7 +107,7 @@ cat summary.jsonl | jq 'select(.output | contains("error"))'
 The `summarize` command can also produce markdown for LLM-as-judge workflows:
 
 ```bash
-acp-harness summarize results.jsonl --markdown -o results.md
+agent-eval-harness summarize results.jsonl --markdown -o results.md
 ```
 
 ### Structure
@@ -147,7 +151,7 @@ acp-harness summarize results.jsonl --markdown -o results.md
 The `trials` command produces per-prompt trial results:
 
 ```bash
-acp-harness trials prompts.jsonl bunx claude-code-acp -k 5 --grader ./grader.ts -o trials.jsonl
+agent-eval-harness trials prompts.jsonl bunx claude-code-acp -k 5 --grader ./grader.ts -o trials.jsonl
 ```
 
 ### Schema
@@ -224,7 +228,7 @@ The `toolErrors` field indicates whether any tool calls failed during execution:
 **Note:** `toolErrors` only indicates tool-level failures. For semantic pass/fail (did the agent accomplish the task?), use a grader:
 
 ```bash
-acp-harness capture prompts.jsonl bunx claude-code-acp --grader ./grader.ts -o results.jsonl
+agent-eval-harness capture prompts.jsonl bunx claude-code-acp --grader ./grader.ts -o results.jsonl
 ```
 
 ## Input Format
@@ -250,7 +254,7 @@ All commands stream output line-by-line as results complete:
 
 ```bash
 # Watch results in real-time
-acp-harness capture prompts.jsonl bunx claude-code-acp --progress -o results.jsonl &
+agent-eval-harness capture prompts.jsonl bunx claude-code-acp --progress -o results.jsonl &
 tail -f results.jsonl
 ```
 
diff --git a/.claude/skills/acp-adapters/SKILL.md b/.claude/skills/headless-adapters/SKILL.md
similarity index 63%
rename from .claude/skills/acp-adapters/SKILL.md
rename to .claude/skills/headless-adapters/SKILL.md
index 0db186a..7242d8e 100644
--- a/.claude/skills/acp-adapters/SKILL.md
+++ b/.claude/skills/headless-adapters/SKILL.md
@@ -1,10 +1,10 @@
 ---
-name: acp-adapters
-description: Discover, create, and validate ACP adapters for agent integration. Includes scaffolding tools and compliance testing for the Agent Client Protocol.
+name: headless-adapters
+description: Discover, create, and validate headless adapters for agent integration. Includes scaffolding tools and compliance testing for the Agent Client Protocol.
 compatibility: Bun >= 1.2.9
 ---
 
-# ACP Adapters
+# Headless Adapters
 
 ## Purpose
 
@@ -13,7 +13,6 @@ Schema-driven adapter for headless CLI agents. **No code required** - just defin
 | Use Case | Tool |
 |----------|------|
 | Wrap headless CLI agent | `headless` command |
-| Verify implementation | `adapter:check` command |
 | Create new schemas | [Schema Creation Guide](references/schema-creation-guide.md) |
 
 ## Quick Start
@@ -21,21 +20,17 @@ Schema-driven adapter for headless CLI agents. **No code required** - just defin
 1. **Check if a schema exists** in [schemas/](schemas/)
 2. **Run the adapter:**
    ```bash
-   ANTHROPIC_API_KEY=... bunx @plaited/acp-harness headless --schema .claude/skills/acp-adapters/schemas/claude-headless.json
-   ```
-3. **Validate compliance:**
-   ```bash
-   bunx @plaited/acp-harness adapter:check bunx @plaited/acp-harness headless --schema ./my-schema.json
+   ANTHROPIC_API_KEY=... bunx @plaited/agent-eval-harness headless --schema .claude/skills/headless-adapters/schemas/claude-headless.json
    ```
 
 ## CLI Commands
 
 ### headless
 
-Schema-driven ACP adapter for ANY headless CLI agent.
+Schema-driven adapter for ANY headless CLI agent.
 
 ```bash
-bunx @plaited/acp-harness headless --schema <path>
+bunx @plaited/agent-eval-harness headless --schema <path>
 ```
 
 **Options:**
@@ -82,46 +77,19 @@ Both modes support multi-turn conversations. Send multiple prompts to the same s
 
 ```typescript
 // Create one session, send multiple prompts
-const session = await client.createSession({ cwd: PROJECT_ROOT })
+const session = await manager.createSession({ cwd: PROJECT_ROOT })
 
 // Turn 1
-const { updates: turn1 } = await client.promptSync(session.id, createPrompt('Remember: 42'))
+const turn1 = await manager.prompt(session.id, 'Remember: 42')
 
 // Turn 2 - context is maintained
-const { updates: turn2 } = await client.promptSync(session.id, createPrompt('What number?'))
+const turn2 = await manager.prompt(session.id, 'What number?')
 ```
 
 How context is preserved:
 - **stream mode:** Process stays alive, CLI maintains internal state
 - **iterative mode:** Adapter builds history using `historyTemplate` from schema
 
----
-
-### adapter:check
-
-Validate that an adapter implements the ACP protocol correctly.
-
-```bash
-bunx @plaited/acp-harness adapter:check <command> [args...]
-```
-
-**Options:**
-| Flag | Description | Default |
-|------|-------------|---------|
-| `--timeout` | Timeout for each check in ms | `5000` |
-| `--verbose` | Show detailed protocol messages | false |
-
-**Checks Performed:**
-
-| Check | Description |
-|-------|-------------|
-| `spawn` | Adapter can be launched as subprocess |
-| `initialize` | Responds to initialize with valid `agentCapabilities` |
-| `session/new` | Creates session and returns `sessionId` |
-| `session/prompt` | Accepts prompt and emits `session/update` notifications |
-| `session/cancel` | Accepts cancel notification gracefully |
-| `framing` | All messages are newline-delimited JSON-RPC 2.0 |
-
 ## Pre-built Schemas
 
 Tested schemas are available in [schemas/](schemas/):
@@ -134,10 +102,10 @@ Tested schemas are available in [schemas/](schemas/):
 **Usage:**
 ```bash
 # Claude Code
-ANTHROPIC_API_KEY=... bunx @plaited/acp-harness headless --schema .claude/skills/acp-adapters/schemas/claude-headless.json
+ANTHROPIC_API_KEY=... bunx @plaited/agent-eval-harness headless --schema .claude/skills/headless-adapters/schemas/claude-headless.json
 
 # Gemini CLI
-GEMINI_API_KEY=... bunx @plaited/acp-harness headless --schema .claude/skills/acp-adapters/schemas/gemini-headless.json
+GEMINI_API_KEY=... bunx @plaited/agent-eval-harness headless --schema .claude/skills/headless-adapters/schemas/gemini-headless.json
 ```
 
 ## Agents with Headless CLI Support
@@ -160,10 +128,9 @@ GEMINI_API_KEY=... bunx @plaited/acp-harness headless --schema .claude/skills/ac
 
 1. Explore the CLI's `--help` to identify prompt, output, and auto-approve flags
 2. Capture sample JSON output from the CLI
-3. Map JSONPath patterns to ACP events
+3. Map JSONPath patterns to output events
 4. Create schema file based on an existing template
 5. Test with `headless` command
-6. Validate with `adapter:check`
 
 See [Schema Creation Guide](references/schema-creation-guide.md) for the complete workflow.
 
@@ -179,7 +146,7 @@ See [Schema Creation Guide](references/schema-creation-guide.md) for the complet
 | Timeout on prompt | JSONPath not matching | Capture raw CLI output, verify paths - [see guide](references/troubleshooting-guide.md#jsonpath-debugging) |
 | Empty responses | Content extraction failing | Check extract paths - [see guide](references/troubleshooting-guide.md#output-event-matching) |
 
-**📖 Complete troubleshooting documentation:** [Troubleshooting Guide](references/troubleshooting-guide.md)
+**Complete troubleshooting documentation:** [Troubleshooting Guide](references/troubleshooting-guide.md)
 
 This guide includes:
 - Detailed debugging steps for each issue
@@ -197,33 +164,13 @@ This guide includes:
 
 2. **Test headless adapter directly:**
    ```bash
-   printf '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":1}}\n' | \
-     bunx @plaited/acp-harness headless --schema ./my-schema.json
-   ```
-
-3. **Run adapter:check for diagnostics:**
-   ```bash
-   bunx @plaited/acp-harness adapter:check \
-     bunx @plaited/acp-harness headless --schema ./my-schema.json --verbose
+   bunx @plaited/agent-eval-harness headless --schema ./my-schema.json -p "Hello"
    ```
 
 ## External Resources
 
-- **ACP-Compatible Agents**: [agentclientprotocol.com/overview/agents](https://agentclientprotocol.com/overview/agents)
 - **AgentSkills Spec**: [agentskills.io](https://agentskills.io)
-- **ACP Protocol Docs**: Use the MCP server for protocol questions:
-  ```json
-  {
-    "mcpServers": {
-      "agent-client-protocol-docs": {
-        "type": "http",
-        "url": "https://agentclientprotocol.com/mcp"
-      }
-    }
-  }
-  ```
 
 ## Related
 
-- **[acp-harness skill](../acp-harness/SKILL.md)** - Running evaluations against adapters
-- **[@agentclientprotocol/sdk](https://www.npmjs.com/package/@agentclientprotocol/sdk)** - ACP SDK with TypeScript types
+- **[agent-eval-harness skill](../agent-eval-harness/SKILL.md)** - Running evaluations against adapters
diff --git a/.claude/skills/acp-adapters/references/schema-creation-guide.md b/.claude/skills/headless-adapters/references/schema-creation-guide.md
similarity index 87%
rename from .claude/skills/acp-adapters/references/schema-creation-guide.md
rename to .claude/skills/headless-adapters/references/schema-creation-guide.md
index 40fdc12..51eca04 100644
--- a/.claude/skills/acp-adapters/references/schema-creation-guide.md
+++ b/.claude/skills/headless-adapters/references/schema-creation-guide.md
@@ -4,7 +4,7 @@ Step-by-step workflow for creating headless adapter schemas for CLI coding agent
 
 ## Overview
 
-The headless adapter transforms any CLI agent with JSON output into an ACP-compatible adapter. You just need a schema file describing how to interact with the CLI.
+The headless adapter transforms any CLI agent with JSON output into a protocol-compatible adapter. You just need a schema file describing how to interact with the CLI.
 
 ## Workflow
 
@@ -14,8 +14,7 @@ flowchart TD
     B --> C["3. Capture Sample Output"]
     C --> D["4. Map JSONPath Patterns"]
     D --> E["5. Create Schema File"]
-    E --> F["6. Test with Headless"]
-    F --> G["7. Validate with adapter:check"]
+    E --> F["6. Test with Debug Mode"]
 ```
 
 ### Step 1: Explore CLI Help
@@ -82,7 +81,7 @@ AGENT_API_KEY=... <agent> exec -o stream-json "Say hello" | jq -c '.'
 
 Analyze the output to create event mappings:
 
-| JSON Event | ACP Event Type | Extract Fields |
+| JSON Event | Event Type | Extract Fields |
 |------------|---------------|----------------|
 | `{"type": "message", ...}` | `message` | `$.content` |
 | `{"type": "tool_use", ...}` | `tool_call` | `$.name` (title), `"pending"` (status) |
@@ -104,7 +103,7 @@ Use an existing schema as a template:
 
 ```bash
 # Copy from tested schema
-cp .claude/skills/acp-adapters/schemas/claude-headless.json ./my-agent-headless.json
+cp .claude/skills/headless-adapters/schemas/claude-headless.json ./my-agent-headless.json
 ```
 
 Modify for your agent:
@@ -151,25 +150,21 @@ Run the headless adapter with your schema:
 
 ```bash
 # Test the adapter
-AGENT_API_KEY=... bunx @plaited/acp-harness headless --schema ./my-agent-headless.json
+AGENT_API_KEY=... bunx @plaited/agent-eval-harness headless --schema ./my-agent-headless.json
 ```
 
-### Step 7: Validate with adapter:check
+### Step 6: Test with Debug Mode
 
-Verify ACP compliance:
+Use debug mode to verify JSONPath extraction:
 
 ```bash
-bunx @plaited/acp-harness adapter:check \
-  bunx @plaited/acp-harness headless --schema ./my-agent-headless.json
+AGENT_API_KEY=... bunx @plaited/agent-eval-harness headless --schema ./my-agent-headless.json --debug
 ```
 
-All 6 checks should pass:
-- `spawn` - Adapter launches
-- `initialize` - Protocol handshake works
-- `session/new` - Session creation works
-- `session/prompt` - Prompt handling works
-- `session/cancel` - Cancel is acknowledged
-- `framing` - Valid JSON-RPC framing
+Debug mode shows:
+- Raw CLI output lines
+- JSONPath match attempts
+- Extracted values for each event
 
 ## Schema Field Reference
 
@@ -218,7 +213,7 @@ All 6 checks should pass:
 
 **Not yet compatible:** [Copilot CLI](https://docs.github.com/en/copilot/concepts/agents/about-copilot-cli) (no JSON output)
 
-> **Note:** For detailed ACP protocol questions during schema creation, use the `agent-client-protocol-docs` MCP server. See SKILL.md for configuration.
+> **Note:** For detailed protocol questions during schema creation, use the `agent-client-protocol-docs` MCP server. See SKILL.md for configuration.
 
 ## Troubleshooting
 
@@ -246,7 +241,7 @@ cat raw-output.jsonl | jq '.'
 ```bash
 # Test initialize and session creation
 printf '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":1}}\n{"jsonrpc":"2.0","id":2,"method":"session/new","params":{}}\n' | \
-  bun src/headless-cli.ts --schema ./my-schema.json 2>&1
+  bunx @plaited/agent-eval-harness headless --schema ./my-schema.json 2>&1
 ```
 
 **3. Common JSONPath issues:**
@@ -271,6 +266,6 @@ Once your schema is working:
 
 1. Run the integration test suite with your schema
 2. Submit a PR to add it to the `schemas/` directory
-3. Include the integration test file as `integration_tests/acp-<agent>.spec.ts`
+3. Include the integration test file as `integration_tests/<agent>.spec.ts`
 
 Only schemas with passing integration tests are included in the official distribution.
diff --git a/.claude/skills/acp-adapters/references/troubleshooting-guide.md b/.claude/skills/headless-adapters/references/troubleshooting-guide.md
similarity index 95%
rename from .claude/skills/acp-adapters/references/troubleshooting-guide.md
rename to .claude/skills/headless-adapters/references/troubleshooting-guide.md
index 0e00d1f..4b48baf 100644
--- a/.claude/skills/acp-adapters/references/troubleshooting-guide.md
+++ b/.claude/skills/headless-adapters/references/troubleshooting-guide.md
@@ -83,7 +83,7 @@ Use wildcard `[*]` syntax in JSONPath expressions to iterate over array items:
    cat raw-output.jsonl | jq '.message.content[] | select(.type == "tool_use")'
    ```
 
-5. **Update schema with correct paths** and test with `adapter:check`
+5. **Update schema with correct paths** and test with `headless --debug`
 
 ---
 
@@ -162,7 +162,7 @@ Use `stdin: true` when:
    ```
 
 3. **Check process spawn in adapter:**
-   - Enable verbose mode: `adapter:check --verbose`
+   - Enable verbose mode: `headless --debug --verbose`
    - Look for command construction in output
 
 4. **Update schema:**
@@ -184,7 +184,7 @@ Use `stdin: true` when:
 
 Some CLIs have the output format embedded in the base command (e.g., `codex exec --json`), so the schema doesn't need separate `output.flag` and `output.value` fields. However, the `output` field is required by the adapter schema.
 
-Before acp-harness 0.4.3, specifying empty output values would add two empty strings as command arguments:
+Before agent-eval-harness 0.4.3, specifying empty output values would add two empty strings as command arguments:
 
 ```bash
 # Schema with empty output
@@ -199,9 +199,9 @@ codex exec --json - "" ""
 
 ### Solution
 
-**acp-harness 0.4.3+:** Empty output flags are automatically skipped - no changes needed.
+**agent-eval-harness 0.4.3+:** Empty output flags are automatically skipped - no changes needed.
 
-**acp-harness 0.4.2 and earlier:** Use a workaround by putting the output format in the command array:
+**agent-eval-harness 0.4.2 and earlier:** Use a workaround by putting the output format in the command array:
 
 ```json
 {
@@ -217,7 +217,7 @@ Even though Codex doesn't use these flags, this prevents empty strings from bein
 Use empty `output.flag` and `output.value` when:
 - CLI has output format embedded in command
 - No additional flags needed for JSON output
-- acp-harness version is 0.4.3 or later
+- agent-eval-harness version is 0.4.3 or later
 
 **Examples:**
 - Codex: `codex exec --json` (format is in command)
@@ -463,7 +463,7 @@ Output events use a two-step process:
 
 This means:
 - Check if `$.type` equals `"message"`
-- If yes, emit an ACP `message` update
+- If yes, emit a session `message` update
 - Extract content from `$.text`
 
 ### Wildcard Matching
@@ -565,8 +565,8 @@ The `result` configuration marks when the agent is done:
 
 1. **Check if events are being matched at all:**
    ```bash
-   # Run adapter:check with verbose mode
-   adapter:check --verbose -- bunx @plaited/acp-harness headless --schema schema.json
+   # Run headless --debug with verbose mode
+   bunx @plaited/agent-eval-harness headless --schema schema.json --debug
    ```
 
 2. **Verify JSON structure matches your paths:**
@@ -678,7 +678,7 @@ If you've tried all the debugging steps and still can't get your schema working,
    ```
 
 4. **Error messages:**
-   - From `adapter:check`
+   - From `headless --debug`
    - From `capture` command
    - From CLI stderr
 
diff --git a/.claude/skills/acp-adapters/schemas/claude-headless.json b/.claude/skills/headless-adapters/schemas/claude-headless.json
similarity index 100%
rename from .claude/skills/acp-adapters/schemas/claude-headless.json
rename to .claude/skills/headless-adapters/schemas/claude-headless.json
diff --git a/.claude/skills/acp-adapters/schemas/gemini-headless.json b/.claude/skills/headless-adapters/schemas/gemini-headless.json
similarity index 94%
rename from .claude/skills/acp-adapters/schemas/gemini-headless.json
rename to .claude/skills/headless-adapters/schemas/gemini-headless.json
index 3c351da..acf2f00 100644
--- a/.claude/skills/acp-adapters/schemas/gemini-headless.json
+++ b/.claude/skills/headless-adapters/schemas/gemini-headless.json
@@ -21,7 +21,7 @@
   "result": {
     "matchPath": "$.type",
     "matchValue": "result",
-    "contentPath": "$.stats"
+    "contentPath": "$.content"
   },
   "historyTemplate": "User: {{input}}\nAssistant: {{output}}"
 }
diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
index c7012ff..81b3564 100644
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -1,4 +1,4 @@
-# Code owners for acp-harness repository
+# Code owners for agent-eval-harness repository
 # These users will be automatically requested for review when someone opens a pull request.
 # See https://docs.github.com/en/repositories/managing-your-repositorys-settings-and-features/customizing-your-repository/about-code-owners
 
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 2aeea54..ea55cde 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -16,14 +16,14 @@ jobs:
     permissions:
       pull-requests: read
     outputs:
-      acp: ${{ steps.filter.outputs.acp }}
+      src: ${{ steps.filter.outputs.src }}
     steps:
       - uses: actions/checkout@v4
       - uses: dorny/paths-filter@v3
         id: filter
         with:
           filters: |
-            acp:
+            src:
               - 'src/**'
 
   test-pr:
@@ -46,14 +46,14 @@ jobs:
   #   - GEMINI_API_KEY: API key for Gemini CLI integration tests
   test-integration:
     needs: changes
-    if: ${{ needs.changes.outputs.acp == 'true' }}
+    if: ${{ needs.changes.outputs.src == 'true' }}
     runs-on: ubuntu-latest
 
     steps:
       - uses: actions/checkout@v4
 
-      - name: Run ACP integration tests
+      - name: Run integration tests
         env:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
           GEMINI_API_KEY: ${{ secrets.GEMINI_API_KEY }}
-        run: docker compose -f docker-compose.test.yml run --rm acp-test
+        run: docker compose -f docker-compose.test.yml run --rm test
diff --git a/.mcp.json b/.mcp.json
index e4338db..b0520ac 100644
--- a/.mcp.json
+++ b/.mcp.json
@@ -1,16 +1,8 @@
 {
   "mcpServers": {
-    "agent-skills-spec": {
-      "type": "http",
-      "url": "https://agentskills.io/mcp"
-    },
     "bun-docs" : {
       "type": "http",
       "url": "https://bun.com/docs/mcp"
-    },
-    "agent-client-protocol": {
-      "type": "http",
-      "url": "https://agentclientprotocol.com/mcp"
     }
   }
 }
diff --git a/.plaited/rules/code-review.md b/.plaited/rules/code-review.md
index db316cc..f0d9c5e 100644
--- a/.plaited/rules/code-review.md
+++ b/.plaited/rules/code-review.md
@@ -92,7 +92,7 @@ For functions with more than two parameters, use a single object parameter:
 
 ```typescript
 // ✅ Good: Object parameter pattern
-const createClient = ({
+const createSessionManager = ({
   command,
   timeout,
   cwd,
@@ -100,14 +100,14 @@ const createClient = ({
   command: string[]
   timeout: number
   cwd?: string
-}): ACPClient => { /* ... */ }
+}): SessionManager => { /* ... */ }
 
 // ❌ Avoid: Multiple positional parameters
-const createClient = (
+const createSessionManager = (
   command: string[],
   timeout: number,
   cwd?: string
-): ACPClient => { /* ... */ }
+): SessionManager => { /* ... */ }
 ```
 
 **Exception - CLI Entry Points:** CLI functions take `args: string[]` because that's what the shell provides—parsing happens inside the function. This rule applies to internal APIs where callers pass typed values directly.
diff --git a/.plaited/rules/module-organization.md b/.plaited/rules/module-organization.md
index cf3dbb8..46b6582 100644
--- a/.plaited/rules/module-organization.md
+++ b/.plaited/rules/module-organization.md
@@ -10,11 +10,11 @@ Use named re-export files at the parent level, matching the folder name:
 
 ```
 src/
-├── acp/                 # Feature module
-│   ├── acp.types.ts
-│   ├── acp.schemas.ts
-│   └── acp.ts           # Main implementation
-├── acp.ts               # Re-exports public API from acp/
+├── capture/             # Feature module
+│   ├── capture.types.ts
+│   ├── capture.schemas.ts
+│   └── capture.ts       # Main implementation
+├── capture.ts           # Re-exports public API from capture/
 ├── utils/
 │   └── format.ts
 └── utils.ts             # Re-exports public API from utils/
@@ -26,9 +26,9 @@ When a package has one primary feature, expose that re-export file directly as m
 
 ```json
 {
-  "main": "src/acp.ts",
+  "main": "src/harness.ts",
   "exports": {
-    ".": "./src/acp.ts",
+    ".": "./src/harness.ts",
     "./utils": "./src/utils.ts"
   }
 }
@@ -43,7 +43,7 @@ Always include `.ts` extensions in imports. Bun runs TypeScript natively—no co
 ```typescript
 // ✅ Good
 import { Config } from './module.types.ts'
-import { createClient } from '../acp/acp.ts'
+import { createClient } from '../capture/capture.ts'
 
 // ❌ Avoid
 import { Config } from './module.types'
diff --git a/.plaited/rules/testing.md b/.plaited/rules/testing.md
index 3d4eead..a39fe3e 100644
--- a/.plaited/rules/testing.md
+++ b/.plaited/rules/testing.md
@@ -31,12 +31,12 @@ Use `test` instead of `it` in test files for consistency:
 
 ```typescript
 // ✅ Good
-test('should create ACP client correctly', () => {
+test('should create session manager correctly', () => {
   // ...
 })
 
 // ❌ Avoid
-it('should create ACP client correctly', () => {
+it('should create session manager correctly', () => {
   // ...
 })
 ```
diff --git a/AGENTS.md b/AGENTS.md
index 14acc37..2d32284 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -19,21 +19,21 @@ bun run check:write
 bun test
 
 # Run Docker integration tests (requires API keys)
-ANTHROPIC_API_KEY=sk-... GEMINI_API_KEY=... docker compose -f docker-compose.test.yml run --rm acp-test
+ANTHROPIC_API_KEY=sk-... GEMINI_API_KEY=... docker compose -f docker-compose.test.yml run --rm test
 ```
 
 ## Quick Reference
 
 ### Package Overview
 
-`@plaited/acp-harness` is a CLI tool for capturing agent trajectories from ACP-compatible agents. It executes prompts, captures full trajectories (tools, thoughts, plans), and outputs structured JSONL for downstream scoring.
+`@plaited/agent-eval-harness` is a CLI tool for capturing agent trajectories from headless CLI agents. It executes prompts, captures full trajectories (tools, thoughts, plans), and outputs structured JSONL for downstream scoring.
 
 **CLI usage (with built-in headless adapter):**
 ```bash
 # Set API key and run capture with headless adapter (recommended)
 export ANTHROPIC_API_KEY=sk-...
-bunx @plaited/acp-harness capture prompts.jsonl \
-  bunx @plaited/acp-harness headless --schema .claude/skills/acp-adapters/schemas/claude-headless.json \
+bunx @plaited/agent-eval-harness capture prompts.jsonl \
+  --schema .claude/skills/headless-adapters/schemas/claude-headless.json \
   -o results.jsonl
 ```
 
@@ -53,39 +53,41 @@ bunx @plaited/acp-harness capture prompts.jsonl \
 
 This project provides two AI agent skills in `.claude/skills/`:
 
-### ACP Harness (`acp-harness`)
+### Agent Eval Harness (`agent-eval-harness`)
 
-CLI tool for capturing agent trajectories from ACP-compatible agents.
+CLI tool for capturing agent trajectories from headless CLI agents.
 
-**Commands:** `capture`, `trials`, `summarize`, `calibrate`, `validate-refs`, `balance`, `schemas`
+**Core Commands:** `capture`, `trials`, `summarize`, `calibrate`, `validate-refs`, `balance`, `schemas`
+
+**Pipeline Commands (Unix-style):** `run`, `extract`, `grade`, `format`, `compare`
 
 **Use cases:**
 - Capturing trajectories for downstream evaluation
 - Generating training data (SFT/DPO) with full context
 - Building regression test fixtures for agent behavior
+- Comparing agent responses across different configurations
 
-See `.claude/skills/acp-harness/SKILL.md` for complete documentation.
+See `.claude/skills/agent-eval-harness/SKILL.md` for complete documentation.
 
-### ACP Adapters (`acp-adapters`)
+### Headless Adapters (`headless-adapters`)
 
-Discover, create, and validate ACP adapters for agent integration.
+Discover, create, and validate headless adapters for agent integration.
 
-**Commands:** `headless`, `adapter:scaffold`, `adapter:check`
+**Commands:** `headless`
 
 **Use cases:**
 - Finding existing adapters for your agent
 - Wrapping headless CLI agents with schema-driven adapter
-- Building custom ACP adapters from scratch
-- Validating adapter ACP compliance
+- Creating new schemas for CLI agents
 
-See `.claude/skills/acp-adapters/SKILL.md` for complete documentation.
+See `.claude/skills/headless-adapters/SKILL.md` for complete documentation.
 
 ### Installing Skills
 
 Install skills for AI coding agents:
 
 ```bash
-curl -fsSL https://raw.githubusercontent.com/plaited/skills-installer/main/install.sh | bash -s -- --agent <agent-name> --project acp-harness
+curl -fsSL https://raw.githubusercontent.com/plaited/skills-installer/main/install.sh | bash -s -- --agent <agent-name> --project agent-eval-harness
 ```
 
 Replace `<agent-name>` with: `claude`, `cursor`, `copilot`, `opencode`, `amp`, `goose`, `factory`
diff --git a/README.md b/README.md
index c03da9d..1623206 100644
--- a/README.md
+++ b/README.md
@@ -1,10 +1,10 @@
-# @plaited/acp-harness
+# @plaited/agent-eval-harness
 
-[![npm version](https://img.shields.io/npm/v/@plaited/acp-harness.svg)](https://www.npmjs.com/package/@plaited/acp-harness)
-[![CI](https://github.com/plaited/acp-harness/actions/workflows/ci.yml/badge.svg)](https://github.com/plaited/acp-harness/actions/workflows/ci.yml)
+[![npm version](https://img.shields.io/npm/v/@plaited/agent-eval-harness.svg)](https://www.npmjs.com/package/@plaited/agent-eval-harness)
+[![CI](https://github.com/plaited/agent-eval-harness/actions/workflows/ci.yml/badge.svg)](https://github.com/plaited/agent-eval-harness/actions/workflows/ci.yml)
 [![License: ISC](https://img.shields.io/badge/License-ISC-blue.svg)](https://opensource.org/licenses/ISC)
 
-CLI tool for capturing agent trajectories from ACP-compatible agents. Execute prompts, capture full trajectories (tools, thoughts, plans), and output structured JSONL for downstream scoring. Available as both a CLI tool and as installable skills for AI coding agents.
+CLI tool for capturing agent trajectories from headless CLI agents. Execute prompts, capture full trajectories (tools, thoughts, plans), and output structured JSONL for downstream scoring. Available as both a CLI tool and as installable skills for AI coding agents.
 
 ## CLI Tool
 
@@ -13,59 +13,72 @@ Use these tools directly via the CLI without installation:
 ```bash
 # Using built-in headless adapter (recommended - no extra install needed)
 export ANTHROPIC_API_KEY=sk-...
-bunx @plaited/acp-harness capture prompts.jsonl \
-  bunx @plaited/acp-harness headless --schema ./schemas/claude-headless.json \
+bunx @plaited/agent-eval-harness capture prompts.jsonl \
+  --schema ./schemas/claude-headless.json \
   -o results.jsonl
-
-# Or with an external ACP adapter
-bunx @plaited/acp-harness capture prompts.jsonl bunx claude-code-acp -o results.jsonl
 ```
 
-**Prerequisite:** Set your API key. The `headless` command works with any CLI agent that supports JSON output - no adapter installation required:
+**Prerequisite:** Set your API key. The harness works with any CLI agent that supports JSON output - just provide a schema describing how to interact with it:
 
 ```bash
 export ANTHROPIC_API_KEY=sk-...   # For Claude
 export GEMINI_API_KEY=...         # For Gemini
 ```
 
-Pre-built schemas are available in `.claude/skills/acp-adapters/schemas/` for Claude and Gemini.
+Pre-built schemas are available in `.claude/skills/headless-adapters/schemas/` for Claude and Gemini.
 
-### Commands
+### Core Commands
 
 | Command | Description |
 |---------|-------------|
-| `capture <prompts> <cmd>` | Trajectory capture (full JSONL) |
-| `trials <prompts> <cmd>` | Multi-run with pass@k metrics |
+| `capture <prompts> --schema <path>` | Trajectory capture (full JSONL) |
+| `trials <prompts> --schema <path>` | Multi-run with pass@k metrics |
 | `summarize <results>` | Derive compact views from results |
 | `calibrate <results>` | Sample failures for review |
 | `validate-refs <prompts>` | Check reference solutions |
 | `balance <prompts>` | Analyze test set coverage |
 | `schemas [name]` | Export JSON schemas |
 | `headless --schema <path>` | Schema-driven adapter for any CLI agent |
-| `adapter:check <cmd>` | Validate adapter ACP compliance |
+
+### Pipeline Commands (Unix-style)
+
+| Command | Description |
+|---------|-------------|
+| `run <prompts> --schema <path>` | Execute prompts, output raw results |
+| `extract <raw> --schema <path>` | Parse raw output into trajectories |
+| `grade <results> --grader <path>` | Apply grader to extracted results |
+| `format <results> --style <style>` | Convert to markdown, csv, or jsonl |
+| `compare <run1> <run2>... --grader <path>` | Compare multiple runs |
 
 ### Examples
 
 ```bash
 # Capture trajectories using headless adapter (recommended)
-bunx @plaited/acp-harness capture prompts.jsonl \
-  bunx @plaited/acp-harness headless --schema ./schemas/claude-headless.json \
+bunx @plaited/agent-eval-harness capture prompts.jsonl \
+  --schema ./schemas/claude-headless.json \
   -o results.jsonl
 
-# Run trials for pass@k analysis
-bunx @plaited/acp-harness trials prompts.jsonl \
-  bunx @plaited/acp-harness headless --schema ./schemas/claude-headless.json \
-  -k 5 --grader ./grader.ts
+# Run trials for pass@k analysis with debug mode
+bunx @plaited/agent-eval-harness trials prompts.jsonl \
+  --schema ./schemas/claude-headless.json \
+  -k 5 --grader ./grader.ts --debug
 
 # Summarize results
-bunx @plaited/acp-harness summarize results.jsonl -o summary.jsonl
+bunx @plaited/agent-eval-harness summarize results.jsonl -o summary.jsonl
 
 # Export schemas
-bunx @plaited/acp-harness schemas CaptureResult --json
-
-# Validate adapter compliance
-bunx @plaited/acp-harness adapter:check \
-  bunx @plaited/acp-harness headless --schema ./schemas/claude-headless.json
+bunx @plaited/agent-eval-harness schemas CaptureResult --json
+
+# Pipeline workflow (Unix-style composition)
+cat prompts.jsonl | \
+  bunx @plaited/agent-eval-harness run -s ./schemas/claude-headless.json | \
+  bunx @plaited/agent-eval-harness extract -s ./schemas/claude-headless.json | \
+  bunx @plaited/agent-eval-harness grade -g ./grader.ts | \
+  bunx @plaited/agent-eval-harness format -f markdown > report.md
+
+# Compare multiple runs
+bunx @plaited/agent-eval-harness compare run1.jsonl run2.jsonl \
+  --grader ./compare-grader.ts -o comparison.jsonl
 ```
 
 ## Skills for AI Agents
@@ -73,24 +86,18 @@ bunx @plaited/acp-harness adapter:check \
 **Install skills** for use with AI coding agents:
 
 ```bash
-curl -fsSL https://raw.githubusercontent.com/plaited/skills-installer/main/install.sh | bash -s -- --agent <agent-name> --project acp-harness
+curl -fsSL https://raw.githubusercontent.com/plaited/skills-installer/main/install.sh | bash -s -- --agent <agent-name> --project agent-eval-harness
 ```
 
 Replace `<agent-name>` with your agent: `claude`, `cursor`, `copilot`, `opencode`, `amp`, `goose`, `factory`
 
-**Update skills:**
-
-```bash
-curl -fsSL https://raw.githubusercontent.com/plaited/skills-installer/main/install.sh | bash -s -- update --agent <agent-name> --project acp-harness
-```
-
 ### Available Skills
 
-#### ACP Harness
+#### Agent Eval Harness
 
 CLI tool for capturing agent trajectories, optimized for TypeScript/JavaScript projects using Bun.
 
-**Commands:**
+**Core Commands:**
 
 | Command | Description |
 |---------|-------------|
@@ -102,29 +109,36 @@ CLI tool for capturing agent trajectories, optimized for TypeScript/JavaScript p
 | `balance` | Analyze test set coverage distribution |
 | `schemas` | Export Zod schemas as JSON Schema |
 
+**Pipeline Commands (Unix-style):**
+
+| Command | Description |
+|---------|-------------|
+| `run` | Execute prompts, output raw results |
+| `extract` | Parse raw output into trajectories |
+| `grade` | Apply grader to extracted results |
+| `format` | Convert to markdown, csv, or jsonl |
+| `compare` | Compare multiple runs |
+
 **Use cases:**
 - Capturing trajectories for downstream evaluation (Braintrust, custom scorers)
 - Generating training data (SFT/DPO) with full context
 - Building regression test fixtures for agent behavior
 - Comparing agent responses across configurations
 
-#### ACP Adapters
+#### Headless Adapters
 
-Discover, create, and validate ACP adapters for agent integration.
+Schema-driven adapters for headless CLI agent integration.
 
 **Commands:**
 
 | Command | Description |
 |---------|-------------|
 | `headless` | Schema-driven adapter for any CLI agent |
-| `adapter:scaffold` | Generate new adapter project with handlers |
-| `adapter:check` | Validate ACP protocol compliance |
 
 **Use cases:**
 - Wrapping headless CLI agents with schema-driven adapter
 - Finding existing adapters for your agent
-- Building custom ACP adapters from scratch
-- Validating adapter implementations
+- Creating new schemas for CLI agents
 
 ## Input Format
 
@@ -140,6 +154,7 @@ Discover, create, and validate ACP adapters for agent integration.
 | `hint` | No | Grader context - what to look for |
 | `reference` | No | Reference solution (for validate-refs) |
 | `metadata` | No | Tags, category, difficulty for filtering |
+| `timeout` | No | Override default timeout for this prompt (ms) |
 
 ## Output Format
 
@@ -152,9 +167,10 @@ The harness outputs full trajectory JSONL (`CaptureResult` schema):
   "output": "Here's a button component...",
   "hint": "should contain <button>",
   "trajectory": [...],
-  "metadata": {"category": "ui", "agent": "bunx claude-code-acp", "trajectoryRichness": "full", "turnCount": 1},
-  "timing": {"start": 1234567890, "end": 1234567900, "sessionCreation": 234, "total": 10},
+  "metadata": {"category": "ui", "trajectoryRichness": "full", "turnCount": 1},
+  "timing": {"start": 1234567890, "end": 1234567900, "total": 10},
   "toolErrors": false,
+  "exitInfo": {"exitCode": 0},
   "score": {"pass": true, "score": 1.0, "reasoning": "Contains hint"}
 }
 ```
@@ -164,7 +180,7 @@ Key fields:
 - `score`: Grader result (only if `--grader` provided)
 - `trajectory`: Full execution trace (thoughts, messages, tool calls, plans)
 - `metadata.trajectoryRichness`: `"full"` | `"messages-only"` | `"minimal"`
-- `timing.sessionCreation`: Time to initialize session (ms)
+- `exitInfo`: Process exit information (`exitCode`, `signal`, `timedOut`)
 - `timing.total`: End-to-end duration (ms)
 
 ## Graders
@@ -176,7 +192,7 @@ Graders score agent outputs. The harness supports two types:
 Export a `grade` function:
 
 ```typescript
-import type { Grader } from '@plaited/acp-harness/schemas'
+import type { Grader } from '@plaited/agent-eval-harness/schemas'
 
 export const grade: Grader = async ({ input, output, hint, trajectory }) => {
   const pass = output.toLowerCase().includes(hint?.toLowerCase() ?? '')
@@ -189,7 +205,7 @@ export const grade: Grader = async ({ input, output, hint, trajectory }) => {
 ```
 
 ```bash
-acp-harness capture prompts.jsonl bunx claude-code-acp --grader ./grader.ts
+agent-eval-harness capture prompts.jsonl --schema ./claude.json --grader ./grader.ts
 ```
 
 ### Polyglot Graders (Python, etc.)
@@ -215,7 +231,7 @@ print(json.dumps({
 
 ```bash
 chmod +x grader.py
-acp-harness capture prompts.jsonl bunx claude-code-acp --grader ./grader.py
+agent-eval-harness capture prompts.jsonl --schema ./claude.json --grader ./grader.py
 ```
 
 **Protocol:**
@@ -243,13 +259,13 @@ bun run check        # Type check + lint + format
 bun test             # Run unit tests
 
 # Run integration tests in Docker (requires API keys)
-ANTHROPIC_API_KEY=sk-... docker compose -f docker-compose.test.yml run --rm acp-test
+ANTHROPIC_API_KEY=sk-... docker compose -f docker-compose.test.yml run --rm test
 ```
 
 ## Requirements
 
 - **Runtime:** Bun >= 1.2.9
-- **ACP Adapter:** Built-in `headless` command (recommended) or external adapter
+- **Schema:** JSON schema describing CLI agent interaction (see `.claude/skills/headless-adapters/schemas/`)
 - **API Key:** `ANTHROPIC_API_KEY` for Claude, `GEMINI_API_KEY` for Gemini
 
 ## License
diff --git a/bin/cli.ts b/bin/cli.ts
index 7d09ac5..4d2e93e 100644
--- a/bin/cli.ts
+++ b/bin/cli.ts
@@ -1,7 +1,7 @@
 #!/usr/bin/env bun
 
 /**
- * ACP Harness CLI - Agent evaluation toolkit.
+ * Agent Eval Harness CLI - Agent evaluation toolkit.
  *
  * @remarks
  * Router for harness commands. Thin wrapper that delegates to command modules.
@@ -15,30 +15,27 @@
  * - balance: Analyze test set coverage
  * - schemas: Export JSON schemas for non-TS users
  * - headless: Schema-driven adapter for any headless CLI agent
- * - adapter:scaffold: Scaffold new ACP adapter project
- * - adapter:check: Validate adapter ACP compliance
  */
 
-import { adapterCheck } from '../src/adapter-check.ts'
-import { adapterScaffold } from '../src/adapter-scaffold.ts'
-import { balance } from '../src/balance.ts'
-import { calibrate } from '../src/calibrate.ts'
-import { capture } from '../src/capture.ts'
+import { balance } from '../src/commands/balance.ts'
+import { calibrate } from '../src/commands/calibrate.ts'
+import { capture } from '../src/commands/capture.ts'
+import { summarize } from '../src/commands/summarize.ts'
+import { trials } from '../src/commands/trials.ts'
+import { validateRefs } from '../src/commands/validate-refs.ts'
 import { headless } from '../src/headless.ts'
-import { schemasCli } from '../src/schemas-cli.ts'
-import { summarize } from '../src/summarize.ts'
-import { trials } from '../src/trials.ts'
-import { validateRefs } from '../src/validate-refs.ts'
+import { compare, extract, format, grade, run } from '../src/pipeline.ts'
+import { schemasCli } from '../src/schemas/schemas-cli.ts'
 
 const [command, ...args] = Bun.argv.slice(2)
 
 const printHelp = () => {
   // biome-ignore lint/suspicious/noConsole: CLI help output
   console.log(`
-acp-harness - CLI tool for agent evaluation
+agent-eval-harness - CLI tool for agent evaluation
 
 Commands:
-  capture          Capture trajectories from ACP agent
+  capture          Capture trajectories from CLI agents
   trials           Run prompts multiple times for pass@k/pass^k metrics
   summarize        Derive compact views from results
   calibrate        Sample failures for grader review
@@ -46,42 +43,40 @@ Commands:
   balance          Analyze test set coverage
   schemas          Export JSON schemas for non-TypeScript users
   headless         Schema-driven adapter for any headless CLI agent
-  adapter:scaffold Scaffold a new ACP adapter project
-  adapter:check    Validate adapter ACP compliance
 
-Run 'acp-harness <command> --help' for command-specific help.
+Pipeline Commands (Unix-style composable):
+  run              Execute prompts and output raw results
+  extract          Parse raw output into trajectories
+  grade            Apply grader to extracted results
+  format           Convert results to different output formats
+  compare          Compare multiple runs of the same prompts
+
+Run 'agent-eval-harness <command> --help' for command-specific help.
 
 Examples:
-  # Basic capture
-  acp-harness capture prompts.jsonl bunx claude-code-acp -o results.jsonl
+  # Basic capture with schema
+  agent-eval-harness capture prompts.jsonl --schema claude.json -o results.jsonl
 
   # With grader
-  acp-harness capture prompts.jsonl bunx claude-code-acp --grader ./grader.ts -o results.jsonl
+  agent-eval-harness capture prompts.jsonl -s claude.json --grader ./grader.ts -o results.jsonl
 
   # Multi-run trials
-  acp-harness trials prompts.jsonl bunx claude-code-acp -k 5 --grader ./grader.ts -o trials.jsonl
+  agent-eval-harness trials prompts.jsonl -s claude.json -k 5 --grader ./grader.ts -o trials.jsonl
 
   # Derive summary view
-  acp-harness summarize results.jsonl -o summary.jsonl
-
-  # Export schemas
-  acp-harness schemas --json -o schemas.json
-
-  # Scaffold new adapter
-  acp-harness adapter:scaffold my-agent -o ./adapters/my-agent
+  agent-eval-harness summarize results.jsonl -o summary.jsonl
 
-  # Validate adapter compliance
-  acp-harness adapter:check bun ./my-adapter/src/main.ts
+  # Pipeline workflow
+  cat prompts.jsonl | \\
+    agent-eval-harness run -s claude.json | \\
+    agent-eval-harness extract -s claude.json | \\
+    agent-eval-harness grade -g ./grader.ts | \\
+    agent-eval-harness format -f markdown > report.md
 
-  # Run headless adapter with schema
-  acp-harness headless --schema ./claude-headless.json
+  # Compare multiple runs
+  agent-eval-harness compare run1.jsonl run2.jsonl -g ./compare-grader.ts
 
-  # Capture with headless adapter
-  acp-harness capture prompts.jsonl \\
-    acp-harness headless --schema ./claude-headless.json \\
-    -o results.jsonl
-
-Documentation: https://github.com/plaited/acp-harness
+Documentation: https://github.com/plaited/agent-eval-harness
 `)
 }
 
@@ -119,12 +114,25 @@ const main = async () => {
       await headless(args)
       break
 
-    case 'adapter:scaffold':
-      await adapterScaffold(args)
+    // Pipeline commands
+    case 'run':
+      await run(args)
+      break
+
+    case 'extract':
+      await extract(args)
+      break
+
+    case 'grade':
+      await grade(args)
+      break
+
+    case 'format':
+      await format(args)
       break
 
-    case 'adapter:check':
-      await adapterCheck(args)
+    case 'compare':
+      await compare(args)
       break
 
     case '-h':
@@ -143,7 +151,7 @@ const main = async () => {
 
     default:
       console.error(`Unknown command: ${command}`)
-      console.error("Run 'acp-harness --help' for usage")
+      console.error("Run 'agent-eval-harness --help' for usage")
       process.exit(1)
   }
 }
diff --git a/bin/tests/cli.spec.ts b/bin/tests/cli.spec.ts
index 8a6d371..c31c0db 100644
--- a/bin/tests/cli.spec.ts
+++ b/bin/tests/cli.spec.ts
@@ -3,11 +3,11 @@ import { join } from 'node:path'
 import { z } from 'zod'
 
 /**
- * Tests for the acp-harness CLI.
+ * Tests for the agent-eval-harness CLI.
  *
  * @remarks
  * Tests CLI argument parsing, help output, and output format schemas.
- * Integration tests requiring an actual ACP agent are in *.docker.ts files.
+ * Integration tests requiring an actual CLI agent are in *.docker.ts files.
  */
 
 const CLI_PATH = join(import.meta.dir, '..', 'cli.ts')
@@ -26,7 +26,7 @@ describe('CLI invocation', () => {
     const exitCode = await proc.exited
 
     expect(exitCode).toBe(0)
-    expect(stdout).toContain('acp-harness')
+    expect(stdout).toContain('agent-eval-harness')
     expect(stdout).toContain('Commands:')
     expect(stdout).toContain('capture')
     expect(stdout).toContain('trials')
@@ -42,7 +42,7 @@ describe('CLI invocation', () => {
     const exitCode = await proc.exited
 
     expect(exitCode).toBe(0)
-    expect(stdout).toContain('acp-harness')
+    expect(stdout).toContain('agent-eval-harness')
   })
 
   test('shows help when no arguments provided', async () => {
@@ -54,7 +54,7 @@ describe('CLI invocation', () => {
     const exitCode = await proc.exited
 
     expect(exitCode).toBe(0) // Exits cleanly when showing help
-    expect(stdout).toContain('acp-harness')
+    expect(stdout).toContain('agent-eval-harness')
   })
 
   test('help shows example commands', async () => {
@@ -64,7 +64,7 @@ describe('CLI invocation', () => {
     })
     const stdout = await new Response(proc.stdout).text()
 
-    expect(stdout).toContain('bunx claude-code-acp')
+    expect(stdout).toContain('--schema')
     expect(stdout).toContain('prompts.jsonl')
     expect(stdout).toContain('results.jsonl')
   })
@@ -84,8 +84,8 @@ describe('CLI invocation', () => {
     expect(stdout).toContain('schemas')
   })
 
-  test('fails with non-existent prompts file', async () => {
-    const proc = Bun.spawn(['bun', CLI_PATH, 'capture', 'nonexistent.jsonl', 'bunx', 'claude-code-acp'], {
+  test('fails with non-existent schema file', async () => {
+    const proc = Bun.spawn(['bun', CLI_PATH, 'capture', 'prompts.jsonl', '--schema', 'nonexistent.json'], {
       stdout: 'pipe',
       stderr: 'pipe',
     })
@@ -93,10 +93,10 @@ describe('CLI invocation', () => {
     const exitCode = await proc.exited
 
     expect(exitCode).not.toBe(0)
-    expect(stderr).toContain('no such file or directory')
+    expect(stderr).toContain('Schema file not found')
   })
 
-  test('fails when no agent command provided', async () => {
+  test('fails when no schema provided', async () => {
     const tmpFile = `/tmp/test-prompts-${Date.now()}.jsonl`
     await Bun.write(tmpFile, '{"id":"test-001","input":"test"}\n')
 
@@ -108,7 +108,7 @@ describe('CLI invocation', () => {
     const exitCode = await proc.exited
 
     expect(exitCode).toBe(1)
-    expect(stderr).toContain('ACP agent command is required')
+    expect(stderr).toContain('--schema is required')
   })
 
   test('fails with unknown command', async () => {
@@ -488,11 +488,11 @@ describe('MCP server config parsing', () => {
 // ============================================================================
 
 describe('error handling', () => {
-  test('fails with invalid JSONL format', async () => {
+  test('fails when schema file does not exist', async () => {
     const tmpFile = `/tmp/invalid-${Date.now()}.jsonl`
-    await Bun.write(tmpFile, '{invalid json}\n')
+    await Bun.write(tmpFile, '{"id": "t1", "input": "test"}\n')
 
-    const proc = Bun.spawn(['bun', CLI_PATH, 'capture', tmpFile, 'bunx', 'claude-code-acp'], {
+    const proc = Bun.spawn(['bun', CLI_PATH, 'capture', tmpFile, '--schema', 'nonexistent-schema.json'], {
       stdout: 'pipe',
       stderr: 'pipe',
     })
@@ -500,7 +500,7 @@ describe('error handling', () => {
     const exitCode = await proc.exited
 
     expect(exitCode).not.toBe(0)
-    expect(stderr).toContain('Invalid prompt at line 1')
+    expect(stderr).toContain('Schema file not found')
   })
 
   test('capture command requires prompts path', async () => {
diff --git a/bun.lock b/bun.lock
index 1305f1b..a904966 100644
--- a/bun.lock
+++ b/bun.lock
@@ -11,22 +11,13 @@
       "devDependencies": {
         "@biomejs/biome": "2.3.11",
         "@types/bun": "1.3.6",
-        "@zed-industries/claude-code-acp": "0.13.1",
         "format-package": "7.0.0",
         "lint-staged": "16.2.7",
         "typescript": "5.9.3",
       },
-      "peerDependencies": {
-        "@agentclientprotocol/sdk": "^0.13.0",
-        "typescript-language-server": "^5.1.3",
-      },
     },
   },
   "packages": {
-    "@agentclientprotocol/sdk": ["@agentclientprotocol/sdk@0.13.0", "", { "peerDependencies": { "zod": "^3.25.0 || ^4.0.0" } }, "sha512-Z6/Fp4cXLbYdMXr5AK752JM5qG2VKb6ShM0Ql6FimBSckMmLyK54OA20UhPYoH4C37FSFwUTARuwQOwQUToYrw=="],
-
-    "@anthropic-ai/claude-agent-sdk": ["@anthropic-ai/claude-agent-sdk@0.2.7", "", { "optionalDependencies": { "@img/sharp-darwin-arm64": "^0.33.5", "@img/sharp-darwin-x64": "^0.33.5", "@img/sharp-linux-arm": "^0.33.5", "@img/sharp-linux-arm64": "^0.33.5", "@img/sharp-linux-x64": "^0.33.5", "@img/sharp-linuxmusl-arm64": "^0.33.5", "@img/sharp-linuxmusl-x64": "^0.33.5", "@img/sharp-win32-x64": "^0.33.5" }, "peerDependencies": { "zod": "^4.0.0" } }, "sha512-I1/zcnLah74kZeRkj/1QnDaC6ItJ2m/Bftlm25uoaRkZx7i7SkcpqM9jGE/r2A8PMxnw5WpabP60Xgj99CrTuw=="],
-
     "@biomejs/biome": ["@biomejs/biome@2.3.11", "", { "optionalDependencies": { "@biomejs/cli-darwin-arm64": "2.3.11", "@biomejs/cli-darwin-x64": "2.3.11", "@biomejs/cli-linux-arm64": "2.3.11", "@biomejs/cli-linux-arm64-musl": "2.3.11", "@biomejs/cli-linux-x64": "2.3.11", "@biomejs/cli-linux-x64-musl": "2.3.11", "@biomejs/cli-win32-arm64": "2.3.11", "@biomejs/cli-win32-x64": "2.3.11" }, "bin": { "biome": "bin/biome" } }, "sha512-/zt+6qazBWguPG6+eWmiELqO+9jRsMZ/DBU3lfuU2ngtIQYzymocHhKiZRyrbra4aCOoyTg/BmY+6WH5mv9xmQ=="],
 
     "@biomejs/cli-darwin-arm64": ["@biomejs/cli-darwin-arm64@2.3.11", "", { "os": "darwin", "cpu": "arm64" }, "sha512-/uXXkBcPKVQY7rc9Ys2CrlirBJYbpESEDme7RKiBD6MmqR2w3j0+ZZXRIL2xiaNPsIMMNhP1YnA+jRRxoOAFrA=="],
@@ -55,44 +46,6 @@
 
     "@hapi/topo": ["@hapi/topo@3.1.6", "", { "dependencies": { "@hapi/hoek": "^8.3.0" } }, "sha512-tAag0jEcjwH+P2quUfipd7liWCNX2F8NvYjQp2wtInsZxnMlypdw0FtAOLxtvvkO+GSRRbmNi8m/5y42PQJYCQ=="],
 
-    "@hono/node-server": ["@hono/node-server@1.19.9", "", { "peerDependencies": { "hono": "^4" } }, "sha512-vHL6w3ecZsky+8P5MD+eFfaGTyCeOHUIFYMGpQGbrBTSmNNoxv0if69rEZ5giu36weC5saFuznL411gRX7bJDw=="],
-
-    "@img/sharp-darwin-arm64": ["@img/sharp-darwin-arm64@0.33.5", "", { "optionalDependencies": { "@img/sharp-libvips-darwin-arm64": "1.0.4" }, "os": "darwin", "cpu": "arm64" }, "sha512-UT4p+iz/2H4twwAoLCqfA9UH5pI6DggwKEGuaPy7nCVQ8ZsiY5PIcrRvD1DzuY3qYL07NtIQcWnBSY/heikIFQ=="],
-
-    "@img/sharp-darwin-x64": ["@img/sharp-darwin-x64@0.33.5", "", { "optionalDependencies": { "@img/sharp-libvips-darwin-x64": "1.0.4" }, "os": "darwin", "cpu": "x64" }, "sha512-fyHac4jIc1ANYGRDxtiqelIbdWkIuQaI84Mv45KvGRRxSAa7o7d1ZKAOBaYbnepLC1WqxfpimdeWfvqqSGwR2Q=="],
-
-    "@img/sharp-libvips-darwin-arm64": ["@img/sharp-libvips-darwin-arm64@1.0.4", "", { "os": "darwin", "cpu": "arm64" }, "sha512-XblONe153h0O2zuFfTAbQYAX2JhYmDHeWikp1LM9Hul9gVPjFY427k6dFEcOL72O01QxQsWi761svJ/ev9xEDg=="],
-
-    "@img/sharp-libvips-darwin-x64": ["@img/sharp-libvips-darwin-x64@1.0.4", "", { "os": "darwin", "cpu": "x64" }, "sha512-xnGR8YuZYfJGmWPvmlunFaWJsb9T/AO2ykoP3Fz/0X5XV2aoYBPkX6xqCQvUTKKiLddarLaxpzNe+b1hjeWHAQ=="],
-
-    "@img/sharp-libvips-linux-arm": ["@img/sharp-libvips-linux-arm@1.0.5", "", { "os": "linux", "cpu": "arm" }, "sha512-gvcC4ACAOPRNATg/ov8/MnbxFDJqf/pDePbBnuBDcjsI8PssmjoKMAz4LtLaVi+OnSb5FK/yIOamqDwGmXW32g=="],
-
-    "@img/sharp-libvips-linux-arm64": ["@img/sharp-libvips-linux-arm64@1.0.4", "", { "os": "linux", "cpu": "arm64" }, "sha512-9B+taZ8DlyyqzZQnoeIvDVR/2F4EbMepXMc/NdVbkzsJbzkUjhXv/70GQJ7tdLA4YJgNP25zukcxpX2/SueNrA=="],
-
-    "@img/sharp-libvips-linux-x64": ["@img/sharp-libvips-linux-x64@1.0.4", "", { "os": "linux", "cpu": "x64" }, "sha512-MmWmQ3iPFZr0Iev+BAgVMb3ZyC4KeFc3jFxnNbEPas60e1cIfevbtuyf9nDGIzOaW9PdnDciJm+wFFaTlj5xYw=="],
-
-    "@img/sharp-libvips-linuxmusl-arm64": ["@img/sharp-libvips-linuxmusl-arm64@1.0.4", "", { "os": "linux", "cpu": "arm64" }, "sha512-9Ti+BbTYDcsbp4wfYib8Ctm1ilkugkA/uscUn6UXK1ldpC1JjiXbLfFZtRlBhjPZ5o1NCLiDbg8fhUPKStHoTA=="],
-
-    "@img/sharp-libvips-linuxmusl-x64": ["@img/sharp-libvips-linuxmusl-x64@1.0.4", "", { "os": "linux", "cpu": "x64" }, "sha512-viYN1KX9m+/hGkJtvYYp+CCLgnJXwiQB39damAO7WMdKWlIhmYTfHjwSbQeUK/20vY154mwezd9HflVFM1wVSw=="],
-
-    "@img/sharp-linux-arm": ["@img/sharp-linux-arm@0.33.5", "", { "optionalDependencies": { "@img/sharp-libvips-linux-arm": "1.0.5" }, "os": "linux", "cpu": "arm" }, "sha512-JTS1eldqZbJxjvKaAkxhZmBqPRGmxgu+qFKSInv8moZ2AmT5Yib3EQ1c6gp493HvrvV8QgdOXdyaIBrhvFhBMQ=="],
-
-    "@img/sharp-linux-arm64": ["@img/sharp-linux-arm64@0.33.5", "", { "optionalDependencies": { "@img/sharp-libvips-linux-arm64": "1.0.4" }, "os": "linux", "cpu": "arm64" }, "sha512-JMVv+AMRyGOHtO1RFBiJy/MBsgz0x4AWrT6QoEVVTyh1E39TrCUpTRI7mx9VksGX4awWASxqCYLCV4wBZHAYxA=="],
-
-    "@img/sharp-linux-x64": ["@img/sharp-linux-x64@0.33.5", "", { "optionalDependencies": { "@img/sharp-libvips-linux-x64": "1.0.4" }, "os": "linux", "cpu": "x64" }, "sha512-opC+Ok5pRNAzuvq1AG0ar+1owsu842/Ab+4qvU879ippJBHvyY5n2mxF1izXqkPYlGuP/M556uh53jRLJmzTWA=="],
-
-    "@img/sharp-linuxmusl-arm64": ["@img/sharp-linuxmusl-arm64@0.33.5", "", { "optionalDependencies": { "@img/sharp-libvips-linuxmusl-arm64": "1.0.4" }, "os": "linux", "cpu": "arm64" }, "sha512-XrHMZwGQGvJg2V/oRSUfSAfjfPxO+4DkiRh6p2AFjLQztWUuY/o8Mq0eMQVIY7HJ1CDQUJlxGGZRw1a5bqmd1g=="],
-
-    "@img/sharp-linuxmusl-x64": ["@img/sharp-linuxmusl-x64@0.33.5", "", { "optionalDependencies": { "@img/sharp-libvips-linuxmusl-x64": "1.0.4" }, "os": "linux", "cpu": "x64" }, "sha512-WT+d/cgqKkkKySYmqoZ8y3pxx7lx9vVejxW/W4DOFMYVSkErR+w7mf2u8m/y4+xHe7yY9DAXQMWQhpnMuFfScw=="],
-
-    "@img/sharp-win32-x64": ["@img/sharp-win32-x64@0.33.5", "", { "os": "win32", "cpu": "x64" }, "sha512-MpY/o8/8kj+EcnxwvrP4aTJSWw/aZ7JIGR4aBeZkZw5B7/Jn+tY9/VNwtcoGmdT7GfggGIU4kygOMSbYnOrAbg=="],
-
-    "@isaacs/balanced-match": ["@isaacs/balanced-match@4.0.1", "", {}, "sha512-yzMTt9lEb8Gv7zRioUilSglI0c0smZ9k5D65677DLWLtWJaXIS3CqcGyUFByYKlnUj6TkjLVs54fBl6+TiGQDQ=="],
-
-    "@isaacs/brace-expansion": ["@isaacs/brace-expansion@5.0.0", "", { "dependencies": { "@isaacs/balanced-match": "^4.0.1" } }, "sha512-ZT55BDLV0yv0RBm2czMiZ+SqCGO7AvmOM3G/w2xhVPH+te0aKgFjmBvGlL1dH+ql2tgGO3MVrbb3jCKyvpgnxA=="],
-
-    "@modelcontextprotocol/sdk": ["@modelcontextprotocol/sdk@1.25.2", "", { "dependencies": { "@hono/node-server": "^1.19.7", "ajv": "^8.17.1", "ajv-formats": "^3.0.1", "content-type": "^1.0.5", "cors": "^2.8.5", "cross-spawn": "^7.0.5", "eventsource": "^3.0.2", "eventsource-parser": "^3.0.0", "express": "^5.0.1", "express-rate-limit": "^7.5.0", "jose": "^6.1.1", "json-schema-typed": "^8.0.2", "pkce-challenge": "^5.0.0", "raw-body": "^3.0.0", "zod": "^3.25 || ^4.0", "zod-to-json-schema": "^3.25.0" }, "peerDependencies": { "@cfworker/json-schema": "^4.1.1" }, "optionalPeers": ["@cfworker/json-schema"] }, "sha512-LZFeo4F9M5qOhC/Uc1aQSrBHxMrvxett+9KLHt7OhcExtoiRN9DKgbZffMP/nxjutWDQpfMDfP3nkHI4X9ijww=="],
-
     "@nodelib/fs.scandir": ["@nodelib/fs.scandir@2.1.5", "", { "dependencies": { "@nodelib/fs.stat": "2.0.5", "run-parallel": "^1.1.9" } }, "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g=="],
 
     "@nodelib/fs.stat": ["@nodelib/fs.stat@2.0.5", "", {}, "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A=="],
@@ -105,14 +58,6 @@
 
     "@types/node": ["@types/node@25.0.9", "", { "dependencies": { "undici-types": "~7.16.0" } }, "sha512-/rpCXHlCWeqClNBwUhDcusJxXYDjZTyE8v5oTO7WbL8eij2nKhUeU89/6xgjU7N4/Vh3He0BtyhJdQbDyhiXAw=="],
 
-    "@zed-industries/claude-code-acp": ["@zed-industries/claude-code-acp@0.13.1", "", { "dependencies": { "@agentclientprotocol/sdk": "0.13.0", "@anthropic-ai/claude-agent-sdk": "0.2.7", "@modelcontextprotocol/sdk": "1.25.2", "diff": "8.0.3", "minimatch": "10.1.1" }, "bin": { "claude-code-acp": "dist/index.js" } }, "sha512-eoLNxTOuV51KOWRrWAwxI9Hl++2Cgsb1bdIclBiIOubxLR89msn6HN2HoM5YONTath3oONEMi6yGpY4AzB+Xng=="],
-
-    "accepts": ["accepts@2.0.0", "", { "dependencies": { "mime-types": "^3.0.0", "negotiator": "^1.0.0" } }, "sha512-5cvg6CtKwfgdmVqY1WIiXKc3Q1bkRqGLi+2W/6ao+6Y7gu/RCwRuAhGEzh5B4KlszSuTLgZYuqFqo5bImjNKng=="],
-
-    "ajv": ["ajv@8.17.1", "", { "dependencies": { "fast-deep-equal": "^3.1.3", "fast-uri": "^3.0.1", "json-schema-traverse": "^1.0.0", "require-from-string": "^2.0.2" } }, "sha512-B/gBuNg5SiMTrPkC+A2+cW0RszwxYmn6VYxB/inlBStS5nx6xHIt/ehKRhIMhqusl7a8LjQoZnjCs5vhwxOQ1g=="],
-
-    "ajv-formats": ["ajv-formats@3.0.1", "", { "dependencies": { "ajv": "^8.0.0" } }, "sha512-8iUql50EUR+uUcdRQ3HDqa6EVyo3docL8g5WJ3FNcWmu62IbkGUue/pEyLBW8VGKKucTPgqeks4fIU1DA4yowQ=="],
-
     "ansi-escapes": ["ansi-escapes@7.2.0", "", { "dependencies": { "environment": "^1.0.0" } }, "sha512-g6LhBsl+GBPRWGWsBtutpzBYuIIdBkLEvad5C/va/74Db018+5TZiyA26cZJAr3Rft5lprVqOIPxf5Vid6tqAw=="],
 
     "ansi-regex": ["ansi-regex@5.0.1", "", {}, "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ=="],
@@ -123,18 +68,10 @@
 
     "array-union": ["array-union@2.1.0", "", {}, "sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw=="],
 
-    "body-parser": ["body-parser@2.2.2", "", { "dependencies": { "bytes": "^3.1.2", "content-type": "^1.0.5", "debug": "^4.4.3", "http-errors": "^2.0.0", "iconv-lite": "^0.7.0", "on-finished": "^2.4.1", "qs": "^6.14.1", "raw-body": "^3.0.1", "type-is": "^2.0.1" } }, "sha512-oP5VkATKlNwcgvxi0vM0p/D3n2C3EReYVX+DNYs5TjZFn/oQt2j+4sVJtSMr18pdRr8wjTcBl6LoV+FUwzPmNA=="],
-
     "braces": ["braces@3.0.3", "", { "dependencies": { "fill-range": "^7.1.1" } }, "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA=="],
 
     "bun-types": ["bun-types@1.3.6", "", { "dependencies": { "@types/node": "*" } }, "sha512-OlFwHcnNV99r//9v5IIOgQ9Uk37gZqrNMCcqEaExdkVq3Avwqok1bJFmvGMCkCE0FqzdY8VMOZpfpR3lwI+CsQ=="],
 
-    "bytes": ["bytes@3.1.2", "", {}, "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg=="],
-
-    "call-bind-apply-helpers": ["call-bind-apply-helpers@1.0.2", "", { "dependencies": { "es-errors": "^1.3.0", "function-bind": "^1.1.2" } }, "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ=="],
-
-    "call-bound": ["call-bound@1.0.4", "", { "dependencies": { "call-bind-apply-helpers": "^1.0.2", "get-intrinsic": "^1.3.0" } }, "sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg=="],
-
     "caller-callsite": ["caller-callsite@2.0.0", "", { "dependencies": { "callsites": "^2.0.0" } }, "sha512-JuG3qI4QOftFsZyOn1qq87fq5grLIyk1JYd5lJmdA+fG7aQ9pA/i3JIJGcO3q0MrRcHlOt1U+ZeHW8Dq9axALQ=="],
 
     "caller-path": ["caller-path@2.0.0", "", { "dependencies": { "caller-callsite": "^2.0.0" } }, "sha512-MCL3sf6nCSXOwCTzvPKhN18TU7AHTvdtam8DAogxcrJ8Rjfbbg7Lgng64H9Iy+vUV6VGFClN/TyxBkAebLRR4A=="],
@@ -157,122 +94,48 @@
 
     "commander": ["commander@14.0.2", "", {}, "sha512-TywoWNNRbhoD0BXs1P3ZEScW8W5iKrnbithIl0YH+uCmBd0QpPOA8yc82DS3BIE5Ma6FnBVUsJ7wVUDz4dvOWQ=="],
 
-    "content-disposition": ["content-disposition@1.0.1", "", {}, "sha512-oIXISMynqSqm241k6kcQ5UwttDILMK4BiurCfGEREw6+X9jkkpEe5T9FZaApyLGGOnFuyMWZpdolTXMtvEJ08Q=="],
-
-    "content-type": ["content-type@1.0.5", "", {}, "sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA=="],
-
-    "cookie": ["cookie@0.7.2", "", {}, "sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w=="],
-
-    "cookie-signature": ["cookie-signature@1.2.2", "", {}, "sha512-D76uU73ulSXrD1UXF4KE2TMxVVwhsnCgfAyTg9k8P6KGZjlXKrOLe4dJQKI3Bxi5wjesZoFXJWElNWBjPZMbhg=="],
-
-    "cors": ["cors@2.8.5", "", { "dependencies": { "object-assign": "^4", "vary": "^1" } }, "sha512-KIHbLJqu73RGr/hnbrO9uBeixNGuvSQjul/jdFvS/KFSIH1hWVd1ng7zOHx+YrEfInLG7q4n6GHQ9cDtxv/P6g=="],
-
     "cosmiconfig": ["cosmiconfig@5.2.1", "", { "dependencies": { "import-fresh": "^2.0.0", "is-directory": "^0.3.1", "js-yaml": "^3.13.1", "parse-json": "^4.0.0" } }, "sha512-H65gsXo1SKjf8zmrJ67eJk8aIRKV5ff2D4uKZIBZShbhGSpEmsQOPW/SKMKYhSTrqR7ufy6RP69rPogdaPh/kA=="],
 
-    "cross-spawn": ["cross-spawn@7.0.6", "", { "dependencies": { "path-key": "^3.1.0", "shebang-command": "^2.0.0", "which": "^2.0.1" } }, "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA=="],
-
-    "debug": ["debug@4.4.3", "", { "dependencies": { "ms": "^2.1.3" } }, "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA=="],
-
-    "depd": ["depd@2.0.0", "", {}, "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw=="],
-
-    "diff": ["diff@8.0.3", "", {}, "sha512-qejHi7bcSD4hQAZE0tNAawRK1ZtafHDmMTMkrrIGgSLl7hTnQHmKCeB45xAcbfTqK2zowkM3j3bHt/4b/ARbYQ=="],
-
     "dir-glob": ["dir-glob@3.0.1", "", { "dependencies": { "path-type": "^4.0.0" } }, "sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA=="],
 
-    "dunder-proto": ["dunder-proto@1.0.1", "", { "dependencies": { "call-bind-apply-helpers": "^1.0.1", "es-errors": "^1.3.0", "gopd": "^1.2.0" } }, "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A=="],
-
-    "ee-first": ["ee-first@1.1.1", "", {}, "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow=="],
-
     "emoji-regex": ["emoji-regex@8.0.0", "", {}, "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A=="],
 
-    "encodeurl": ["encodeurl@2.0.0", "", {}, "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg=="],
-
     "environment": ["environment@1.1.0", "", {}, "sha512-xUtoPkMggbz0MPyPiIWr1Kp4aeWJjDZ6SMvURhimjdZgsRuDplF5/s9hcgGhyXMhs+6vpnuoiZ2kFiu3FMnS8Q=="],
 
     "error-ex": ["error-ex@1.3.4", "", { "dependencies": { "is-arrayish": "^0.2.1" } }, "sha512-sqQamAnR14VgCr1A618A3sGrygcpK+HEbenA/HiEAkkUwcZIIB/tgWqHFxWgOyDh4nB4JCRimh79dR5Ywc9MDQ=="],
 
-    "es-define-property": ["es-define-property@1.0.1", "", {}, "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g=="],
-
-    "es-errors": ["es-errors@1.3.0", "", {}, "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw=="],
-
-    "es-object-atoms": ["es-object-atoms@1.1.1", "", { "dependencies": { "es-errors": "^1.3.0" } }, "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA=="],
-
     "escalade": ["escalade@3.2.0", "", {}, "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA=="],
 
-    "escape-html": ["escape-html@1.0.3", "", {}, "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow=="],
-
     "esprima": ["esprima@4.0.1", "", { "bin": { "esparse": "./bin/esparse.js", "esvalidate": "./bin/esvalidate.js" } }, "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A=="],
 
-    "etag": ["etag@1.8.1", "", {}, "sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg=="],
-
     "eventemitter3": ["eventemitter3@5.0.1", "", {}, "sha512-GWkBvjiSZK87ELrYOSESUYeVIc9mvLLf/nXalMOS5dYrgZq9o5OVkbZAVM06CVxYsCwH9BDZFPlQTlPA1j4ahA=="],
 
-    "eventsource": ["eventsource@3.0.7", "", { "dependencies": { "eventsource-parser": "^3.0.1" } }, "sha512-CRT1WTyuQoD771GW56XEZFQ/ZoSfWid1alKGDYMmkt2yl8UXrVR4pspqWNEcqKvVIzg6PAltWjxcSSPrboA4iA=="],
-
-    "eventsource-parser": ["eventsource-parser@3.0.6", "", {}, "sha512-Vo1ab+QXPzZ4tCa8SwIHJFaSzy4R6SHf7BY79rFBDf0idraZWAkYrDjDj8uWaSm3S2TK+hJ7/t1CEmZ7jXw+pg=="],
-
-    "express": ["express@5.2.1", "", { "dependencies": { "accepts": "^2.0.0", "body-parser": "^2.2.1", "content-disposition": "^1.0.0", "content-type": "^1.0.5", "cookie": "^0.7.1", "cookie-signature": "^1.2.1", "debug": "^4.4.0", "depd": "^2.0.0", "encodeurl": "^2.0.0", "escape-html": "^1.0.3", "etag": "^1.8.1", "finalhandler": "^2.1.0", "fresh": "^2.0.0", "http-errors": "^2.0.0", "merge-descriptors": "^2.0.0", "mime-types": "^3.0.0", "on-finished": "^2.4.1", "once": "^1.4.0", "parseurl": "^1.3.3", "proxy-addr": "^2.0.7", "qs": "^6.14.0", "range-parser": "^1.2.1", "router": "^2.2.0", "send": "^1.1.0", "serve-static": "^2.2.0", "statuses": "^2.0.1", "type-is": "^2.0.1", "vary": "^1.1.2" } }, "sha512-hIS4idWWai69NezIdRt2xFVofaF4j+6INOpJlVOLDO8zXGpUVEVzIYk12UUi2JzjEzWL3IOAxcTubgz9Po0yXw=="],
-
-    "express-rate-limit": ["express-rate-limit@7.5.1", "", { "peerDependencies": { "express": ">= 4.11" } }, "sha512-7iN8iPMDzOMHPUYllBEsQdWVB6fPDMPqwjBaFrgr4Jgr/+okjvzAy+UHlYYL/Vs0OsOrMkwS6PJDkFlJwoxUnw=="],
-
-    "fast-deep-equal": ["fast-deep-equal@3.1.3", "", {}, "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q=="],
-
     "fast-glob": ["fast-glob@3.3.3", "", { "dependencies": { "@nodelib/fs.stat": "^2.0.2", "@nodelib/fs.walk": "^1.2.3", "glob-parent": "^5.1.2", "merge2": "^1.3.0", "micromatch": "^4.0.8" } }, "sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg=="],
 
-    "fast-uri": ["fast-uri@3.1.0", "", {}, "sha512-iPeeDKJSWf4IEOasVVrknXpaBV0IApz/gp7S2bb7Z4Lljbl2MGJRqInZiUrQwV16cpzw/D3S5j5Julj/gT52AA=="],
-
     "fastq": ["fastq@1.20.1", "", { "dependencies": { "reusify": "^1.0.4" } }, "sha512-GGToxJ/w1x32s/D2EKND7kTil4n8OVk/9mycTc4VDza13lOvpUZTGX3mFSCtV9ksdGBVzvsyAVLM6mHFThxXxw=="],
 
     "fill-range": ["fill-range@7.1.1", "", { "dependencies": { "to-regex-range": "^5.0.1" } }, "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg=="],
 
-    "finalhandler": ["finalhandler@2.1.1", "", { "dependencies": { "debug": "^4.4.0", "encodeurl": "^2.0.0", "escape-html": "^1.0.3", "on-finished": "^2.4.1", "parseurl": "^1.3.3", "statuses": "^2.0.1" } }, "sha512-S8KoZgRZN+a5rNwqTxlZZePjT/4cnm0ROV70LedRHZ0p8u9fRID0hJUZQpkKLzro8LfmC8sx23bY6tVNxv8pQA=="],
-
     "format-package": ["format-package@7.0.0", "", { "dependencies": { "@hapi/joi": "^15.1.1", "chalk": "^4.1.2", "cosmiconfig": "^5.2.1", "fs-extra": "^10.0.0", "globby": "^11.0.4", "json5": "^2.2.0", "resolve-from": "^5.0.0", "sort-scripts": "^1.0.1", "yargs": "^17.3.1" }, "peerDependencies": { "prettier": "^2.0.0" }, "bin": { "format-package": "build/cli/index.js" } }, "sha512-XZ3OsNfo3I+Cy9/SBqqUFZUmXRgFaHK8MhRkSIUWIHRdG/WfGto7dyerbcDORR3GmzUwfYDYeyjC3tFBx8t7Jw=="],
 
-    "forwarded": ["forwarded@0.2.0", "", {}, "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow=="],
-
-    "fresh": ["fresh@2.0.0", "", {}, "sha512-Rx/WycZ60HOaqLKAi6cHRKKI7zxWbJ31MhntmtwMoaTeF7XFH9hhBp8vITaMidfljRQ6eYWCKkaTK+ykVJHP2A=="],
-
     "fs-extra": ["fs-extra@10.1.0", "", { "dependencies": { "graceful-fs": "^4.2.0", "jsonfile": "^6.0.1", "universalify": "^2.0.0" } }, "sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ=="],
 
-    "function-bind": ["function-bind@1.1.2", "", {}, "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA=="],
-
     "get-caller-file": ["get-caller-file@2.0.5", "", {}, "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg=="],
 
     "get-east-asian-width": ["get-east-asian-width@1.4.0", "", {}, "sha512-QZjmEOC+IT1uk6Rx0sX22V6uHWVwbdbxf1faPqJ1QhLdGgsRGCZoyaQBm/piRdJy/D2um6hM1UP7ZEeQ4EkP+Q=="],
 
-    "get-intrinsic": ["get-intrinsic@1.3.0", "", { "dependencies": { "call-bind-apply-helpers": "^1.0.2", "es-define-property": "^1.0.1", "es-errors": "^1.3.0", "es-object-atoms": "^1.1.1", "function-bind": "^1.1.2", "get-proto": "^1.0.1", "gopd": "^1.2.0", "has-symbols": "^1.1.0", "hasown": "^2.0.2", "math-intrinsics": "^1.1.0" } }, "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ=="],
-
-    "get-proto": ["get-proto@1.0.1", "", { "dependencies": { "dunder-proto": "^1.0.1", "es-object-atoms": "^1.0.0" } }, "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g=="],
-
     "glob-parent": ["glob-parent@5.1.2", "", { "dependencies": { "is-glob": "^4.0.1" } }, "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow=="],
 
     "globby": ["globby@11.1.0", "", { "dependencies": { "array-union": "^2.1.0", "dir-glob": "^3.0.1", "fast-glob": "^3.2.9", "ignore": "^5.2.0", "merge2": "^1.4.1", "slash": "^3.0.0" } }, "sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g=="],
 
-    "gopd": ["gopd@1.2.0", "", {}, "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg=="],
-
     "graceful-fs": ["graceful-fs@4.2.11", "", {}, "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ=="],
 
     "has-flag": ["has-flag@4.0.0", "", {}, "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ=="],
 
-    "has-symbols": ["has-symbols@1.1.0", "", {}, "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ=="],
-
-    "hasown": ["hasown@2.0.2", "", { "dependencies": { "function-bind": "^1.1.2" } }, "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ=="],
-
-    "hono": ["hono@4.11.4", "", {}, "sha512-U7tt8JsyrxSRKspfhtLET79pU8K+tInj5QZXs1jSugO1Vq5dFj3kmZsRldo29mTBfcjDRVRXrEZ6LS63Cog9ZA=="],
-
-    "http-errors": ["http-errors@2.0.1", "", { "dependencies": { "depd": "~2.0.0", "inherits": "~2.0.4", "setprototypeof": "~1.2.0", "statuses": "~2.0.2", "toidentifier": "~1.0.1" } }, "sha512-4FbRdAX+bSdmo4AUFuS0WNiPz8NgFt+r8ThgNWmlrjQjt1Q7ZR9+zTlce2859x4KSXrwIsaeTqDoKQmtP8pLmQ=="],
-
-    "iconv-lite": ["iconv-lite@0.7.2", "", { "dependencies": { "safer-buffer": ">= 2.1.2 < 3.0.0" } }, "sha512-im9DjEDQ55s9fL4EYzOAv0yMqmMBSZp6G0VvFyTMPKWxiSBHUj9NW/qqLmXUwXrrM7AvqSlTCfvqRb0cM8yYqw=="],
-
     "ignore": ["ignore@5.3.2", "", {}, "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g=="],
 
     "import-fresh": ["import-fresh@2.0.0", "", { "dependencies": { "caller-path": "^2.0.0", "resolve-from": "^3.0.0" } }, "sha512-eZ5H8rcgYazHbKC3PG4ClHNykCSxtAhxSSEM+2mb+7evD2CKF5V7c0dNum7AdpDh0ZdICwZY9sRSn8f+KH96sg=="],
 
-    "inherits": ["inherits@2.0.4", "", {}, "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ=="],
-
-    "ipaddr.js": ["ipaddr.js@1.9.1", "", {}, "sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g=="],
-
     "is-arrayish": ["is-arrayish@0.2.1", "", {}, "sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg=="],
 
     "is-directory": ["is-directory@0.3.1", "", {}, "sha512-yVChGzahRFvbkscn2MlwGismPO12i9+znNruC5gVEntG3qu0xQMzsGg/JFbrsqDOHtHFPci+V5aP5T9I+yeKqw=="],
@@ -285,20 +148,10 @@
 
     "is-number": ["is-number@7.0.0", "", {}, "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng=="],
 
-    "is-promise": ["is-promise@4.0.0", "", {}, "sha512-hvpoI6korhJMnej285dSg6nu1+e6uxs7zG3BYAm5byqDsgJNWwxzM6z6iZiAgQR4TJ30JmBTOwqZUw3WlyH3AQ=="],
-
-    "isexe": ["isexe@2.0.0", "", {}, "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw=="],
-
-    "jose": ["jose@6.1.3", "", {}, "sha512-0TpaTfihd4QMNwrz/ob2Bp7X04yuxJkjRGi4aKmOqwhov54i6u79oCv7T+C7lo70MKH6BesI3vscD1yb/yzKXQ=="],
-
     "js-yaml": ["js-yaml@3.14.2", "", { "dependencies": { "argparse": "^1.0.7", "esprima": "^4.0.0" }, "bin": { "js-yaml": "bin/js-yaml.js" } }, "sha512-PMSmkqxr106Xa156c2M265Z+FTrPl+oxd/rgOQy2tijQeK5TxQ43psO1ZCwhVOSdnn+RzkzlRz/eY4BgJBYVpg=="],
 
     "json-parse-better-errors": ["json-parse-better-errors@1.0.2", "", {}, "sha512-mrqyZKfX5EhL7hvqcV6WG1yYjnjeuYDzDhhcAAUrq8Po85NBQBJP+ZDUT75qZQ98IkUoBqdkExkukOU7Ts2wrw=="],
 
-    "json-schema-traverse": ["json-schema-traverse@1.0.0", "", {}, "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug=="],
-
-    "json-schema-typed": ["json-schema-typed@8.0.2", "", {}, "sha512-fQhoXdcvc3V28x7C7BMs4P5+kNlgUURe2jmUT1T//oBRMDrqy1QPelJimwZGo7Hg9VPV3EQV5Bnq4hbFy2vetA=="],
-
     "json5": ["json5@2.2.3", "", { "bin": { "json5": "lib/cli.js" } }, "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg=="],
 
     "jsonfile": ["jsonfile@6.2.0", "", { "dependencies": { "universalify": "^2.0.0" }, "optionalDependencies": { "graceful-fs": "^4.1.6" } }, "sha512-FGuPw30AdOIUTRMC2OMRtQV+jkVj2cfPqSeWXv1NEAJ1qZ5zb1X6z1mFhbfOB/iy3ssJCD+3KuZ8r8C3uVFlAg=="],
@@ -309,72 +162,30 @@
 
     "log-update": ["log-update@6.1.0", "", { "dependencies": { "ansi-escapes": "^7.0.0", "cli-cursor": "^5.0.0", "slice-ansi": "^7.1.0", "strip-ansi": "^7.1.0", "wrap-ansi": "^9.0.0" } }, "sha512-9ie8ItPR6tjY5uYJh8K/Zrv/RMZ5VOlOWvtZdEHYSTFKZfIBPQa9tOAEeAWhd+AnIneLJ22w5fjOYtoutpWq5w=="],
 
-    "math-intrinsics": ["math-intrinsics@1.1.0", "", {}, "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g=="],
-
-    "media-typer": ["media-typer@1.1.0", "", {}, "sha512-aisnrDP4GNe06UcKFnV5bfMNPBUw4jsLGaWwWfnH3v02GnBuXX2MCVn5RbrWo0j3pczUilYblq7fQ7Nw2t5XKw=="],
-
-    "merge-descriptors": ["merge-descriptors@2.0.0", "", {}, "sha512-Snk314V5ayFLhp3fkUREub6WtjBfPdCPY1Ln8/8munuLuiYhsABgBVWsozAG+MWMbVEvcdcpbi9R7ww22l9Q3g=="],
-
     "merge2": ["merge2@1.4.1", "", {}, "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg=="],
 
     "micromatch": ["micromatch@4.0.8", "", { "dependencies": { "braces": "^3.0.3", "picomatch": "^2.3.1" } }, "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA=="],
 
-    "mime-db": ["mime-db@1.54.0", "", {}, "sha512-aU5EJuIN2WDemCcAp2vFBfp/m4EAhWJnUNSSw0ixs7/kXbd6Pg64EmwJkNdFhB8aWt1sH2CTXrLxo/iAGV3oPQ=="],
-
-    "mime-types": ["mime-types@3.0.2", "", { "dependencies": { "mime-db": "^1.54.0" } }, "sha512-Lbgzdk0h4juoQ9fCKXW4by0UJqj+nOOrI9MJ1sSj4nI8aI2eo1qmvQEie4VD1glsS250n15LsWsYtCugiStS5A=="],
-
     "mimic-function": ["mimic-function@5.0.1", "", {}, "sha512-VP79XUPxV2CigYP3jWwAUFSku2aKqBH7uTAapFWCBqutsbmDo96KY5o8uh6U+/YSIn5OxJnXp73beVkpqMIGhA=="],
 
-    "minimatch": ["minimatch@10.1.1", "", { "dependencies": { "@isaacs/brace-expansion": "^5.0.0" } }, "sha512-enIvLvRAFZYXJzkCYG5RKmPfrFArdLv+R+lbQ53BmIMLIry74bjKzX6iHAm8WYamJkhSSEabrWN5D97XnKObjQ=="],
-
-    "ms": ["ms@2.1.3", "", {}, "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="],
-
     "nano-spawn": ["nano-spawn@2.0.0", "", {}, "sha512-tacvGzUY5o2D8CBh2rrwxyNojUsZNU2zjNTzKQrkgGJQTbGAfArVWXSKMBokBeeg6C7OLRGUEyoFlYbfeWQIqw=="],
 
-    "negotiator": ["negotiator@1.0.0", "", {}, "sha512-8Ofs/AUQh8MaEcrlq5xOX0CQ9ypTF5dl78mjlMNfOK08fzpgTHQRQPBxcPlEtIw0yRpws+Zo/3r+5WRby7u3Gg=="],
-
-    "object-assign": ["object-assign@4.1.1", "", {}, "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg=="],
-
-    "object-inspect": ["object-inspect@1.13.4", "", {}, "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew=="],
-
-    "on-finished": ["on-finished@2.4.1", "", { "dependencies": { "ee-first": "1.1.1" } }, "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg=="],
-
-    "once": ["once@1.4.0", "", { "dependencies": { "wrappy": "1" } }, "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w=="],
-
     "onetime": ["onetime@7.0.0", "", { "dependencies": { "mimic-function": "^5.0.0" } }, "sha512-VXJjc87FScF88uafS3JllDgvAm+c/Slfz06lorj2uAY34rlUu0Nt+v8wreiImcrgAjjIHp1rXpTDlLOGw29WwQ=="],
 
     "parse-json": ["parse-json@4.0.0", "", { "dependencies": { "error-ex": "^1.3.1", "json-parse-better-errors": "^1.0.1" } }, "sha512-aOIos8bujGN93/8Ox/jPLh7RwVnPEysynVFE+fQZyg6jKELEHwzgKdLRFHUgXJL6kylijVSBC4BvN9OmsB48Rw=="],
 
-    "parseurl": ["parseurl@1.3.3", "", {}, "sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ=="],
-
-    "path-key": ["path-key@3.1.1", "", {}, "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q=="],
-
-    "path-to-regexp": ["path-to-regexp@8.3.0", "", {}, "sha512-7jdwVIRtsP8MYpdXSwOS0YdD0Du+qOoF/AEPIt88PcCFrZCzx41oxku1jD88hZBwbNUIEfpqvuhjFaMAqMTWnA=="],
-
     "path-type": ["path-type@4.0.0", "", {}, "sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw=="],
 
     "picomatch": ["picomatch@2.3.1", "", {}, "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA=="],
 
     "pidtree": ["pidtree@0.6.0", "", { "bin": { "pidtree": "bin/pidtree.js" } }, "sha512-eG2dWTVw5bzqGRztnHExczNxt5VGsE6OwTeCG3fdUf9KBsZzO3R5OIIIzWR+iZA0NtZ+RDVdaoE2dK1cn6jH4g=="],
 
-    "pkce-challenge": ["pkce-challenge@5.0.1", "", {}, "sha512-wQ0b/W4Fr01qtpHlqSqspcj3EhBvimsdh0KlHhH8HRZnMsEa0ea2fTULOXOS9ccQr3om+GcGRk4e+isrZWV8qQ=="],
-
     "prettier": ["prettier@2.8.8", "", { "bin": { "prettier": "bin-prettier.js" } }, "sha512-tdN8qQGvNjw4CHbY+XXk0JgCXn9QiF21a55rBe5LJAU+kDyC4WQn4+awm2Xfk2lQMk5fKup9XgzTZtGkjBdP9Q=="],
 
-    "proxy-addr": ["proxy-addr@2.0.7", "", { "dependencies": { "forwarded": "0.2.0", "ipaddr.js": "1.9.1" } }, "sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg=="],
-
-    "qs": ["qs@6.14.1", "", { "dependencies": { "side-channel": "^1.1.0" } }, "sha512-4EK3+xJl8Ts67nLYNwqw/dsFVnCf+qR7RgXSK9jEEm9unao3njwMDdmsdvoKBKHzxd7tCYz5e5M+SnMjdtXGQQ=="],
-
     "queue-microtask": ["queue-microtask@1.2.3", "", {}, "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A=="],
 
-    "range-parser": ["range-parser@1.2.1", "", {}, "sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg=="],
-
-    "raw-body": ["raw-body@3.0.2", "", { "dependencies": { "bytes": "~3.1.2", "http-errors": "~2.0.1", "iconv-lite": "~0.7.0", "unpipe": "~1.0.0" } }, "sha512-K5zQjDllxWkf7Z5xJdV0/B0WTNqx6vxG70zJE4N0kBs4LovmEYWJzQGxC9bS9RAKu3bgM40lrd5zoLJ12MQ5BA=="],
-
     "require-directory": ["require-directory@2.1.1", "", {}, "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q=="],
 
-    "require-from-string": ["require-from-string@2.0.2", "", {}, "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw=="],
-
     "resolve-from": ["resolve-from@5.0.0", "", {}, "sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw=="],
 
     "restore-cursor": ["restore-cursor@5.1.0", "", { "dependencies": { "onetime": "^7.0.0", "signal-exit": "^4.1.0" } }, "sha512-oMA2dcrw6u0YfxJQXm342bFKX/E4sG9rbTzO9ptUcR/e8A33cHuvStiYOwH7fszkZlZ1z/ta9AAoPk2F4qIOHA=="],
@@ -383,30 +194,8 @@
 
     "rfdc": ["rfdc@1.4.1", "", {}, "sha512-q1b3N5QkRUWUl7iyylaaj3kOpIT0N2i9MqIEQXP73GVsN9cw3fdx8X63cEmWhJGi2PPCF23Ijp7ktmd39rawIA=="],
 
-    "router": ["router@2.2.0", "", { "dependencies": { "debug": "^4.4.0", "depd": "^2.0.0", "is-promise": "^4.0.0", "parseurl": "^1.3.3", "path-to-regexp": "^8.0.0" } }, "sha512-nLTrUKm2UyiL7rlhapu/Zl45FwNgkZGaCpZbIHajDYgwlJCOzLSk+cIPAnsEqV955GjILJnKbdQC1nVPz+gAYQ=="],
-
     "run-parallel": ["run-parallel@1.2.0", "", { "dependencies": { "queue-microtask": "^1.2.2" } }, "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA=="],
 
-    "safer-buffer": ["safer-buffer@2.1.2", "", {}, "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg=="],
-
-    "send": ["send@1.2.1", "", { "dependencies": { "debug": "^4.4.3", "encodeurl": "^2.0.0", "escape-html": "^1.0.3", "etag": "^1.8.1", "fresh": "^2.0.0", "http-errors": "^2.0.1", "mime-types": "^3.0.2", "ms": "^2.1.3", "on-finished": "^2.4.1", "range-parser": "^1.2.1", "statuses": "^2.0.2" } }, "sha512-1gnZf7DFcoIcajTjTwjwuDjzuz4PPcY2StKPlsGAQ1+YH20IRVrBaXSWmdjowTJ6u8Rc01PoYOGHXfP1mYcZNQ=="],
-
-    "serve-static": ["serve-static@2.2.1", "", { "dependencies": { "encodeurl": "^2.0.0", "escape-html": "^1.0.3", "parseurl": "^1.3.3", "send": "^1.2.0" } }, "sha512-xRXBn0pPqQTVQiC8wyQrKs2MOlX24zQ0POGaj0kultvoOCstBQM5yvOhAVSUwOMjQtTvsPWoNCHfPGwaaQJhTw=="],
-
-    "setprototypeof": ["setprototypeof@1.2.0", "", {}, "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw=="],
-
-    "shebang-command": ["shebang-command@2.0.0", "", { "dependencies": { "shebang-regex": "^3.0.0" } }, "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA=="],
-
-    "shebang-regex": ["shebang-regex@3.0.0", "", {}, "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A=="],
-
-    "side-channel": ["side-channel@1.1.0", "", { "dependencies": { "es-errors": "^1.3.0", "object-inspect": "^1.13.3", "side-channel-list": "^1.0.0", "side-channel-map": "^1.0.1", "side-channel-weakmap": "^1.0.2" } }, "sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw=="],
-
-    "side-channel-list": ["side-channel-list@1.0.0", "", { "dependencies": { "es-errors": "^1.3.0", "object-inspect": "^1.13.3" } }, "sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA=="],
-
-    "side-channel-map": ["side-channel-map@1.0.1", "", { "dependencies": { "call-bound": "^1.0.2", "es-errors": "^1.3.0", "get-intrinsic": "^1.2.5", "object-inspect": "^1.13.3" } }, "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA=="],
-
-    "side-channel-weakmap": ["side-channel-weakmap@1.0.2", "", { "dependencies": { "call-bound": "^1.0.2", "es-errors": "^1.3.0", "get-intrinsic": "^1.2.5", "object-inspect": "^1.13.3", "side-channel-map": "^1.0.1" } }, "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A=="],
-
     "signal-exit": ["signal-exit@4.1.0", "", {}, "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw=="],
 
     "slash": ["slash@3.0.0", "", {}, "sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q=="],
@@ -417,8 +206,6 @@
 
     "sprintf-js": ["sprintf-js@1.0.3", "", {}, "sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g=="],
 
-    "statuses": ["statuses@2.0.2", "", {}, "sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw=="],
-
     "string-argv": ["string-argv@0.3.2", "", {}, "sha512-aqD2Q0144Z+/RqG52NeHEkZauTAUWJO8c6yTftGJKO3Tja5tUgIfmIl6kExvhtxSDP7fXB6DvzkfMpCd/F3G+Q=="],
 
     "string-width": ["string-width@4.2.3", "", { "dependencies": { "emoji-regex": "^8.0.0", "is-fullwidth-code-point": "^3.0.0", "strip-ansi": "^6.0.1" } }, "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g=="],
@@ -429,10 +216,6 @@
 
     "to-regex-range": ["to-regex-range@5.0.1", "", { "dependencies": { "is-number": "^7.0.0" } }, "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ=="],
 
-    "toidentifier": ["toidentifier@1.0.1", "", {}, "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA=="],
-
-    "type-is": ["type-is@2.0.1", "", { "dependencies": { "content-type": "^1.0.5", "media-typer": "^1.1.0", "mime-types": "^3.0.0" } }, "sha512-OZs6gsjF4vMp32qrCbiVSkrFmXtG/AZhY3t0iAMrMBiAZyV9oALtXO8hsrHbMXF9x6L3grlFuwW2oAz7cav+Gw=="],
-
     "typescript": ["typescript@5.9.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="],
 
     "typescript-language-server": ["typescript-language-server@5.1.3", "", { "bin": { "typescript-language-server": "lib/cli.mjs" } }, "sha512-r+pAcYtWdN8tKlYZPwiiHNA2QPjXnI02NrW5Sf2cVM3TRtuQ3V9EKKwOxqwaQ0krsaEXk/CbN90I5erBuf84Vg=="],
@@ -441,16 +224,8 @@
 
     "universalify": ["universalify@2.0.1", "", {}, "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw=="],
 
-    "unpipe": ["unpipe@1.0.0", "", {}, "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ=="],
-
-    "vary": ["vary@1.1.2", "", {}, "sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg=="],
-
-    "which": ["which@2.0.2", "", { "dependencies": { "isexe": "^2.0.0" }, "bin": { "node-which": "./bin/node-which" } }, "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA=="],
-
     "wrap-ansi": ["wrap-ansi@9.0.2", "", { "dependencies": { "ansi-styles": "^6.2.1", "string-width": "^7.0.0", "strip-ansi": "^7.1.0" } }, "sha512-42AtmgqjV+X1VpdOfyTGOYRi0/zsoLqtXQckTmqTeybT+BDIbM/Guxo7x3pE2vtpr1ok6xRqM9OpBe+Jyoqyww=="],
 
-    "wrappy": ["wrappy@1.0.2", "", {}, "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ=="],
-
     "y18n": ["y18n@5.0.8", "", {}, "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA=="],
 
     "yaml": ["yaml@2.8.2", "", { "bin": { "yaml": "bin.mjs" } }, "sha512-mplynKqc1C2hTVYxd0PU2xQAc22TI1vShAYGksCCfxbn/dFwnHTNi1bvYsBTkhdUNtGIf5xNOg938rrSSYvS9A=="],
@@ -461,8 +236,6 @@
 
     "zod": ["zod@4.3.5", "", {}, "sha512-k7Nwx6vuWx1IJ9Bjuf4Zt1PEllcwe7cls3VNzm4CQ1/hgtFUK2bRNG3rvnpPUhFjmqJKAKtjV576KnUkHocg/g=="],
 
-    "zod-to-json-schema": ["zod-to-json-schema@3.25.1", "", { "peerDependencies": { "zod": "^3.25 || ^4" } }, "sha512-pM/SU9d3YAggzi6MtR4h7ruuQlqKtad8e9S0fmxcMi+ueAK5Korys/aWcV9LIIHTVbj01NdzxcnXSN+O74ZIVA=="],
-
     "cli-truncate/string-width": ["string-width@8.1.0", "", { "dependencies": { "get-east-asian-width": "^1.3.0", "strip-ansi": "^7.1.0" } }, "sha512-Kxl3KJGb/gxkaUMOjRsQ8IrXiGW75O4E3RPjFIINOVH8AMl2SQ/yWdTzWwF3FevIX9LcMAjJW+GRwAlAbTSXdg=="],
 
     "cliui/wrap-ansi": ["wrap-ansi@7.0.0", "", { "dependencies": { "ansi-styles": "^4.0.0", "string-width": "^4.1.0", "strip-ansi": "^6.0.0" } }, "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q=="],
diff --git a/docker-compose.test.yml b/docker-compose.test.yml
index 5e7cbd3..ef5def7 100644
--- a/docker-compose.test.yml
+++ b/docker-compose.test.yml
@@ -9,7 +9,7 @@
 #   CI:     Uses secrets from GitHub Actions
 
 services:
-  acp-test:
+  test:
     build:
       context: .
       dockerfile: Dockerfile.test
diff --git a/package.json b/package.json
index 6440068..8798048 100644
--- a/package.json
+++ b/package.json
@@ -1,27 +1,28 @@
 {
-  "name": "@plaited/acp-harness",
-  "version": "0.4.4",
-  "description": "CLI tool for capturing agent trajectories from ACP-compatible agents",
+  "name": "@plaited/agent-eval-harness",
+  "version": "0.5.0",
+  "description": "CLI tool for capturing agent trajectories from headless CLI agents",
   "license": "ISC",
   "engines": {
     "bun": ">= v1.2.9"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/plaited/acp-harness.git"
+    "url": "git+https://github.com/plaited/agent-eval-harness.git"
   },
   "bugs": {
-    "url": "https://github.com/plaited/acp-harness/issues"
+    "url": "https://github.com/plaited/agent-eval-harness/issues"
   },
-  "homepage": "https://github.com/plaited/acp-harness/tree/main#readme",
+  "homepage": "https://github.com/plaited/agent-eval-harness/tree/main#readme",
   "bin": {
-    "acp-harness": "./bin/cli.ts"
+    "agent-eval-harness": "./bin/cli.ts"
   },
   "type": "module",
   "exports": {
-    ".": "./src/acp.ts",
+    ".": "./src/harness.ts",
     "./schemas": "./src/schemas.ts",
-    "./harness": "./src/harness.ts"
+    "./headless": "./src/headless.ts",
+    "./pipeline": "./src/pipeline.ts"
   },
   "files": [
     "./src/**",
@@ -56,14 +57,9 @@
     "zod": "^4.3.5",
     "@plaited/development-skills": "0.6.3"
   },
-  "peerDependencies": {
-    "typescript-language-server": "^5.1.3",
-    "@agentclientprotocol/sdk": "^0.13.0"
-  },
   "devDependencies": {
     "@biomejs/biome": "2.3.11",
     "@types/bun": "1.3.6",
-    "@zed-industries/claude-code-acp": "0.13.1",
     "format-package": "7.0.0",
     "lint-staged": "16.2.7",
     "typescript": "5.9.3"
diff --git a/src/acp-client.ts b/src/acp-client.ts
deleted file mode 100644
index d4fca51..0000000
--- a/src/acp-client.ts
+++ /dev/null
@@ -1,507 +0,0 @@
-/**
- * Headless ACP client for programmatic agent interaction.
- *
- * @remarks
- * This client enables automated evaluation of ACP-compatible agents like
- * Claude Code, Droid, Gemini CLI, and others. It provides:
- *
- * - **Subprocess management**: Spawn and control agent processes
- * - **Session handling**: Create and manage conversation sessions
- * - **Streaming prompts**: AsyncGenerator for real-time updates
- * - **Sync prompts**: Simple request/response for basic evals
- * - **Auto-permissions**: Automatically approves all permissions for headless use
- *
- * Designed for testing and evaluation, not for user-facing applications.
- */
-
-import type {
-  AgentCapabilities,
-  CancelNotification,
-  ClientCapabilities,
-  ContentBlock,
-  Implementation,
-  InitializeRequest,
-  InitializeResponse,
-  PromptRequest,
-  PromptResponse,
-  RequestPermissionRequest,
-  RequestPermissionResponse,
-  SessionNotification,
-} from '@agentclientprotocol/sdk'
-import { version } from '../package.json' with { type: 'json' }
-import { createACPTransport } from './acp-transport.ts'
-import { ACP_METHODS, ACP_PROTOCOL_VERSION, DEFAULT_ACP_CLIENT_NAME, DEFAULT_POLLING_INTERVAL } from './constants.ts'
-import type { Session } from './schemas.ts'
-import { RequestPermissionRequestSchema, SessionNotificationSchema } from './schemas.ts'
-
-// ============================================================================
-// Types
-// ============================================================================
-
-/** Configuration for the ACP client */
-export type ACPClientConfig = {
-  /** Command to spawn agent (e.g., ['claude', 'code'] or ['droid']) */
-  command: string[]
-  /** Working directory for agent process */
-  cwd?: string
-  /** Environment variables for agent process */
-  env?: Record<string, string>
-  /** Client info for initialization */
-  clientInfo?: Implementation
-  /** Client capabilities to advertise */
-  capabilities?: ClientCapabilities
-  /** Timeout for operations in milliseconds (default: 30000) */
-  timeout?: number
-  /**
-   * Polling interval for streaming updates in milliseconds (default: 50).
-   * Lower values provide more responsive updates but increase CPU usage.
-   * Consider increasing for testing to reduce timing-related flakiness.
-   */
-  pollingInterval?: number
-  /**
-   * Permission handler for agent requests.
-   * Default: auto-approve all permissions (headless mode)
-   */
-  onPermissionRequest?: (params: RequestPermissionRequest) => Promise<RequestPermissionResponse>
-}
-
-/** Session update emitted during prompt streaming */
-export type SessionUpdate = {
-  type: 'update'
-  params: SessionNotification
-}
-
-/** Prompt completion emitted when prompt finishes */
-export type PromptComplete = {
-  type: 'complete'
-  result: PromptResponse
-}
-
-/** Events emitted during prompt streaming */
-export type PromptEvent = SessionUpdate | PromptComplete
-
-/** Error thrown by ACP client operations */
-export class ACPClientError extends Error {
-  constructor(
-    message: string,
-    public readonly code?: string,
-  ) {
-    super(message)
-    this.name = 'ACPClientError'
-  }
-}
-
-// ============================================================================
-// Client Implementation
-// ============================================================================
-
-/**
- * Creates a headless ACP client for agent evaluation.
- *
- * @param config - Client configuration including command, cwd, and permission handling
- * @returns Client object with lifecycle, session, and prompt methods
- *
- * @remarks
- * The client manages:
- * - Agent subprocess lifecycle (connect/disconnect)
- * - Protocol initialization and capability negotiation
- * - Session creation and management
- * - Prompt streaming with real-time updates
- * - Automatic permission approval for headless evaluation
- *
- * See module-level documentation in `src/acp.ts` for usage guidance.
- * See client tests for usage patterns.
- */
-export const createACPClient = (config: ACPClientConfig) => {
-  const {
-    command,
-    cwd,
-    env,
-    clientInfo = { name: DEFAULT_ACP_CLIENT_NAME, version },
-    capabilities = {},
-    timeout = 30000,
-    pollingInterval = DEFAULT_POLLING_INTERVAL,
-    onPermissionRequest,
-  } = config
-
-  let transport: ReturnType<typeof createACPTransport> | undefined
-  let agentCapabilities: AgentCapabilities | undefined
-  let initializeResult: InitializeResponse | undefined
-
-  // Track active prompt sessions for update routing
-  const activePrompts = new Map<
-    string,
-    {
-      updates: SessionNotification[]
-      resolve: (result: PromptResponse) => void
-      reject: (error: Error) => void
-    }
-  >()
-
-  // --------------------------------------------------------------------------
-  // Permission Handling
-  // --------------------------------------------------------------------------
-
-  /**
-   * Default permission handler: auto-approve all requests.
-   * For headless evaluation in trusted environments.
-   *
-   * @remarks
-   * Validates params with Zod before processing.
-   * Prioritizes `allow_always` for faster headless evaluation with fewer
-   * permission round-trips. Cancels if validation fails or no allow option
-   * is available.
-   */
-  const autoApprovePermission = async (params: RequestPermissionRequest): Promise<RequestPermissionResponse> => {
-    const result = RequestPermissionRequestSchema.safeParse(params)
-    if (!result.success) {
-      return { outcome: { outcome: 'cancelled' } }
-    }
-
-    const { options } = result.data
-
-    // Priority: allow_always (fewer round-trips) > allow_once
-    const allowAlways = options.find((opt) => opt.kind === 'allow_always')
-    if (allowAlways) {
-      return { outcome: { outcome: 'selected', optionId: allowAlways.optionId } }
-    }
-
-    const allowOnce = options.find((opt) => opt.kind === 'allow_once')
-    if (allowOnce) {
-      return { outcome: { outcome: 'selected', optionId: allowOnce.optionId } }
-    }
-
-    // No allow option available - cancel
-    return { outcome: { outcome: 'cancelled' } }
-  }
-
-  const handlePermissionRequest = onPermissionRequest ?? autoApprovePermission
-
-  // --------------------------------------------------------------------------
-  // Transport Callbacks
-  // --------------------------------------------------------------------------
-
-  const onNotification = (method: string, params: unknown) => {
-    if (method === ACP_METHODS.UPDATE) {
-      const updateParams = SessionNotificationSchema.parse(params)
-      const activePrompt = activePrompts.get(updateParams.sessionId)
-      if (activePrompt) {
-        activePrompt.updates.push(updateParams)
-      }
-    }
-  }
-
-  const onRequest = async (method: string, params: unknown): Promise<unknown> => {
-    if (method === ACP_METHODS.REQUEST_PERMISSION) {
-      return handlePermissionRequest(RequestPermissionRequestSchema.parse(params))
-    }
-
-    throw new ACPClientError(`Unknown request method: ${method}`)
-  }
-
-  // --------------------------------------------------------------------------
-  // Lifecycle Methods
-  // --------------------------------------------------------------------------
-
-  /**
-   * Connects to the agent by spawning the subprocess and initializing the protocol.
-   *
-   * @returns Initialize result with agent capabilities
-   * @throws {ACPClientError} If already connected or connection fails
-   */
-  const connect = async (): Promise<InitializeResponse> => {
-    if (transport?.isConnected()) {
-      throw new ACPClientError('Already connected')
-    }
-
-    transport = createACPTransport({
-      command,
-      cwd,
-      env,
-      timeout,
-      onNotification,
-      onRequest,
-      onError: (error) => {
-        console.error('[ACP Client Error]:', error.message)
-      },
-      onClose: (code) => {
-        // Reject all active prompts on unexpected close
-        for (const [sessionId, prompt] of activePrompts) {
-          prompt.reject(new ACPClientError(`Agent process exited with code ${code}`))
-          activePrompts.delete(sessionId)
-        }
-      },
-    })
-
-    await transport.start()
-
-    // Initialize protocol
-    const initParams: InitializeRequest = {
-      protocolVersion: ACP_PROTOCOL_VERSION,
-      clientInfo,
-      clientCapabilities: capabilities,
-    }
-
-    initializeResult = await transport.request<InitializeResponse>(ACP_METHODS.INITIALIZE, initParams)
-
-    agentCapabilities = initializeResult?.agentCapabilities
-
-    return initializeResult
-  }
-
-  /**
-   * Disconnects from the agent, closing the subprocess.
-   *
-   * @param graceful - If true, sends shutdown request first (default: true)
-   */
-  const disconnect = async (graceful = true): Promise<void> => {
-    if (!transport) return
-
-    // Cancel all active prompts
-    for (const [sessionId, prompt] of activePrompts) {
-      prompt.reject(new ACPClientError('Client disconnected'))
-      activePrompts.delete(sessionId)
-    }
-
-    await transport.close(graceful)
-    transport = undefined
-    agentCapabilities = undefined
-    initializeResult = undefined
-  }
-
-  // --------------------------------------------------------------------------
-  // Session Methods
-  // --------------------------------------------------------------------------
-
-  /**
-   * Creates a new conversation session.
-   *
-   * @remarks
-   * MCP servers are auto-discovered by the agent from configuration files
-   * in the working directory (e.g., `.mcp.json`, `.gemini/settings.json`).
-   *
-   * @param params - Session parameters with working directory
-   * @returns The created session
-   * @throws {ACPClientError} If not connected
-   */
-  const createSession = async (params: { cwd: string }): Promise<Session> => {
-    if (!transport?.isConnected()) {
-      throw new ACPClientError('Not connected')
-    }
-
-    const response = await transport.request<{ sessionId: string }>(ACP_METHODS.CREATE_SESSION, {
-      cwd: params.cwd,
-      mcpServers: [], // Required field - empty array lets agents auto-discover from cwd
-    })
-    return { id: response.sessionId }
-  }
-
-  /**
-   * Sets the model for a session.
-   *
-   * @experimental This is an unstable ACP feature and may change.
-   * @param sessionId - The session ID to set the model for
-   * @param modelId - The model ID (e.g., 'claude-3-5-haiku-20241022', 'claude-sonnet-4-20250514')
-   * @throws {ACPClientError} If not connected
-   */
-  const setModel = async (sessionId: string, modelId: string): Promise<void> => {
-    if (!transport?.isConnected()) {
-      throw new ACPClientError('Not connected')
-    }
-
-    await transport.request(ACP_METHODS.SET_MODEL, { sessionId, modelId })
-  }
-
-  // --------------------------------------------------------------------------
-  // Prompt Methods
-  // --------------------------------------------------------------------------
-
-  /**
-   * Sends a prompt and streams updates as they arrive.
-   *
-   * @param sessionId - The session ID to send the prompt to
-   * @param content - Content blocks for the prompt
-   * @yields Session updates and final completion
-   * @throws {ACPClientError} If not connected
-   *
-   * @remarks
-   * Use this for evaluation scenarios where you need access to
-   * intermediate updates (tool calls, plan changes, etc).
-   */
-  async function* prompt(sessionId: string, content: ContentBlock[]): AsyncGenerator<PromptEvent> {
-    if (!transport?.isConnected()) {
-      throw new ACPClientError('Not connected')
-    }
-
-    const { promise, resolve, reject } = Promise.withResolvers<PromptResponse>()
-    const updates: SessionNotification[] = []
-    const promptState = {
-      updates,
-      resolve,
-      reject,
-    }
-
-    activePrompts.set(sessionId, promptState)
-
-    // Send prompt request
-    const promptParams: PromptRequest = {
-      sessionId,
-      prompt: content,
-    }
-
-    // Start the prompt request (don't await - we'll poll for updates)
-    const promptPromise = transport
-      .request<PromptResponse>(ACP_METHODS.PROMPT, promptParams)
-      .then(resolve)
-      .catch(reject)
-
-    try {
-      // Poll for updates until prompt completes
-      let lastYieldedIndex = 0
-
-      while (true) {
-        // Yield any new updates
-        while (lastYieldedIndex < promptState.updates.length) {
-          const update = promptState.updates[lastYieldedIndex]
-          if (update) {
-            yield { type: 'update', params: update }
-          }
-          lastYieldedIndex++
-        }
-
-        // Check if prompt completed
-        const raceResult = await Promise.race([
-          promise.then((result) => ({ done: true as const, result })),
-          new Promise<{ done: false }>((res) => setTimeout(() => res({ done: false }), pollingInterval)),
-        ])
-
-        if (raceResult.done) {
-          // Yield any remaining updates
-          while (lastYieldedIndex < promptState.updates.length) {
-            const update = promptState.updates[lastYieldedIndex]
-            if (update) {
-              yield { type: 'update', params: update }
-            }
-            lastYieldedIndex++
-          }
-
-          // Yield completion
-          yield {
-            type: 'complete',
-            result: raceResult.result,
-          }
-          break
-        }
-      }
-
-      await promptPromise
-    } finally {
-      activePrompts.delete(sessionId)
-    }
-  }
-
-  /**
-   * Sends a prompt and waits for the final result.
-   *
-   * @param sessionId - The session ID to send the prompt to
-   * @param content - Content blocks for the prompt
-   * @returns The prompt result with all accumulated updates
-   * @throws {ACPClientError} If not connected
-   *
-   * @remarks
-   * Use this for simple evaluation scenarios where you only need
-   * the final result. All intermediate updates are collected but
-   * returned together at the end.
-   */
-  const promptSync = async (
-    sessionId: string,
-    content: ContentBlock[],
-  ): Promise<{
-    result: PromptResponse
-    updates: SessionNotification[]
-  }> => {
-    const updates: SessionNotification[] = []
-    let result: PromptResponse | undefined
-
-    for await (const event of prompt(sessionId, content)) {
-      if (event.type === 'update') {
-        updates.push(event.params)
-      } else if (event.type === 'complete') {
-        result = event.result
-      }
-    }
-
-    if (!result) {
-      throw new ACPClientError('Prompt completed without result')
-    }
-
-    return { result, updates }
-  }
-
-  /**
-   * Cancels an ongoing prompt.
-   *
-   * @param sessionId - The session ID to cancel
-   * @throws {ACPClientError} If not connected
-   */
-  const cancelPrompt = async (sessionId: string): Promise<void> => {
-    if (!transport?.isConnected()) {
-      throw new ACPClientError('Not connected')
-    }
-
-    const cancelParams: CancelNotification = { sessionId }
-    await transport.notify(ACP_METHODS.CANCEL, cancelParams)
-  }
-
-  // --------------------------------------------------------------------------
-  // State Methods
-  // --------------------------------------------------------------------------
-
-  /**
-   * Gets the agent capabilities negotiated during initialization.
-   *
-   * @returns Agent capabilities or undefined if not connected
-   */
-  const getCapabilities = (): AgentCapabilities | undefined => {
-    return agentCapabilities
-  }
-
-  /**
-   * Gets the full initialization result.
-   *
-   * @returns Initialize result or undefined if not connected
-   */
-  const getInitializeResult = (): InitializeResponse | undefined => {
-    return initializeResult
-  }
-
-  /**
-   * Checks if the client is connected to an agent.
-   */
-  const isConnected = (): boolean => {
-    return transport?.isConnected() ?? false
-  }
-
-  return {
-    // Lifecycle
-    connect,
-    disconnect,
-
-    // Sessions
-    createSession,
-    setModel,
-
-    // Prompts
-    prompt,
-    promptSync,
-    cancelPrompt,
-
-    // State
-    getCapabilities,
-    getInitializeResult,
-    isConnected,
-  }
-}
-
-/** Client instance type */
-export type ACPClient = ReturnType<typeof createACPClient>
diff --git a/src/acp-helpers.ts b/src/acp-helpers.ts
deleted file mode 100644
index a7f72d5..0000000
--- a/src/acp-helpers.ts
+++ /dev/null
@@ -1,121 +0,0 @@
-/**
- * High-level helper utilities for ACP prompt building and response analysis.
- *
- * @remarks
- * Provides convenience functions for common ACP workflows:
- * - Building prompts with text, files, and images
- * - Summarizing agent responses for evaluation
- *
- * For low-level content manipulation, see internal utilities in acp-utils.ts.
- */
-
-import type { ContentBlock, PlanEntry, SessionNotification, ToolCall } from '@agentclientprotocol/sdk'
-import {
-  createImageContent,
-  createTextContent,
-  createTextResource,
-  extractLatestToolCalls,
-  extractPlan,
-  extractTextFromUpdates,
-  filterToolCallsByStatus,
-  getPlanProgress,
-  hasToolCallErrors,
-} from './acp-utils.ts'
-
-// ============================================================================
-// Prompt Building Utilities
-// ============================================================================
-
-/**
- * Creates a simple text prompt.
- *
- * @param text - The prompt text
- * @returns Array with single text content block
- */
-export const createPrompt = (text: string): ContentBlock[] => {
-  return [createTextContent(text)]
-}
-
-/**
- * Creates a prompt with text and file context.
- *
- * @param text - The prompt text
- * @param files - Array of file paths and contents to include
- * @returns Array of content blocks
- */
-export const createPromptWithFiles = (
-  text: string,
-  files: Array<{ path: string; content: string }>,
-): ContentBlock[] => {
-  const blocks: ContentBlock[] = [createTextContent(text)]
-
-  for (const file of files) {
-    blocks.push(createTextResource({ uri: `file://${file.path}`, text: file.content, mimeType: 'text/plain' }))
-  }
-
-  return blocks
-}
-
-/** Parameters for creating a prompt with image */
-export type CreatePromptWithImageParams = {
-  /** The prompt text */
-  text: string
-  /** Base64-encoded image data */
-  imageData: string
-  /** Image MIME type */
-  mimeType: string
-}
-
-/**
- * Creates a prompt with text and image.
- *
- * @param params - Prompt with image parameters
- * @returns Array of content blocks
- */
-export const createPromptWithImage = ({ text, imageData, mimeType }: CreatePromptWithImageParams): ContentBlock[] => {
-  return [createTextContent(text), createImageContent(imageData, mimeType)]
-}
-
-// ============================================================================
-// Response Analysis Utilities
-// ============================================================================
-
-/** Summary of a prompt response for evaluation */
-export type PromptResponseSummary = {
-  /** Concatenated text output */
-  text: string
-  /** Number of tool calls made */
-  toolCallCount: number
-  /** Tool calls that completed */
-  completedToolCalls: ToolCall[]
-  /** Tool calls that failed */
-  failedToolCalls: ToolCall[]
-  /** Final plan state */
-  plan?: PlanEntry[]
-  /** Plan completion percentage */
-  planProgress?: number
-  /** Whether any errors occurred */
-  hasErrors: boolean
-}
-
-/**
- * Creates a summary of a prompt response for evaluation.
- *
- * @param notifications - Session notifications from the prompt
- * @returns Response summary
- */
-export const summarizeResponse = (notifications: SessionNotification[]): PromptResponseSummary => {
-  const text = extractTextFromUpdates(notifications)
-  const toolCalls = [...extractLatestToolCalls(notifications).values()]
-  const plan = extractPlan(notifications)
-
-  return {
-    text,
-    toolCallCount: toolCalls.length,
-    completedToolCalls: filterToolCallsByStatus(toolCalls, 'completed'),
-    failedToolCalls: filterToolCallsByStatus(toolCalls, 'failed'),
-    plan,
-    planProgress: plan ? getPlanProgress(plan) : undefined,
-    hasErrors: hasToolCallErrors(toolCalls),
-  }
-}
diff --git a/src/acp-transport.ts b/src/acp-transport.ts
deleted file mode 100644
index 56f1d32..0000000
--- a/src/acp-transport.ts
+++ /dev/null
@@ -1,462 +0,0 @@
-/**
- * ACP stdio transport for subprocess communication.
- *
- * @remarks
- * Manages bidirectional JSON-RPC 2.0 communication with ACP agents over
- * stdin/stdout. Handles message framing, request/response correlation,
- * and notification streaming.
- *
- * The transport spawns the agent as a subprocess and communicates using
- * newline-delimited JSON messages with Zod runtime validation.
- */
-
-import { JSON_RPC_ERRORS } from './constants.ts'
-import type {
-  JsonRpcError,
-  JsonRpcErrorResponse,
-  JsonRpcMessage,
-  JsonRpcNotification,
-  JsonRpcRequest,
-  JsonRpcResponse,
-  JsonRpcSuccessResponse,
-} from './schemas.ts'
-import { JsonRpcMessageSchema } from './schemas.ts'
-
-// ============================================================================
-// Types
-// ============================================================================
-
-/** Configuration for the ACP transport */
-export type ACPTransportConfig = {
-  /** Command to spawn agent (e.g., ['claude', 'code', '--print-acp-config']) */
-  command: string[]
-  /** Working directory for agent process */
-  cwd?: string
-  /** Environment variables for agent process */
-  env?: Record<string, string>
-  /** Timeout for requests in milliseconds (default: 30000) */
-  timeout?: number
-  /** Callback for incoming notifications */
-  onNotification?: (method: string, params: unknown) => void
-  /** Callback for incoming requests (agent → client) */
-  onRequest?: (method: string, params: unknown) => Promise<unknown>
-  /** Callback for transport errors */
-  onError?: (error: Error) => void
-  /** Callback when transport closes */
-  onClose?: (code: number | null) => void
-}
-
-/** Pending request tracker */
-type PendingRequest = {
-  resolve: (result: unknown) => void
-  reject: (error: Error) => void
-  timer: Timer
-}
-
-/** Bun FileSink for subprocess stdin */
-type FileSink = {
-  write: (data: string | ArrayBufferView | ArrayBuffer) => number
-  flush: () => void
-  end: () => void
-}
-
-/** Subprocess type with piped stdio (Bun.spawn return type) */
-type PipedSubprocess = {
-  stdin: FileSink
-  stdout: ReadableStream<Uint8Array>
-  stderr: ReadableStream<Uint8Array>
-  exited: Promise<number>
-  kill: (signal?: number) => void
-  pid: number
-}
-
-/** Custom error for ACP transport failures */
-export class ACPTransportError extends Error {
-  constructor(
-    message: string,
-    public readonly code?: number,
-    public readonly data?: unknown,
-  ) {
-    super(message)
-    this.name = 'ACPTransportError'
-  }
-
-  /** Create from JSON-RPC error */
-  static fromJsonRpcError(error: JsonRpcError): ACPTransportError {
-    return new ACPTransportError(error.message, error.code, error.data)
-  }
-}
-
-// ============================================================================
-// Transport Implementation
-// ============================================================================
-
-/**
- * Creates an ACP transport for subprocess communication.
- *
- * @param config - Transport configuration
- * @returns Transport object with send/close methods
- *
- * @remarks
- * The transport handles:
- * - Spawning the agent subprocess
- * - JSON-RPC message framing over stdio
- * - Request/response correlation with timeouts
- * - Notification and request routing
- * - Graceful shutdown
- * - Runtime validation of incoming messages via Zod
- */
-export const createACPTransport = (config: ACPTransportConfig) => {
-  const { command, cwd, env, timeout = 30000, onNotification, onRequest, onError, onClose } = config
-
-  let subprocess: PipedSubprocess | undefined
-  let nextId = 1
-  const pendingRequests = new Map<string | number, PendingRequest>()
-  let buffer = ''
-  let isClosing = false
-
-  // Stream readers for explicit cleanup
-  // Use global ReadableStreamDefaultReader type (Bun's type includes readMany)
-  let stdoutReader: globalThis.ReadableStreamDefaultReader<Uint8Array> | undefined
-  let stderrReader: globalThis.ReadableStreamDefaultReader<Uint8Array> | undefined
-
-  // --------------------------------------------------------------------------
-  // Message Parsing (with Zod validation)
-  // --------------------------------------------------------------------------
-
-  const parseMessages = (data: string): JsonRpcMessage[] => {
-    buffer += data
-    const messages: JsonRpcMessage[] = []
-    const lines = buffer.split('\n')
-
-    // Keep incomplete last line in buffer
-    buffer = lines.pop() ?? ''
-
-    for (const line of lines) {
-      const trimmed = line.trim()
-      if (!trimmed) continue
-
-      // Skip lines that don't look like JSON objects (debug output from adapters)
-      if (!trimmed.startsWith('{')) continue
-
-      try {
-        const json = JSON.parse(trimmed)
-        const result = JsonRpcMessageSchema.safeParse(json)
-
-        if (!result.success) {
-          // Only log if it looked like valid JSON but failed schema validation
-          onError?.(new Error(`Invalid JSON-RPC message: ${result.error.message}`))
-          continue
-        }
-
-        messages.push(result.data as JsonRpcMessage)
-      } catch {
-        // Silently skip non-JSON lines (common with debug output)
-      }
-    }
-
-    return messages
-  }
-
-  // --------------------------------------------------------------------------
-  // Message Handling
-  // --------------------------------------------------------------------------
-
-  const handleMessage = async (message: JsonRpcMessage) => {
-    // Response to our request
-    if (
-      'id' in message &&
-      message.id !== undefined &&
-      message.id !== null &&
-      ('result' in message || 'error' in message)
-    ) {
-      const response = message as JsonRpcResponse
-      const id = response.id as string | number
-      const pending = pendingRequests.get(id)
-      if (pending) {
-        pendingRequests.delete(id)
-        clearTimeout(pending.timer)
-
-        if ('error' in response) {
-          pending.reject(ACPTransportError.fromJsonRpcError(response.error))
-        } else {
-          pending.resolve(response.result)
-        }
-      }
-      return
-    }
-
-    // Request from agent (e.g., permission request, file read)
-    if ('id' in message && message.id !== undefined && message.id !== null && 'method' in message) {
-      const request = message as JsonRpcRequest
-      const id = request.id as string | number
-      if (onRequest) {
-        try {
-          const result = await onRequest(request.method, request.params)
-          await sendResponse(id, result)
-        } catch (err) {
-          const error = err instanceof Error ? err : new Error(String(err))
-          await sendErrorResponse(id, JSON_RPC_ERRORS.INTERNAL_ERROR, error.message)
-        }
-      } else {
-        // No handler, respond with method not found
-        await sendErrorResponse(id, JSON_RPC_ERRORS.METHOD_NOT_FOUND, `No handler for ${request.method}`)
-      }
-      return
-    }
-
-    // Notification from agent
-    if ('method' in message && !('id' in message)) {
-      const notification = message as JsonRpcNotification
-      onNotification?.(notification.method, notification.params)
-    }
-  }
-
-  // --------------------------------------------------------------------------
-  // Sending Messages
-  // --------------------------------------------------------------------------
-
-  const sendRaw = (message: JsonRpcMessage): void => {
-    if (!subprocess || isClosing) {
-      throw new ACPTransportError('Transport is not connected')
-    }
-
-    const json = `${JSON.stringify(message)}\n`
-    subprocess.stdin.write(json)
-    subprocess.stdin.flush()
-  }
-
-  const sendResponse = async (id: string | number, result: unknown): Promise<void> => {
-    const response: JsonRpcSuccessResponse = {
-      jsonrpc: '2.0',
-      id,
-      result,
-    }
-    sendRaw(response)
-  }
-
-  const sendErrorResponse = async (id: string | number, code: number, message: string): Promise<void> => {
-    const response: JsonRpcErrorResponse = {
-      jsonrpc: '2.0',
-      id,
-      error: { code, message },
-    }
-    sendRaw(response)
-  }
-
-  // --------------------------------------------------------------------------
-  // Public API
-  // --------------------------------------------------------------------------
-
-  /**
-   * Starts the transport by spawning the agent subprocess.
-   *
-   * @throws {ACPTransportError} If the subprocess fails to start
-   */
-  const start = async (): Promise<void> => {
-    if (subprocess) {
-      throw new ACPTransportError('Transport already started')
-    }
-
-    if (command.length === 0) {
-      throw new ACPTransportError('Command array is empty')
-    }
-
-    const proc = Bun.spawn(command, {
-      cwd,
-      env: { ...Bun.env, ...env },
-      stdin: 'pipe',
-      stdout: 'pipe',
-      stderr: 'pipe',
-    })
-
-    // Cast to our expected type - Bun.spawn with 'pipe' options returns streams
-    subprocess = proc as unknown as PipedSubprocess
-
-    // Read stdout for JSON-RPC messages
-    const readStdout = async () => {
-      if (!subprocess) {
-        throw new ACPTransportError('Subprocess not started')
-      }
-      // Type assertion needed: Bun's ReadableStreamDefaultReader includes readMany
-      // but node:stream/web reader returned by getReader() doesn't have it
-      const reader = subprocess.stdout.getReader() as globalThis.ReadableStreamDefaultReader<Uint8Array>
-      stdoutReader = reader
-      const decoder = new TextDecoder()
-
-      try {
-        while (true) {
-          const { done, value } = await reader.read()
-          if (done) break
-
-          const text = decoder.decode(value, { stream: true })
-          const messages = parseMessages(text)
-          for (const message of messages) {
-            await handleMessage(message)
-          }
-        }
-      } catch (err) {
-        if (!isClosing) {
-          onError?.(err instanceof Error ? err : new Error(String(err)))
-        }
-      } finally {
-        stdoutReader = undefined
-      }
-    }
-
-    // Read stderr for debugging
-    const readStderr = async () => {
-      if (!subprocess) {
-        throw new ACPTransportError('Subprocess not started')
-      }
-      // Type assertion needed: Bun's ReadableStreamDefaultReader includes readMany
-      // but node:stream/web reader returned by getReader() doesn't have it
-      const reader = subprocess.stderr.getReader() as globalThis.ReadableStreamDefaultReader<Uint8Array>
-      stderrReader = reader
-      const decoder = new TextDecoder()
-
-      try {
-        while (true) {
-          const { done, value } = await reader.read()
-          if (done) break
-          // Log stderr for debugging but don't treat as error
-          const text = decoder.decode(value, { stream: true })
-          if (text.trim()) {
-            console.error('[ACP Agent stderr]:', text.trim())
-          }
-        }
-      } catch {
-        // Ignore stderr read errors
-      } finally {
-        stderrReader = undefined
-      }
-    }
-
-    // Start reading streams (fire-and-forget pattern)
-    // These run concurrently and clean up via optional chaining in close()
-    readStdout()
-    readStderr()
-
-    // Monitor process exit
-    subprocess.exited.then((code) => {
-      if (!isClosing) {
-        // Reject all pending requests
-        for (const [id, pending] of pendingRequests) {
-          clearTimeout(pending.timer)
-          pending.reject(new ACPTransportError(`Process exited with code ${code}`))
-          pendingRequests.delete(id)
-        }
-        onClose?.(code)
-      }
-    })
-  }
-
-  /**
-   * Sends a JSON-RPC request and waits for response.
-   *
-   * @param method - The RPC method name
-   * @param params - Optional parameters
-   * @returns The result from the response
-   * @throws {ACPTransportError} On timeout, transport error, or RPC error
-   */
-  const request = async <T>(method: string, params?: unknown): Promise<T> => {
-    const id = nextId++
-
-    const rpcRequest: JsonRpcRequest = {
-      jsonrpc: '2.0',
-      id,
-      method,
-      ...(params !== undefined && { params }),
-    }
-
-    const { promise, resolve, reject } = Promise.withResolvers<unknown>()
-
-    const timer = setTimeout(() => {
-      pendingRequests.delete(id)
-      reject(new ACPTransportError(`Request timed out after ${timeout}ms`, JSON_RPC_ERRORS.INTERNAL_ERROR))
-    }, timeout)
-
-    pendingRequests.set(id, { resolve, reject, timer })
-
-    try {
-      sendRaw(rpcRequest)
-    } catch (err) {
-      pendingRequests.delete(id)
-      clearTimeout(timer)
-      throw err
-    }
-
-    return promise as Promise<T>
-  }
-
-  /**
-   * Sends a JSON-RPC notification (no response expected).
-   *
-   * @param method - The notification method name
-   * @param params - Optional parameters
-   */
-  const notify = async (method: string, params?: unknown): Promise<void> => {
-    const notification: JsonRpcNotification = {
-      jsonrpc: '2.0',
-      method,
-      ...(params !== undefined && { params }),
-    }
-    sendRaw(notification)
-  }
-
-  /**
-   * Cancels a pending request using the ACP cancel notification.
-   *
-   * @param requestId - The ID of the request to cancel
-   */
-  const cancelRequest = async (requestId: string | number): Promise<void> => {
-    // Use SDK's CancelRequestNotification format
-    await notify('$/cancel_request', { requestId })
-  }
-
-  /**
-   * Closes the transport and terminates the subprocess.
-   *
-   * @param graceful - If true, sends shutdown request first (default: true)
-   */
-  const close = async (graceful = true): Promise<void> => {
-    if (!subprocess || isClosing) return
-    isClosing = true
-
-    // Cancel all pending requests
-    for (const [id, pending] of pendingRequests) {
-      clearTimeout(pending.timer)
-      pending.reject(new ACPTransportError('Transport closed'))
-      pendingRequests.delete(id)
-    }
-
-    try {
-      if (graceful) {
-        // Try graceful shutdown - not in SDK, use string literal
-        await request('shutdown').catch(() => {})
-      }
-    } finally {
-      // Release stream readers to allow clean subprocess termination
-      await Promise.all([stdoutReader?.cancel().catch(() => {}), stderrReader?.cancel().catch(() => {})])
-
-      subprocess.kill()
-      subprocess = undefined
-    }
-  }
-
-  /**
-   * Checks if the transport is connected.
-   */
-  const isConnected = (): boolean => {
-    return subprocess !== undefined && !isClosing
-  }
-
-  return {
-    start,
-    request,
-    notify,
-    cancelRequest,
-    close,
-    isConnected,
-  }
-}
diff --git a/src/acp-utils.ts b/src/acp-utils.ts
deleted file mode 100644
index 1f529e6..0000000
--- a/src/acp-utils.ts
+++ /dev/null
@@ -1,341 +0,0 @@
-/**
- * Internal utilities for ACP content manipulation.
- *
- * @remarks
- * Low-level functions for building content blocks and extracting data
- * from session responses. These are used internally by the higher-level
- * helpers in acp-helpers.ts.
- *
- * @internal
- */
-
-import type {
-  BlobResourceContents,
-  ContentBlock,
-  PlanEntry,
-  SessionNotification,
-  SessionUpdate,
-  TextContent,
-  TextResourceContents,
-  ToolCall,
-  ToolCallContent,
-} from '@agentclientprotocol/sdk'
-
-// ============================================================================
-// Content Block Builders
-// ============================================================================
-
-/**
- * Creates a text content block.
- *
- * @param text - The text content
- * @returns Text content block
- */
-export const createTextContent = (text: string): ContentBlock => ({
-  type: 'text',
-  text,
-})
-
-/**
- * Creates an image content block from base64 data.
- *
- * @param data - Base64-encoded image data
- * @param mimeType - MIME type (e.g., 'image/png', 'image/jpeg')
- * @returns Image content block
- */
-export const createImageContent = (data: string, mimeType: string): ContentBlock => ({
-  type: 'image',
-  data,
-  mimeType,
-})
-
-/**
- * Creates an audio content block from base64 data.
- *
- * @param data - Base64-encoded audio data
- * @param mimeType - MIME type (e.g., 'audio/wav', 'audio/mp3')
- * @returns Audio content block
- */
-export const createAudioContent = (data: string, mimeType: string): ContentBlock => ({
-  type: 'audio',
-  data,
-  mimeType,
-})
-
-/** Parameters for creating a resource link */
-export type CreateResourceLinkParams = {
-  /** URI to the resource */
-  uri: string
-  /** Resource name (required by SDK) */
-  name: string
-  /** Optional MIME type */
-  mimeType?: string
-}
-
-/**
- * Creates a resource link content block.
- *
- * @param params - Resource link parameters
- * @returns Resource link content block
- */
-export const createResourceLink = ({ uri, name, mimeType }: CreateResourceLinkParams): ContentBlock => ({
-  type: 'resource_link',
-  uri,
-  name,
-  ...(mimeType && { mimeType }),
-})
-
-/** Parameters for creating an embedded text resource */
-export type CreateTextResourceParams = {
-  /** URI identifying the resource */
-  uri: string
-  /** Text content of the resource */
-  text: string
-  /** Optional MIME type */
-  mimeType?: string
-}
-
-/**
- * Creates an embedded text resource content block.
- *
- * @param params - Text resource parameters
- * @returns Resource content block
- */
-export const createTextResource = ({ uri, text, mimeType }: CreateTextResourceParams): ContentBlock => ({
-  type: 'resource',
-  resource: {
-    uri,
-    text,
-    ...(mimeType && { mimeType }),
-  } as TextResourceContents,
-})
-
-/** Parameters for creating an embedded blob resource */
-export type CreateBlobResourceParams = {
-  /** URI identifying the resource */
-  uri: string
-  /** Base64-encoded binary data */
-  blob: string
-  /** Optional MIME type */
-  mimeType?: string
-}
-
-/**
- * Creates an embedded blob resource content block.
- *
- * @param params - Blob resource parameters
- * @returns Resource content block
- */
-export const createBlobResource = ({ uri, blob, mimeType }: CreateBlobResourceParams): ContentBlock => ({
-  type: 'resource',
-  resource: {
-    uri,
-    blob,
-    ...(mimeType && { mimeType }),
-  } as BlobResourceContents,
-})
-
-// ============================================================================
-// Content Extraction
-// ============================================================================
-
-/**
- * Extracts all text from content blocks.
- *
- * @param content - Array of content blocks
- * @returns Concatenated text content
- */
-export const extractText = (content: ContentBlock[]): string => {
-  return content
-    .filter((block): block is TextContent & { type: 'text' } => block.type === 'text')
-    .map((block) => block.text)
-    .join('\n')
-}
-
-/**
- * Helper to extract content from SessionUpdate (discriminated union)
- */
-const getUpdateContent = (update: SessionUpdate): ContentBlock | undefined => {
-  if (
-    update.sessionUpdate === 'user_message_chunk' ||
-    update.sessionUpdate === 'agent_message_chunk' ||
-    update.sessionUpdate === 'agent_thought_chunk'
-  ) {
-    return update.content
-  }
-  return undefined
-}
-
-/**
- * Helper to extract tool call from SessionUpdate
- */
-const getUpdateToolCall = (update: SessionUpdate): ToolCall | undefined => {
-  if (update.sessionUpdate === 'tool_call') {
-    return update
-  }
-  return undefined
-}
-
-/**
- * Helper to extract plan from SessionUpdate
- */
-const getUpdatePlan = (update: SessionUpdate): PlanEntry[] | undefined => {
-  if (update.sessionUpdate === 'plan') {
-    return update.entries
-  }
-  return undefined
-}
-
-/**
- * Extracts text from session notifications.
- *
- * @remarks
- * Streaming produces partial tokens that should be concatenated directly.
- * Uses empty string join to preserve the original text structure.
- *
- * @param notifications - Array of session notifications
- * @returns Concatenated text from all updates
- */
-export const extractTextFromUpdates = (notifications: SessionNotification[]): string => {
-  const texts: string[] = []
-  for (const notification of notifications) {
-    const content = getUpdateContent(notification.update)
-    if (content && content.type === 'text') {
-      texts.push(content.text)
-    }
-  }
-  // Join without separator - streaming chunks should be concatenated directly
-  return texts.join('')
-}
-
-/**
- * Extracts all tool calls from session notifications.
- *
- * @param notifications - Array of session notifications
- * @returns Array of all tool calls
- */
-export const extractToolCalls = (notifications: SessionNotification[]): ToolCall[] => {
-  const calls: ToolCall[] = []
-  for (const notification of notifications) {
-    const toolCall = getUpdateToolCall(notification.update)
-    if (toolCall) {
-      calls.push(toolCall)
-    }
-  }
-  return calls
-}
-
-/**
- * Extracts the latest state of each tool call (deduplicated by toolCallId).
- *
- * @param notifications - Array of session notifications
- * @returns Map of tool call ID to latest tool call state
- */
-export const extractLatestToolCalls = (notifications: SessionNotification[]): Map<string, ToolCall> => {
-  const latest = new Map<string, ToolCall>()
-  for (const notification of notifications) {
-    const toolCall = getUpdateToolCall(notification.update)
-    if (toolCall) {
-      latest.set(toolCall.toolCallId, toolCall)
-    }
-  }
-  return latest
-}
-
-/**
- * Extracts the latest plan from session notifications.
- *
- * @param notifications - Array of session notifications
- * @returns Latest plan entries or undefined if no plan
- */
-export const extractPlan = (notifications: SessionNotification[]): PlanEntry[] | undefined => {
-  // Plans are replaced entirely, so find the last one
-  for (let i = notifications.length - 1; i >= 0; i--) {
-    const notification = notifications[i]
-    if (notification) {
-      const plan = getUpdatePlan(notification.update)
-      if (plan) {
-        return plan
-      }
-    }
-  }
-  return undefined
-}
-
-// ============================================================================
-// Tool Call Utilities
-// ============================================================================
-
-/**
- * Filters tool calls by status.
- *
- * @param toolCalls - Array of tool calls
- * @param status - Status to filter by
- * @returns Filtered tool calls
- */
-export const filterToolCallsByStatus = (toolCalls: ToolCall[], status: ToolCall['status']): ToolCall[] => {
-  return toolCalls.filter((call) => call.status === status)
-}
-
-/**
- * Filters tool calls by title.
- *
- * @param toolCalls - Array of tool calls
- * @param title - Tool title to filter by
- * @returns Filtered tool calls
- */
-export const filterToolCallsByTitle = (toolCalls: ToolCall[], title: string): ToolCall[] => {
-  return toolCalls.filter((call) => call.title === title)
-}
-
-/**
- * Checks if any tool calls have failed.
- *
- * @param toolCalls - Array of tool calls
- * @returns True if any tool call has 'failed' status
- */
-export const hasToolCallErrors = (toolCalls: ToolCall[]): boolean => {
-  return toolCalls.some((call) => call.status === 'failed')
-}
-
-/**
- * Gets completed tool calls with their output content.
- *
- * @param toolCalls - Array of tool calls
- * @returns Tool calls that completed with content
- */
-export const getCompletedToolCallsWithContent = (
-  toolCalls: ToolCall[],
-): Array<ToolCall & { content: ToolCallContent[] }> => {
-  return toolCalls.filter(
-    (call): call is ToolCall & { content: ToolCallContent[] } =>
-      call.status === 'completed' && call.content !== undefined && call.content.length > 0,
-  )
-}
-
-// ============================================================================
-// Plan Utilities
-// ============================================================================
-
-/**
- * Gets plan entries by status.
- *
- * @param plan - Array of plan entries
- * @param status - Status to filter by
- * @returns Filtered plan entries
- */
-export const filterPlanByStatus = (plan: PlanEntry[], status: PlanEntry['status']): PlanEntry[] => {
-  return plan.filter((entry) => entry.status === status)
-}
-
-/**
- * Calculates plan completion percentage.
- *
- * @param plan - Array of plan entries
- * @returns Percentage of completed entries (0-100)
- */
-export const getPlanProgress = (plan: PlanEntry[]): number => {
-  if (plan.length === 0) return 100
-  const completed = plan.filter((entry) => entry.status === 'completed').length
-  return Math.round((completed / plan.length) * 100)
-}
diff --git a/src/acp.ts b/src/acp.ts
deleted file mode 100644
index a0541ee..0000000
--- a/src/acp.ts
+++ /dev/null
@@ -1,27 +0,0 @@
-/**
- * @plaited/acp-harness - ACP client and evaluation harness for TypeScript/Bun projects.
- *
- * @remarks
- * This module provides a headless ACP client for programmatic agent interaction,
- * optimized for testing, evaluation, and training data generation.
- *
- * **Primary exports:**
- * - `createACPClient` - Factory for headless ACP client instances
- * - `createPrompt`, `createPromptWithFiles`, `createPromptWithImage` - Prompt builders
- * - `summarizeResponse` - Response analysis utility
- *
- * **Re-exports from acp-utils (for advanced usage):**
- * - Content builders: `createTextContent`, `createImageContent`, `createAudioContent`,
- *   `createResourceLink`, `createTextResource`, `createBlobResource`
- * - Content extractors: `extractText`, `extractTextFromUpdates`, `extractToolCalls`,
- *   `extractLatestToolCalls`, `extractPlan`
- * - Tool call utilities: `filterToolCallsByStatus`, `filterToolCallsByTitle`,
- *   `hasToolCallErrors`, `getCompletedToolCallsWithContent`
- * - Plan utilities: `filterPlanByStatus`, `getPlanProgress`
- *
- * @packageDocumentation
- */
-
-export * from './acp-client.ts'
-export * from './acp-helpers.ts'
-export * from './acp-utils.ts'
diff --git a/src/adapter-check.ts b/src/adapter-check.ts
deleted file mode 100644
index 17ffe0d..0000000
--- a/src/adapter-check.ts
+++ /dev/null
@@ -1,541 +0,0 @@
-/**
- * ACP adapter compliance checker.
- *
- * @remarks
- * Validates that an adapter correctly implements the Agent Client Protocol
- * by running a series of checks:
- *
- * 1. spawn - Adapter can be launched as subprocess
- * 2. initialize - Responds with valid agentCapabilities
- * 3. session/new - Creates session and returns sessionId
- * 4. session/prompt - Accepts prompt and emits session/update notifications
- * 5. session/cancel - Accepts cancel notification gracefully
- * 6. framing - All messages are newline-delimited JSON-RPC 2.0
- *
- * @packageDocumentation
- */
-
-import { parseArgs } from 'node:util'
-import { createACPTransport } from './acp-transport.ts'
-import { ACP_METHODS, ACP_PROTOCOL_VERSION, DEFAULT_ACP_CLIENT_NAME } from './constants.ts'
-
-// ============================================================================
-// Types
-// ============================================================================
-
-/** Configuration for compliance check */
-export type CheckConfig = {
-  /** Command to spawn adapter (e.g., ['bun', './src/main.ts']) */
-  command: string[]
-  /** Timeout for each check in milliseconds */
-  timeout: number
-  /** Show detailed protocol messages */
-  verbose: boolean
-}
-
-/** Result of a single check */
-export type CheckResult = {
-  /** Check name */
-  name: string
-  /** Whether the check passed */
-  passed: boolean
-  /** Human-readable message */
-  message: string
-  /** Additional details (for verbose output) */
-  details?: string
-}
-
-/** Result of full compliance check */
-export type ComplianceResult = {
-  /** Whether all checks passed */
-  passed: boolean
-  /** Individual check results */
-  checks: CheckResult[]
-  /** Summary statistics */
-  summary: {
-    total: number
-    passed: number
-    failed: number
-  }
-}
-
-// ============================================================================
-// Check Implementations
-// ============================================================================
-
-/**
- * Check: spawn
- * Verify adapter can be launched as a subprocess.
- */
-const checkSpawn = async (config: CheckConfig): Promise<CheckResult> => {
-  const { command, timeout, verbose } = config
-
-  try {
-    const transport = createACPTransport({
-      command,
-      timeout,
-      onNotification: () => {},
-      onRequest: async () => ({}),
-      onError: () => {},
-      onClose: () => {},
-    })
-
-    await transport.start()
-    await transport.close(false) // Don't send shutdown, just close
-
-    return {
-      name: 'spawn',
-      passed: true,
-      message: 'Adapter launched successfully',
-      details: verbose ? `Command: ${command.join(' ')}` : undefined,
-    }
-  } catch (error) {
-    return {
-      name: 'spawn',
-      passed: false,
-      message: `Failed to spawn adapter: ${error instanceof Error ? error.message : String(error)}`,
-    }
-  }
-}
-
-/**
- * Check: initialize
- * Verify adapter responds to initialize with valid agentCapabilities.
- */
-const checkInitialize = async (
-  config: CheckConfig,
-): Promise<{ result: CheckResult; transport?: ReturnType<typeof createACPTransport>; capabilities?: unknown }> => {
-  const { command, timeout, verbose } = config
-
-  try {
-    const transport = createACPTransport({
-      command,
-      timeout,
-      onNotification: () => {},
-      onRequest: async () => ({}),
-      onError: () => {},
-      onClose: () => {},
-    })
-
-    await transport.start()
-
-    const initResponse = await transport.request<{
-      protocolVersion: number
-      agentInfo?: { name: string; version: string }
-      agentCapabilities?: Record<string, unknown>
-    }>(ACP_METHODS.INITIALIZE, {
-      protocolVersion: ACP_PROTOCOL_VERSION,
-      clientInfo: { name: DEFAULT_ACP_CLIENT_NAME, version: '1.0.0' },
-      clientCapabilities: {},
-    })
-
-    if (!initResponse || initResponse.protocolVersion !== ACP_PROTOCOL_VERSION) {
-      await transport.close(false)
-      return {
-        result: {
-          name: 'initialize',
-          passed: false,
-          message: `Invalid protocol version: expected ${ACP_PROTOCOL_VERSION}, got ${initResponse?.protocolVersion}`,
-        },
-      }
-    }
-
-    const capabilities = initResponse.agentCapabilities ?? {}
-    const capList = Object.entries(capabilities)
-      .filter(([, v]) => v)
-      .map(([k, v]) => {
-        if (typeof v === 'object' && v !== null) {
-          const nested = Object.entries(v as Record<string, unknown>)
-            .filter(([, nv]) => nv)
-            .map(([nk]) => nk)
-          return nested.length > 0 ? `${k}.${nested.join(', ')}` : k
-        }
-        return k
-      })
-
-    return {
-      result: {
-        name: 'initialize',
-        passed: true,
-        message: `Protocol version ${initResponse.protocolVersion}${capList.length > 0 ? `, capabilities: ${capList.join(', ')}` : ''}`,
-        details: verbose ? JSON.stringify(initResponse, null, 2) : undefined,
-      },
-      transport,
-      capabilities,
-    }
-  } catch (error) {
-    return {
-      result: {
-        name: 'initialize',
-        passed: false,
-        message: `Initialize failed: ${error instanceof Error ? error.message : String(error)}`,
-      },
-    }
-  }
-}
-
-/**
- * Check: session/new
- * Verify adapter creates session and returns sessionId.
- */
-const checkSessionNew = async (
-  transport: ReturnType<typeof createACPTransport>,
-  verbose: boolean,
-): Promise<{ result: CheckResult; sessionId?: string }> => {
-  try {
-    const response = await transport.request<{ sessionId: string }>(ACP_METHODS.CREATE_SESSION, {
-      cwd: process.cwd(),
-    })
-
-    if (!response || !response.sessionId) {
-      return {
-        result: {
-          name: 'session/new',
-          passed: false,
-          message: 'No sessionId in response',
-        },
-      }
-    }
-
-    return {
-      result: {
-        name: 'session/new',
-        passed: true,
-        message: `Session ${response.sessionId} created`,
-        details: verbose ? JSON.stringify(response, null, 2) : undefined,
-      },
-      sessionId: response.sessionId,
-    }
-  } catch (error) {
-    return {
-      result: {
-        name: 'session/new',
-        passed: false,
-        message: `session/new failed: ${error instanceof Error ? error.message : String(error)}`,
-      },
-    }
-  }
-}
-
-/**
- * Check: session/prompt
- * Verify adapter accepts prompt and emits session/update notifications.
- */
-const checkSessionPrompt = async (config: CheckConfig, sessionId: string): Promise<CheckResult> => {
-  const { command, timeout, verbose } = config
-  const updates: unknown[] = []
-
-  // Create a new transport with update collection
-  const transport = createACPTransport({
-    command,
-    timeout,
-    onNotification: (method: string, params: unknown) => {
-      if (method === ACP_METHODS.UPDATE) {
-        updates.push(params)
-      }
-    },
-    onRequest: async () => ({}),
-    onError: () => {},
-    onClose: () => {},
-  })
-
-  try {
-    await transport.start()
-
-    // Re-initialize for new connection
-    await transport.request(ACP_METHODS.INITIALIZE, {
-      protocolVersion: ACP_PROTOCOL_VERSION,
-      clientInfo: { name: DEFAULT_ACP_CLIENT_NAME, version: '1.0.0' },
-      clientCapabilities: {},
-    })
-
-    const response = await transport.request<{ content: unknown[] }>(ACP_METHODS.PROMPT, {
-      sessionId,
-      prompt: [{ type: 'text', text: 'Hello, this is a test prompt.' }],
-    })
-
-    await transport.close(false)
-
-    if (!response || !response.content) {
-      return {
-        name: 'session/prompt',
-        passed: false,
-        message: 'No content in response',
-      }
-    }
-
-    // Categorize updates
-    const updateTypes = updates.map((u) => {
-      const update = u as { update?: { sessionUpdate?: string } }
-      return update?.update?.sessionUpdate ?? 'unknown'
-    })
-
-    const uniqueTypes = [...new Set(updateTypes)]
-    const typeDisplay = uniqueTypes.length > 0 ? uniqueTypes.join(', ') : 'none'
-
-    return {
-      name: 'session/prompt',
-      passed: true,
-      message: `Received ${updates.length} update${updates.length !== 1 ? 's' : ''} (${typeDisplay})`,
-      details: verbose ? JSON.stringify({ updates, response }, null, 2) : undefined,
-    }
-  } catch (error) {
-    await transport.close(false).catch(() => {})
-
-    return {
-      name: 'session/prompt',
-      passed: false,
-      message: `session/prompt failed: ${error instanceof Error ? error.message : String(error)}`,
-    }
-  }
-}
-
-/**
- * Check: session/cancel
- * Verify adapter accepts cancel notification gracefully.
- */
-const checkSessionCancel = async (config: CheckConfig, sessionId: string): Promise<CheckResult> => {
-  const { command, timeout, verbose } = config
-
-  const transport = createACPTransport({
-    command,
-    timeout,
-    onNotification: () => {},
-    onRequest: async () => ({}),
-    onError: () => {},
-    onClose: () => {},
-  })
-
-  try {
-    await transport.start()
-
-    // Re-initialize for new connection
-    await transport.request(ACP_METHODS.INITIALIZE, {
-      protocolVersion: ACP_PROTOCOL_VERSION,
-      clientInfo: { name: DEFAULT_ACP_CLIENT_NAME, version: '1.0.0' },
-      clientCapabilities: {},
-    })
-
-    await transport.notify(ACP_METHODS.CANCEL, { sessionId })
-
-    // Give adapter a moment to process the notification
-    await new Promise((resolve) => setTimeout(resolve, 100))
-
-    await transport.close(false)
-
-    return {
-      name: 'session/cancel',
-      passed: true,
-      message: 'Acknowledged without error',
-      details: verbose ? `Sent cancel for session ${sessionId}` : undefined,
-    }
-  } catch (error) {
-    await transport.close(false).catch(() => {})
-
-    return {
-      name: 'session/cancel',
-      passed: false,
-      message: `session/cancel failed: ${error instanceof Error ? error.message : String(error)}`,
-    }
-  }
-}
-
-/**
- * Check: framing
- * Verify all messages are valid JSON-RPC 2.0.
- * This is implicitly tested by the other checks succeeding.
- */
-const checkFraming = (previousChecks: CheckResult[]): CheckResult => {
-  // If all previous checks passed, framing is valid
-  const allPassed = previousChecks.every((c) => c.passed)
-
-  if (allPassed) {
-    return {
-      name: 'framing',
-      passed: true,
-      message: 'All messages valid JSON-RPC 2.0',
-    }
-  }
-
-  return {
-    name: 'framing',
-    passed: false,
-    message: 'Some messages failed validation (see above)',
-  }
-}
-
-// ============================================================================
-// Main Check Runner
-// ============================================================================
-
-/**
- * Run full compliance check against an adapter.
- *
- * @param config - Check configuration
- * @returns Compliance result with all check details
- */
-export const runCheck = async (config: CheckConfig): Promise<ComplianceResult> => {
-  const checks: CheckResult[] = []
-
-  // Check 1: spawn
-  const spawnResult = await checkSpawn(config)
-  checks.push(spawnResult)
-
-  if (!spawnResult.passed) {
-    // Can't continue if spawn fails
-    return {
-      passed: false,
-      checks,
-      summary: { total: 6, passed: 0, failed: 1 },
-    }
-  }
-
-  // Check 2: initialize
-  const { result: initResult, transport, capabilities: _ } = await checkInitialize(config)
-  checks.push(initResult)
-
-  if (!initResult.passed || !transport) {
-    return {
-      passed: false,
-      checks,
-      summary: { total: 6, passed: 1, failed: 1 },
-    }
-  }
-
-  // Check 3: session/new
-  const { result: sessionResult, sessionId } = await checkSessionNew(transport, config.verbose)
-  checks.push(sessionResult)
-
-  if (!sessionResult.passed || !sessionId) {
-    await transport.close(false)
-    return {
-      passed: false,
-      checks,
-      summary: { total: 6, passed: 2, failed: 1 },
-    }
-  }
-
-  // Clean up init transport - we'll create fresh ones for remaining checks
-  await transport.close(true)
-
-  // Check 4: session/prompt (uses fresh transport)
-  const promptResult = await checkSessionPrompt(config, sessionId)
-  checks.push(promptResult)
-
-  // Check 5: session/cancel (uses fresh transport)
-  const cancelResult = await checkSessionCancel(config, sessionId)
-  checks.push(cancelResult)
-
-  // Check 6: framing (based on previous results)
-  const framingResult = checkFraming(checks)
-  checks.push(framingResult)
-
-  const passed = checks.filter((c) => c.passed).length
-  const failed = checks.filter((c) => !c.passed).length
-
-  return {
-    passed: failed === 0,
-    checks,
-    summary: {
-      total: checks.length,
-      passed,
-      failed,
-    },
-  }
-}
-
-// ============================================================================
-// CLI Entry Point
-// ============================================================================
-
-/**
- * Adapter check command CLI handler.
- *
- * @param args - Command line arguments (after 'adapter:check')
- */
-export const adapterCheck = async (args: string[]): Promise<void> => {
-  const { values, positionals } = parseArgs({
-    args,
-    options: {
-      timeout: { type: 'string', default: '5000' },
-      verbose: { type: 'boolean', default: false },
-      help: { type: 'boolean', short: 'h' },
-    },
-    allowPositionals: true,
-  })
-
-  if (values.help) {
-    // biome-ignore lint/suspicious/noConsole: CLI help output
-    console.log(`
-Usage: acp-harness adapter:check <command> [args...]
-
-Arguments:
-  command [args]    Command to spawn the adapter
-
-Options:
-  --timeout         Timeout for each check in ms (default: 5000)
-  --verbose         Show detailed protocol messages
-  -h, --help        Show this help message
-
-Checks Performed:
-  spawn             Adapter can be launched as subprocess
-  initialize        Responds with valid agentCapabilities
-  session/new       Creates session and returns sessionId
-  session/prompt    Accepts prompt and emits updates
-  session/cancel    Accepts cancel notification gracefully
-  framing           All messages are valid JSON-RPC 2.0
-
-Examples:
-  # Check local TypeScript adapter
-  acp-harness adapter:check bun ./my-adapter/src/main.ts
-
-  # Check with verbose output
-  acp-harness adapter:check bunx my-adapter --verbose
-
-  # Check Python adapter
-  acp-harness adapter:check python ./adapter.py
-`)
-    return
-  }
-
-  if (positionals.length === 0) {
-    console.error('Error: adapter command is required')
-    console.error('Example: acp-harness adapter:check bun ./src/main.ts')
-    process.exit(1)
-  }
-
-  const command = positionals
-
-  // biome-ignore lint/suspicious/noConsole: CLI output
-  console.log(`Checking ACP compliance for: ${command.join(' ')}\n`)
-
-  const result = await runCheck({
-    command,
-    timeout: Number.parseInt(values.timeout ?? '5000', 10),
-    verbose: values.verbose ?? false,
-  })
-
-  // Print results
-  for (const check of result.checks) {
-    const icon = check.passed ? '\u2713' : '\u2717'
-    const color = check.passed ? '\x1b[32m' : '\x1b[31m'
-    const reset = '\x1b[0m'
-
-    // biome-ignore lint/suspicious/noConsole: CLI output
-    console.log(`${color}${icon}${reset} ${check.name}: ${check.message}`)
-
-    if (check.details && values.verbose) {
-      // biome-ignore lint/suspicious/noConsole: CLI verbose output
-      console.log(`  ${check.details.split('\n').join('\n  ')}`)
-    }
-  }
-
-  // biome-ignore lint/suspicious/noConsole: CLI output
-  console.log(
-    `\n${result.summary.passed}/${result.summary.total} checks passed.${result.passed ? ' Adapter is ACP-compliant.' : ''}`,
-  )
-
-  if (!result.passed) {
-    process.exit(1)
-  }
-}
diff --git a/src/adapter-scaffold.ts b/src/adapter-scaffold.ts
deleted file mode 100644
index c0681c4..0000000
--- a/src/adapter-scaffold.ts
+++ /dev/null
@@ -1,935 +0,0 @@
-/**
- * ACP adapter project scaffolding.
- *
- * @remarks
- * Generates boilerplate for new ACP adapter projects with proper structure,
- * TypeScript configuration, and example handlers.
- *
- * Supports TypeScript and Python adapters.
- *
- * @packageDocumentation
- */
-
-import { stat } from 'node:fs/promises'
-import { join } from 'node:path'
-import { parseArgs } from 'node:util'
-
-// ============================================================================
-// Types
-// ============================================================================
-
-/** Configuration for scaffold generation */
-export type ScaffoldConfig = {
-  /** Adapter name (used for package name and directory) */
-  name: string
-  /** Output directory path */
-  outputDir: string
-  /** Language: 'ts' or 'python' */
-  lang: 'ts' | 'python'
-  /** Generate minimal boilerplate only */
-  minimal: boolean
-}
-
-/** Result of scaffold operation */
-export type ScaffoldResult = {
-  /** Output directory path */
-  outputDir: string
-  /** List of created files */
-  files: string[]
-  /** Language used */
-  lang: 'ts' | 'python'
-}
-
-// ============================================================================
-// TypeScript Templates
-// ============================================================================
-
-const tsPackageJson = (name: string): string => `{
-  "name": "${name}-acp",
-  "version": "1.0.0",
-  "type": "module",
-  "bin": {
-    "${name}-acp": "./src/main.ts"
-  },
-  "scripts": {
-    "start": "bun run src/main.ts",
-    "check": "bunx @plaited/acp-harness adapter:check bun ./src/main.ts"
-  },
-  "dependencies": {
-    "@agentclientprotocol/sdk": "^0.0.1"
-  },
-  "devDependencies": {
-    "@types/bun": "latest",
-    "typescript": "^5.0.0"
-  }
-}
-`
-
-const tsTsConfig = (): string => `{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "outDir": "dist",
-    "declaration": true
-  },
-  "include": ["src"]
-}
-`
-
-const tsIndexFile = (name: string): string => `#!/usr/bin/env bun
-/**
- * ${name} ACP adapter entry point.
- *
- * This adapter translates between the Agent Client Protocol and
- * your agent's native API.
- */
-
-import { createInterface } from 'node:readline'
-import { handleInitialize } from './handlers/initialize.ts'
-import { handleSessionNew, handleSessionLoad } from './handlers/session-new.ts'
-import { handleSessionPrompt } from './handlers/session-prompt.ts'
-import { handleSessionCancel } from './handlers/session-cancel.ts'
-import type { JsonRpcRequest, JsonRpcResponse, JsonRpcNotification } from './types.ts'
-
-// Method handlers
-const methodHandlers: Record<string, (params: unknown) => Promise<unknown>> = {
-  initialize: handleInitialize,
-  'session/new': handleSessionNew,
-  'session/load': handleSessionLoad,
-  'session/prompt': handleSessionPrompt,
-}
-
-// Notification handlers (no response expected)
-const notificationHandlers: Record<string, (params: unknown) => Promise<void>> = {
-  'session/cancel': handleSessionCancel,
-}
-
-/**
- * Send a JSON-RPC message to stdout.
- */
-export const sendMessage = (message: JsonRpcResponse | JsonRpcNotification): void => {
-  // biome-ignore lint/suspicious/noConsole: Protocol output
-  console.log(JSON.stringify(message))
-}
-
-/**
- * Send a session update notification.
- */
-export const sendSessionUpdate = (sessionId: string, update: unknown): void => {
-  sendMessage({
-    jsonrpc: '2.0',
-    method: 'session/update',
-    params: { sessionId, update },
-  })
-}
-
-/**
- * Process incoming JSON-RPC message.
- */
-const processMessage = async (line: string): Promise<void> => {
-  let request: JsonRpcRequest | JsonRpcNotification
-
-  try {
-    request = JSON.parse(line)
-  } catch {
-    sendMessage({
-      jsonrpc: '2.0',
-      id: null,
-      error: { code: -32700, message: 'Parse error' },
-    })
-    return
-  }
-
-  // Check if it's a notification (no id)
-  const isNotification = !('id' in request)
-
-  if (isNotification) {
-    const handler = notificationHandlers[request.method]
-    if (handler) {
-      await handler(request.params)
-    }
-    // No response for notifications
-    return
-  }
-
-  // It's a request - send response
-  const reqWithId = request as JsonRpcRequest
-  const handler = methodHandlers[reqWithId.method]
-
-  if (!handler) {
-    sendMessage({
-      jsonrpc: '2.0',
-      id: reqWithId.id,
-      error: { code: -32601, message: \`Method not found: \${reqWithId.method}\` },
-    })
-    return
-  }
-
-  try {
-    const result = await handler(reqWithId.params)
-    sendMessage({
-      jsonrpc: '2.0',
-      id: reqWithId.id,
-      result,
-    })
-  } catch (error) {
-    sendMessage({
-      jsonrpc: '2.0',
-      id: reqWithId.id,
-      error: {
-        code: -32603,
-        message: error instanceof Error ? error.message : 'Internal error',
-      },
-    })
-  }
-}
-
-// Main loop: read lines from stdin
-const rl = createInterface({
-  input: process.stdin,
-  output: process.stdout,
-  terminal: false,
-})
-
-rl.on('line', processMessage)
-
-// Handle clean shutdown
-process.on('SIGTERM', () => {
-  rl.close()
-  process.exit(0)
-})
-`
-
-const tsTypesFile = (): string => `/**
- * TypeScript types for JSON-RPC 2.0 protocol.
- */
-
-export type JsonRpcRequest = {
-  jsonrpc: '2.0'
-  id: string | number
-  method: string
-  params?: unknown
-}
-
-export type JsonRpcNotification = {
-  jsonrpc: '2.0'
-  method: string
-  params?: unknown
-}
-
-export type JsonRpcSuccessResponse = {
-  jsonrpc: '2.0'
-  id: string | number
-  result: unknown
-}
-
-export type JsonRpcErrorResponse = {
-  jsonrpc: '2.0'
-  id: string | number | null
-  error: {
-    code: number
-    message: string
-    data?: unknown
-  }
-}
-
-export type JsonRpcResponse = JsonRpcSuccessResponse | JsonRpcErrorResponse
-
-export type ContentBlock =
-  | { type: 'text'; text: string }
-  | { type: 'image'; source: { type: 'base64'; mediaType: string; data: string } }
-`
-
-const tsInitializeHandler = (name: string): string => `/**
- * Initialize handler - protocol handshake.
- */
-
-type InitializeParams = {
-  protocolVersion: number
-  clientInfo: { name: string; version: string }
-  clientCapabilities: Record<string, unknown>
-}
-
-type InitializeResult = {
-  protocolVersion: number
-  agentInfo: { name: string; version: string }
-  agentCapabilities: {
-    loadSession?: boolean
-    promptCapabilities?: {
-      image?: boolean
-    }
-  }
-}
-
-export const handleInitialize = async (params: unknown): Promise<InitializeResult> => {
-  const { protocolVersion } = params as InitializeParams
-
-  if (protocolVersion !== 1) {
-    throw new Error(\`Unsupported protocol version: \${protocolVersion}\`)
-  }
-
-  return {
-    protocolVersion: 1,
-    agentInfo: {
-      name: '${name}',
-      version: '1.0.0',
-    },
-    agentCapabilities: {
-      loadSession: false,
-      promptCapabilities: {
-        image: false,
-      },
-    },
-  }
-}
-`
-
-const tsSessionNewHandler = (): string => `/**
- * Session handlers - create and load sessions.
- */
-
-import { sessionManager } from '../session-manager.ts'
-
-type SessionNewParams = {
-  cwd: string
-}
-
-type SessionNewResult = {
-  sessionId: string
-}
-
-export const handleSessionNew = async (params: unknown): Promise<SessionNewResult> => {
-  const { cwd } = params as SessionNewParams
-
-  // MCP servers are discovered from cwd configuration files
-  // (e.g., .mcp.json, .gemini/settings.json)
-  const sessionId = sessionManager.createSession({ cwd })
-
-  return { sessionId }
-}
-
-type SessionLoadParams = {
-  sessionId: string
-}
-
-export const handleSessionLoad = async (params: unknown): Promise<SessionNewResult> => {
-  const { sessionId } = params as SessionLoadParams
-
-  const session = sessionManager.getSession(sessionId)
-  if (!session) {
-    throw new Error(\`Session not found: \${sessionId}\`)
-  }
-
-  return { sessionId }
-}
-`
-
-const tsSessionPromptHandler = (): string => `/**
- * Session prompt handler - process prompts and emit updates.
- */
-
-import { sessionManager } from '../session-manager.ts'
-import { sendSessionUpdate } from '../main.ts'
-import type { ContentBlock } from '../types.ts'
-
-type PromptParams = {
-  sessionId: string
-  prompt: ContentBlock[]
-}
-
-type PromptResult = {
-  content: ContentBlock[]
-}
-
-export const handleSessionPrompt = async (params: unknown): Promise<PromptResult> => {
-  const { sessionId, prompt } = params as PromptParams
-
-  const session = sessionManager.getSession(sessionId)
-  if (!session) {
-    throw new Error(\`Session not found: \${sessionId}\`)
-  }
-
-  // Extract text from content blocks
-  const promptText = prompt
-    .filter((block): block is ContentBlock & { type: 'text' } => block.type === 'text')
-    .map((block) => block.text)
-    .join('\\n')
-
-  // Emit thinking update
-  sendSessionUpdate(sessionId, {
-    sessionUpdate: 'agent_thought_chunk',
-    content: { type: 'text', text: 'Processing your request...' },
-  })
-
-  // TODO: Replace with your agent's actual API call
-  const response = await processWithYourAgent(promptText, session.cwd)
-
-  // Emit message update
-  sendSessionUpdate(sessionId, {
-    sessionUpdate: 'agent_message_chunk',
-    content: { type: 'text', text: response },
-  })
-
-  return {
-    content: [{ type: 'text', text: response }],
-  }
-}
-
-/**
- * Replace this with your actual agent API call.
- */
-const processWithYourAgent = async (prompt: string, _cwd: string): Promise<string> => {
-  // Example echo implementation - replace with real agent call
-  return \`Echo: \${prompt}\`
-}
-`
-
-const tsSessionCancelHandler = (): string => `/**
- * Session cancel handler - cancel ongoing prompts.
- */
-
-type CancelParams = {
-  sessionId: string
-}
-
-// Track active requests for cancellation
-const activeRequests = new Map<string, AbortController>()
-
-export const handleSessionCancel = async (params: unknown): Promise<void> => {
-  const { sessionId } = params as CancelParams
-
-  const controller = activeRequests.get(sessionId)
-  if (controller) {
-    controller.abort()
-    activeRequests.delete(sessionId)
-  }
-}
-
-/**
- * Register an active request for cancellation support.
- */
-export const registerActiveRequest = (
-  sessionId: string,
-  controller: AbortController
-): void => {
-  activeRequests.set(sessionId, controller)
-}
-
-/**
- * Unregister an active request after completion.
- */
-export const unregisterActiveRequest = (sessionId: string): void => {
-  activeRequests.delete(sessionId)
-}
-`
-
-const tsSessionManager = (): string => `/**
- * Session manager - tracks active conversation sessions.
- */
-
-import { randomUUID } from 'node:crypto'
-
-type Session = {
-  id: string
-  cwd: string
-  createdAt: Date
-}
-
-class SessionManager {
-  #sessions = new Map<string, Session>()
-
-  createSession(params: { cwd: string }): string {
-    const id = \`sess_\${randomUUID().slice(0, 8)}\`
-    this.#sessions.set(id, {
-      id,
-      cwd: params.cwd,
-      createdAt: new Date(),
-    })
-    return id
-  }
-
-  getSession(id: string): Session | undefined {
-    return this.#sessions.get(id)
-  }
-
-  deleteSession(id: string): boolean {
-    return this.#sessions.delete(id)
-  }
-
-  listSessions(): Session[] {
-    return Array.from(this.#sessions.values())
-  }
-}
-
-export const sessionManager = new SessionManager()
-`
-
-const tsReadme = (name: string): string => `# ${name} ACP Adapter
-
-ACP (Agent Client Protocol) adapter for ${name}.
-
-## Quick Start
-
-\`\`\`bash
-# Install dependencies
-bun install
-
-# Run the adapter
-bun run start
-
-# Or run directly
-bun run src/main.ts
-\`\`\`
-
-## Verify Compliance
-
-\`\`\`bash
-# Run compliance checker
-bun run check
-
-# Or manually
-bunx @plaited/acp-harness adapter:check bun ./src/main.ts
-\`\`\`
-
-## Test with Harness
-
-\`\`\`bash
-# Create test prompts
-echo '{"id":"test-1","input":"Hello"}' > prompts.jsonl
-
-# Run capture
-bunx @plaited/acp-harness capture prompts.jsonl bun ./src/main.ts -o results.jsonl
-
-# View results
-cat results.jsonl | jq .
-\`\`\`
-
-## Implementation
-
-Replace the placeholder in \`src/handlers/session-prompt.ts\`:
-
-\`\`\`typescript
-const processWithYourAgent = async (prompt: string, cwd: string): Promise<string> => {
-  // Call your agent's API here
-  const response = await yourAgentClient.chat(prompt)
-  return response.text
-}
-\`\`\`
-
-## Protocol Reference
-
-See the [ACP Specification](https://agentclientprotocol.org) for protocol details.
-`
-
-// ============================================================================
-// Python Templates
-// ============================================================================
-
-const pythonAdapter = (name: string): string => `#!/usr/bin/env python3
-"""
-${name} ACP adapter.
-
-ACP (Agent Client Protocol) adapter for ${name}.
-Translates between JSON-RPC 2.0 and your agent's native API.
-"""
-
-import json
-import sys
-import uuid
-from typing import Any, Dict, Optional
-
-# Session storage
-sessions: Dict[str, Dict[str, Any]] = {}
-
-
-def create_session(cwd: str) -> str:
-    """Create a new session.
-
-    MCP servers are discovered from cwd configuration files.
-    """
-    session_id = f"sess_{uuid.uuid4().hex[:8]}"
-    sessions[session_id] = {
-        "id": session_id,
-        "cwd": cwd,
-    }
-    return session_id
-
-
-def get_session(session_id: str) -> Optional[Dict[str, Any]]:
-    """Get session by ID."""
-    return sessions.get(session_id)
-
-
-def send_message(message: Dict[str, Any]) -> None:
-    """Send JSON-RPC message to stdout."""
-    print(json.dumps(message), flush=True)
-
-
-def send_session_update(session_id: str, update: Dict[str, Any]) -> None:
-    """Send session update notification."""
-    send_message({
-        "jsonrpc": "2.0",
-        "method": "session/update",
-        "params": {"sessionId": session_id, "update": update},
-    })
-
-
-def handle_initialize(params: Dict[str, Any]) -> Dict[str, Any]:
-    """Handle initialize request."""
-    protocol_version = params.get("protocolVersion", 0)
-    if protocol_version != 1:
-        raise ValueError(f"Unsupported protocol version: {protocol_version}")
-
-    return {
-        "protocolVersion": 1,
-        "agentInfo": {"name": "${name}", "version": "1.0.0"},
-        "agentCapabilities": {
-            "loadSession": False,
-            "promptCapabilities": {"image": False},
-        },
-    }
-
-
-def handle_session_new(params: Dict[str, Any]) -> Dict[str, Any]:
-    """Handle session/new request.
-
-    MCP servers are discovered from cwd configuration files
-    (e.g., .mcp.json, .gemini/settings.json).
-    """
-    cwd = params.get("cwd", ".")
-    session_id = create_session(cwd)
-    return {"sessionId": session_id}
-
-
-def handle_session_prompt(params: Dict[str, Any]) -> Dict[str, Any]:
-    """Handle session/prompt request."""
-    session_id = params["sessionId"]
-    session = get_session(session_id)
-    if not session:
-        raise ValueError(f"Session not found: {session_id}")
-
-    # Extract text from prompt blocks
-    prompt_text = " ".join(
-        block["text"]
-        for block in params.get("prompt", [])
-        if block.get("type") == "text"
-    )
-
-    # Send thinking update
-    send_session_update(session_id, {
-        "sessionUpdate": "agent_thought_chunk",
-        "content": {"type": "text", "text": "Processing your request..."},
-    })
-
-    # TODO: Replace with your agent's actual API call
-    response = process_with_your_agent(prompt_text, session["cwd"])
-
-    # Send message update
-    send_session_update(session_id, {
-        "sessionUpdate": "agent_message_chunk",
-        "content": {"type": "text", "text": response},
-    })
-
-    return {"content": [{"type": "text", "text": response}]}
-
-
-def process_with_your_agent(prompt: str, cwd: str) -> str:
-    """Replace with your actual agent API call."""
-    return f"Echo: {prompt}"
-
-
-# Method handlers
-METHOD_HANDLERS = {
-    "initialize": handle_initialize,
-    "session/new": handle_session_new,
-    "session/prompt": handle_session_prompt,
-}
-
-
-def process_message(line: str) -> None:
-    """Process incoming JSON-RPC message."""
-    try:
-        request = json.loads(line)
-    except json.JSONDecodeError:
-        send_message({
-            "jsonrpc": "2.0",
-            "id": None,
-            "error": {"code": -32700, "message": "Parse error"},
-        })
-        return
-
-    # Check if notification (no id)
-    if "id" not in request:
-        # Handle notification silently
-        return
-
-    method = request.get("method", "")
-    handler = METHOD_HANDLERS.get(method)
-
-    if not handler:
-        send_message({
-            "jsonrpc": "2.0",
-            "id": request["id"],
-            "error": {"code": -32601, "message": f"Method not found: {method}"},
-        })
-        return
-
-    try:
-        result = handler(request.get("params", {}))
-        send_message({
-            "jsonrpc": "2.0",
-            "id": request["id"],
-            "result": result,
-        })
-    except Exception as e:
-        send_message({
-            "jsonrpc": "2.0",
-            "id": request["id"],
-            "error": {"code": -32603, "message": str(e)},
-        })
-
-
-def main() -> None:
-    """Main loop: read lines from stdin."""
-    for line in sys.stdin:
-        line = line.strip()
-        if line:
-            process_message(line)
-
-
-if __name__ == "__main__":
-    main()
-`
-
-const pythonReadme = (name: string): string => `# ${name} ACP Adapter
-
-ACP (Agent Client Protocol) adapter for ${name} (Python).
-
-## Quick Start
-
-\`\`\`bash
-# Make executable
-chmod +x adapter.py
-
-# Run the adapter
-python adapter.py
-\`\`\`
-
-## Verify Compliance
-
-\`\`\`bash
-bunx @plaited/acp-harness adapter:check python ./adapter.py
-\`\`\`
-
-## Test with Harness
-
-\`\`\`bash
-# Create test prompts
-echo '{"id":"test-1","input":"Hello"}' > prompts.jsonl
-
-# Run capture
-bunx @plaited/acp-harness capture prompts.jsonl python ./adapter.py -o results.jsonl
-
-# View results
-cat results.jsonl | jq .
-\`\`\`
-
-## Implementation
-
-Replace the placeholder in \`adapter.py\`:
-
-\`\`\`python
-def process_with_your_agent(prompt: str, cwd: str) -> str:
-    # Call your agent's API here
-    response = your_agent_client.chat(prompt)
-    return response.text
-\`\`\`
-
-## Protocol Reference
-
-See the [ACP Specification](https://agentclientprotocol.org) for protocol details.
-`
-
-// ============================================================================
-// Scaffold Implementation
-// ============================================================================
-
-/**
- * Generate TypeScript adapter project.
- */
-const scaffoldTypeScript = async (config: ScaffoldConfig): Promise<string[]> => {
-  const { name, outputDir, minimal } = config
-  const files: string[] = []
-
-  // Create directories
-  await Bun.write(join(outputDir, 'src', 'handlers', '.gitkeep'), '')
-
-  // Core files
-  await Bun.write(join(outputDir, 'package.json'), tsPackageJson(name))
-  files.push('package.json')
-
-  await Bun.write(join(outputDir, 'tsconfig.json'), tsTsConfig())
-  files.push('tsconfig.json')
-
-  await Bun.write(join(outputDir, 'src', 'main.ts'), tsIndexFile(name))
-  files.push('src/main.ts')
-
-  await Bun.write(join(outputDir, 'src', 'types.ts'), tsTypesFile())
-  files.push('src/types.ts')
-
-  await Bun.write(join(outputDir, 'src', 'session-manager.ts'), tsSessionManager())
-  files.push('src/session-manager.ts')
-
-  // Handler files
-  await Bun.write(join(outputDir, 'src', 'handlers', 'initialize.ts'), tsInitializeHandler(name))
-  files.push('src/handlers/initialize.ts')
-
-  await Bun.write(join(outputDir, 'src', 'handlers', 'session-new.ts'), tsSessionNewHandler())
-  files.push('src/handlers/session-new.ts')
-
-  await Bun.write(join(outputDir, 'src', 'handlers', 'session-prompt.ts'), tsSessionPromptHandler())
-  files.push('src/handlers/session-prompt.ts')
-
-  await Bun.write(join(outputDir, 'src', 'handlers', 'session-cancel.ts'), tsSessionCancelHandler())
-  files.push('src/handlers/session-cancel.ts')
-
-  // README (unless minimal)
-  if (!minimal) {
-    await Bun.write(join(outputDir, 'README.md'), tsReadme(name))
-    files.push('README.md')
-  }
-
-  return files
-}
-
-/**
- * Generate Python adapter project.
- */
-const scaffoldPython = async (config: ScaffoldConfig): Promise<string[]> => {
-  const { name, outputDir, minimal } = config
-  const files: string[] = []
-
-  await Bun.write(join(outputDir, 'adapter.py'), pythonAdapter(name))
-  files.push('adapter.py')
-
-  if (!minimal) {
-    await Bun.write(join(outputDir, 'README.md'), pythonReadme(name))
-    files.push('README.md')
-  }
-
-  return files
-}
-
-/**
- * Run adapter scaffolding with configuration object.
- *
- * @param config - Scaffold configuration
- * @returns Scaffold result with created files
- */
-export const runScaffold = async (config: ScaffoldConfig): Promise<ScaffoldResult> => {
-  const { outputDir, lang } = config
-
-  // Create output directory
-  await Bun.write(join(outputDir, '.gitkeep'), '')
-
-  const files = lang === 'python' ? await scaffoldPython(config) : await scaffoldTypeScript(config)
-
-  return {
-    outputDir,
-    files,
-    lang,
-  }
-}
-
-// ============================================================================
-// CLI Entry Point
-// ============================================================================
-
-/**
- * Adapter scaffold command CLI handler.
- *
- * @param args - Command line arguments (after 'adapter:scaffold')
- */
-export const adapterScaffold = async (args: string[]): Promise<void> => {
-  const { values, positionals } = parseArgs({
-    args,
-    options: {
-      output: { type: 'string', short: 'o' },
-      lang: { type: 'string', default: 'ts' },
-      minimal: { type: 'boolean', default: false },
-      help: { type: 'boolean', short: 'h' },
-    },
-    allowPositionals: true,
-  })
-
-  if (values.help) {
-    // biome-ignore lint/suspicious/noConsole: CLI help output
-    console.log(`
-Usage: acp-harness adapter:scaffold [name] [options]
-
-Arguments:
-  name              Adapter name (used for package name)
-
-Options:
-  -o, --output      Output directory (default: ./<name>-acp)
-  --lang            Language: ts or python (default: ts)
-  --minimal         Generate minimal boilerplate only
-  -h, --help        Show this help message
-
-Examples:
-  # Scaffold TypeScript adapter
-  acp-harness adapter:scaffold my-agent
-
-  # Scaffold Python adapter
-  acp-harness adapter:scaffold my-agent --lang python
-
-  # Scaffold to specific directory
-  acp-harness adapter:scaffold my-agent -o ./adapters/my-agent
-`)
-    return
-  }
-
-  const name = positionals[0]
-  if (!name) {
-    console.error('Error: adapter name is required')
-    console.error('Example: acp-harness adapter:scaffold my-agent')
-    process.exit(1)
-  }
-
-  const lang = values.lang === 'python' ? 'python' : 'ts'
-  const outputDir = values.output ?? `./${name}-acp`
-
-  // Check if directory already exists
-  const dirExists = await stat(outputDir).catch(() => null)
-  if (dirExists) {
-    console.error(`Error: directory already exists: ${outputDir}`)
-    process.exit(1)
-  }
-
-  const result = await runScaffold({
-    name,
-    outputDir,
-    lang,
-    minimal: values.minimal ?? false,
-  })
-
-  // biome-ignore lint/suspicious/noConsole: CLI output
-  console.log(`
-Scaffolded ${result.lang === 'ts' ? 'TypeScript' : 'Python'} adapter: ${name}
-
-Created files:
-${result.files.map((f) => `  ${result.outputDir}/${f}`).join('\n')}
-
-Next steps:
-  cd ${result.outputDir}
-${result.lang === 'ts' ? '  bun install' : '  chmod +x adapter.py'}
-${result.lang === 'ts' ? '  bun run start' : '  python adapter.py'}
-
-Verify compliance:
-  acp-harness adapter:check ${result.lang === 'ts' ? 'bun ./src/main.ts' : 'python ./adapter.py'}
-`)
-}
diff --git a/src/capture.ts b/src/capture.ts
deleted file mode 100644
index c966b5f..0000000
--- a/src/capture.ts
+++ /dev/null
@@ -1,538 +0,0 @@
-/**
- * Core trajectory capture command.
- *
- * @remarks
- * Executes prompts against an ACP agent and captures full trajectories.
- * This is the foundational command - all other views derive from its output.
- *
- * Output format is always full trajectory JSONL (`CaptureResultSchema`).
- * Use `summarize` command to derive compact views.
- *
- * @packageDocumentation
- */
-
-import { appendFile } from 'node:fs/promises'
-import { parseArgs } from 'node:util'
-import type { SessionNotification, ToolCall } from '@agentclientprotocol/sdk'
-import { createACPClient } from './acp-client.ts'
-import { createPrompt } from './acp-helpers.ts'
-import { DEFAULT_HARNESS_TIMEOUT, HEAD_LINES, TAIL_LINES } from './constants.ts'
-import { loadGrader } from './grader-loader.ts'
-import type { CaptureResult, Grader, PromptCase, TrajectoryRichness, TrajectoryStep } from './schemas.ts'
-import { PromptCaseSchema, TokenUsageSchema, ToolInputSchema } from './schemas.ts'
-
-// ============================================================================
-// Types
-// ============================================================================
-
-/** Configuration for capture command */
-export type CaptureConfig = {
-  /** Path to prompts.jsonl file */
-  promptsPath: string
-  /** ACP agent command (e.g., ['bunx', 'claude-code-acp']) */
-  agentCommand: string[]
-  /** Output file path (undefined for stdout) */
-  outputPath?: string
-  /** Working directory for agent */
-  cwd?: string
-  /** Timeout per prompt in milliseconds */
-  timeout?: number
-  /** Show progress to stderr */
-  progress?: boolean
-  /** Append to output file instead of overwriting */
-  append?: boolean
-  /** Optional grader function */
-  grader?: Grader
-}
-
-// ============================================================================
-// Helpers
-// ============================================================================
-
-/** Load prompts from JSONL file */
-export const loadPrompts = async (path: string): Promise<PromptCase[]> => {
-  const content = await Bun.file(path).text()
-  return content
-    .trim()
-    .split('\n')
-    .filter(Boolean)
-    .map((line, index) => {
-      try {
-        return PromptCaseSchema.parse(JSON.parse(line))
-      } catch (error) {
-        throw new Error(`Invalid prompt at line ${index + 1}: ${error instanceof Error ? error.message : error}`)
-      }
-    })
-}
-
-/** Extract trajectory from session notifications */
-export const extractTrajectory = (notifications: SessionNotification[], startTime: number): TrajectoryStep[] => {
-  const trajectory: TrajectoryStep[] = []
-  const toolCallMap = new Map<string, { start: number; step: TrajectoryStep & { type: 'tool_call' } }>()
-
-  for (const notification of notifications) {
-    const timestamp = Date.now() - startTime
-    const update = notification.update
-
-    if (update.sessionUpdate === 'agent_thought_chunk' && update.content.type === 'text') {
-      trajectory.push({
-        type: 'thought',
-        content: update.content.text,
-        timestamp,
-      })
-    } else if (update.sessionUpdate === 'agent_message_chunk' && update.content.type === 'text') {
-      trajectory.push({
-        type: 'message',
-        content: update.content.text,
-        timestamp,
-      })
-    } else if (update.sessionUpdate === 'tool_call') {
-      const toolCall = update as ToolCall
-      const existing = toolCallMap.get(toolCall.toolCallId)
-
-      if (existing) {
-        // Update existing tool call with completion info
-        existing.step.status = toolCall.status ?? 'pending'
-        if (toolCall.content) {
-          existing.step.output = toolCall.content
-        }
-        if (toolCall.rawOutput) {
-          existing.step.output = toolCall.rawOutput
-        }
-        existing.step.duration = timestamp - existing.start
-      } else {
-        // New tool call
-        const step: TrajectoryStep & { type: 'tool_call' } = {
-          type: 'tool_call',
-          name: toolCall.title,
-          status: toolCall.status ?? 'pending',
-          input: toolCall.rawInput,
-          timestamp,
-        }
-        toolCallMap.set(toolCall.toolCallId, { start: timestamp, step })
-        trajectory.push(step)
-      }
-    } else if (update.sessionUpdate === 'plan') {
-      trajectory.push({
-        type: 'plan',
-        entries: update.entries,
-        timestamp,
-      })
-    }
-  }
-
-  return trajectory
-}
-
-/** Extract final text output from trajectory */
-export const extractOutput = (trajectory: TrajectoryStep[]): string => {
-  return trajectory
-    .filter((step): step is TrajectoryStep & { type: 'message' } => step.type === 'message')
-    .map((step) => step.content)
-    .join('\n')
-}
-
-/** Check if any tool calls failed */
-export const hasToolErrors = (trajectory: TrajectoryStep[]): boolean => {
-  return trajectory.some((step) => step.type === 'tool_call' && step.status === 'failed')
-}
-
-/** Head/tail preview of content */
-export const headTailPreview = (content: string, headLines = HEAD_LINES, tailLines = TAIL_LINES): string => {
-  const lines = content.split('\n')
-  if (lines.length <= headLines + tailLines) {
-    return content
-  }
-  const head = lines.slice(0, headLines).join('\n')
-  const tail = lines.slice(-tailLines).join('\n')
-  const omitted = lines.length - headLines - tailLines
-  return `${head}\n\n// ... ${omitted} lines omitted ...\n\n${tail}`
-}
-
-/** Extract file path from tool input if present */
-export const extractFilePath = (input: unknown): string | undefined => {
-  const result = ToolInputSchema.safeParse(input)
-  if (!result.success) return undefined
-  return result.data.file_path ?? result.data.path
-}
-
-/** Extract content from tool input if present */
-export const extractContent = (input: unknown): string | undefined => {
-  const result = ToolInputSchema.safeParse(input)
-  if (!result.success) return undefined
-  return result.data.content ?? result.data.new_string
-}
-
-/** Write output line (to stdout or file) */
-const writeOutput = async (line: string, outputPath?: string, append?: boolean): Promise<void> => {
-  if (outputPath) {
-    if (append) {
-      await appendFile(outputPath, `${line}\n`)
-    } else {
-      await Bun.write(outputPath, `${line}\n`)
-    }
-  } else {
-    // biome-ignore lint/suspicious/noConsole: CLI stdout output
-    console.log(line)
-  }
-}
-
-/** Log progress to stderr (doesn't pollute stdout) */
-const logProgress = (message: string, showProgress: boolean): void => {
-  if (showProgress) {
-    console.error(message)
-  }
-}
-
-/** Resolve path relative to process.cwd() */
-const resolvePath = (path: string): string => {
-  if (path.startsWith('/')) return path
-  return `${process.cwd()}/${path}`
-}
-
-/**
- * Detect trajectory richness level from captured steps.
- *
- * @remarks
- * Different adapters provide varying levels of detail:
- * - `full`: Has thoughts, tool calls, or plans (e.g., Claude Code)
- * - `messages-only`: Only message steps present
- * - `minimal`: Empty or unknown content
- *
- * Uses single-pass iteration with early exit for efficiency.
- */
-export const detectTrajectoryRichness = (trajectory: TrajectoryStep[]): TrajectoryRichness => {
-  let hasMessages = false
-
-  for (const step of trajectory) {
-    // Early exit: any of these means 'full' richness
-    if (step.type === 'thought' || step.type === 'tool_call' || step.type === 'plan') {
-      return 'full'
-    }
-    if (step.type === 'message') {
-      hasMessages = true
-    }
-  }
-
-  return hasMessages ? 'messages-only' : 'minimal'
-}
-
-/**
- * Extract token counts from session notifications if available.
- *
- * @remarks
- * Token usage is adapter-dependent. If the adapter doesn't expose usage,
- * these fields will be undefined. Uses Zod validation for runtime type safety.
- */
-export const extractTokenCounts = (updates: SessionNotification[]): { inputTokens?: number; outputTokens?: number } => {
-  let inputTokens: number | undefined
-  let outputTokens: number | undefined
-
-  for (const update of updates) {
-    // Check for token usage in update (adapter-specific)
-    // ACP SDK doesn't declare 'usage' field, but adapters extend it at runtime
-    const updateRecord = update as Record<string, unknown>
-    const usageData = updateRecord.usage ?? (updateRecord.update as Record<string, unknown> | undefined)?.usage
-    const usage = TokenUsageSchema.safeParse(usageData)
-
-    if (usage.success) {
-      if (usage.data.inputTokens !== undefined) {
-        inputTokens = (inputTokens ?? 0) + usage.data.inputTokens
-      }
-      if (usage.data.outputTokens !== undefined) {
-        outputTokens = (outputTokens ?? 0) + usage.data.outputTokens
-      }
-    }
-  }
-
-  return { inputTokens, outputTokens }
-}
-
-/** Get preview text for input (handles string or array) */
-const getInputPreview = (input: string | string[]): string => {
-  if (Array.isArray(input)) {
-    const first = input[0] ?? ''
-    return `[${input.length} turns] ${first.slice(0, 40)}...`
-  }
-  return input.slice(0, 50)
-}
-
-// ============================================================================
-// Capture Implementation
-// ============================================================================
-
-/**
- * Execute capture with configuration object.
- *
- * @remarks
- * Creates a fresh session for each JSONL entry to ensure isolation.
- * Supports multi-turn conversations via `input: string[]`.
- *
- * @param config - Capture configuration
- * @returns Array of capture results
- */
-export const runCapture = async (config: CaptureConfig): Promise<CaptureResult[]> => {
-  const {
-    promptsPath,
-    agentCommand,
-    outputPath,
-    cwd,
-    timeout = DEFAULT_HARNESS_TIMEOUT,
-    progress = false,
-    append = false,
-    grader,
-  } = config
-
-  // Load prompts
-  const prompts = await loadPrompts(promptsPath)
-
-  // Resolve output path
-  const resolvedOutputPath = outputPath ? resolvePath(outputPath) : undefined
-
-  // Log progress info
-  logProgress(`Loaded ${prompts.length} prompts from ${promptsPath}`, progress)
-  logProgress(`Command: ${agentCommand.join(' ')}`, progress)
-  if (resolvedOutputPath) {
-    logProgress(`Output: ${resolvedOutputPath}`, progress)
-  }
-
-  // Create ACP client
-  const client = createACPClient({
-    command: agentCommand,
-    cwd,
-    timeout,
-  })
-
-  // Clear output file if not appending
-  if (resolvedOutputPath && !append) {
-    await Bun.write(resolvedOutputPath, '')
-  }
-
-  // Session params - agents auto-discover MCP configs from cwd
-  const sessionParams = {
-    cwd: cwd ?? process.cwd(),
-  }
-
-  const results: CaptureResult[] = []
-  let isFirstOutput = true
-
-  try {
-    logProgress('Connecting to agent...', progress)
-    await client.connect()
-    logProgress('Connected!', progress)
-
-    // Run evaluations sequentially - fresh session per entry
-    for (let i = 0; i < prompts.length; i++) {
-      const promptCase = prompts[i]
-      if (!promptCase) continue
-
-      logProgress(`[${i + 1}/${prompts.length}] ${promptCase.id}: ${getInputPreview(promptCase.input)}...`, progress)
-
-      const startTime = Date.now()
-      let result: CaptureResult
-
-      try {
-        // Create fresh session for each entry (ensures isolation)
-        const sessionStart = Date.now()
-        const session = await client.createSession(sessionParams)
-        const sessionCreation = Date.now() - sessionStart
-        logProgress(`  Session: ${session.id}`, progress)
-
-        // Handle string or array input
-        const inputs = Array.isArray(promptCase.input) ? promptCase.input : [promptCase.input]
-        const turnCount = inputs.length
-
-        // Collect all updates from all turns
-        const allUpdates: SessionNotification[] = []
-
-        // Execute each turn sequentially in the same session
-        for (const turnInput of inputs) {
-          const prompt = createPrompt(turnInput)
-          const { updates } = await client.promptSync(session.id, prompt)
-          allUpdates.push(...updates)
-        }
-
-        const endTime = Date.now()
-        const trajectory = extractTrajectory(allUpdates, startTime)
-        const output = extractOutput(trajectory)
-        const toolErrors = hasToolErrors(trajectory)
-        const trajectoryRichness = detectTrajectoryRichness(trajectory)
-        const tokenCounts = extractTokenCounts(allUpdates)
-
-        result = {
-          id: promptCase.id,
-          input: promptCase.input, // Preserve original (string or array)
-          output,
-          ...(promptCase.hint && { hint: promptCase.hint }),
-          trajectory,
-          metadata: {
-            ...promptCase.metadata,
-            agent: agentCommand.join(' '),
-            trajectoryRichness,
-            turnCount,
-          },
-          timing: {
-            start: startTime,
-            end: endTime,
-            firstResponse: trajectory.length > 0 ? trajectory[0]?.timestamp : undefined,
-            sessionCreation,
-            total: endTime - startTime,
-            ...(tokenCounts.inputTokens !== undefined && { inputTokens: tokenCounts.inputTokens }),
-            ...(tokenCounts.outputTokens !== undefined && { outputTokens: tokenCounts.outputTokens }),
-          },
-          toolErrors,
-        }
-
-        // Apply grader if provided
-        if (grader) {
-          result.score = await grader({
-            input: promptCase.input,
-            output,
-            hint: promptCase.hint,
-            trajectory,
-          })
-        }
-      } catch (error) {
-        const endTime = Date.now()
-        const message = error instanceof Error ? error.message : String(error)
-        const inputs = Array.isArray(promptCase.input) ? promptCase.input : [promptCase.input]
-
-        result = {
-          id: promptCase.id,
-          input: promptCase.input,
-          output: '',
-          trajectory: [],
-          metadata: {
-            ...promptCase.metadata,
-            agent: agentCommand.join(' '),
-            trajectoryRichness: 'minimal' as TrajectoryRichness,
-            turnCount: inputs.length,
-          },
-          timing: {
-            start: startTime,
-            end: endTime,
-            sessionCreation: 0,
-            total: endTime - startTime,
-          },
-          toolErrors: true,
-          errors: [message],
-        }
-      }
-
-      results.push(result)
-
-      // Write result immediately
-      const formatted = JSON.stringify(result)
-      await writeOutput(formatted, resolvedOutputPath, !isFirstOutput)
-      isFirstOutput = false
-
-      const statusIcon = result.toolErrors ? '!' : '✓'
-      logProgress(`  ${statusIcon} (${result.timing.total}ms)`, progress)
-    }
-  } finally {
-    logProgress('Disconnecting...', progress)
-    await client.disconnect()
-  }
-
-  logProgress('Done!', progress)
-  return results
-}
-
-// ============================================================================
-// CLI Entry Point
-// ============================================================================
-
-/**
- * Capture command CLI handler.
- *
- * @param args - Command line arguments (after 'capture')
- */
-export const capture = async (args: string[]): Promise<void> => {
-  const { values, positionals } = parseArgs({
-    args,
-    options: {
-      output: { type: 'string', short: 'o' },
-      cwd: { type: 'string', short: 'c' },
-      timeout: { type: 'string', short: 't', default: String(DEFAULT_HARNESS_TIMEOUT) },
-      progress: { type: 'boolean', default: false },
-      append: { type: 'boolean', default: false },
-      grader: { type: 'string', short: 'g' },
-      help: { type: 'boolean', short: 'h' },
-    },
-    allowPositionals: true,
-  })
-
-  if (values.help) {
-    // biome-ignore lint/suspicious/noConsole: CLI help output
-    console.log(`
-Usage: acp-harness capture <prompts.jsonl> <command> [args...] [options]
-
-Arguments:
-  prompts.jsonl     Input file with evaluation prompts
-  command [args]    ACP agent command to execute
-
-Options:
-  -o, --output      Output file (default: stdout)
-  -c, --cwd         Working directory for agent (agents auto-discover MCP configs from here)
-  -t, --timeout     Request timeout in ms (default: ${DEFAULT_HARNESS_TIMEOUT})
-  --progress        Show progress to stderr
-  --append          Append to output file instead of overwriting
-  -g, --grader      Path to grader (.ts/.js module or executable script)
-  -h, --help        Show this help message
-
-Output Format:
-  Full trajectory JSONL with toolErrors indicator.
-  Use 'acp-harness summarize' to derive compact views.
-
-Graders:
-  TS/JS modules must export a 'grade' function.
-  Executable scripts (Python, etc.) use stdin/stdout JSON protocol.
-
-Examples:
-  # Basic capture
-  acp-harness capture prompts.jsonl bunx claude-code-acp -o results.jsonl
-
-  # With TypeScript grader
-  acp-harness capture prompts.jsonl bunx claude-code-acp --grader ./grader.ts -o results.jsonl
-
-  # With Python grader
-  acp-harness capture prompts.jsonl bunx claude-code-acp --grader ./grader.py -o results.jsonl
-`)
-    return
-  }
-
-  const promptsPath = positionals[0]
-  if (!promptsPath) {
-    console.error('Error: prompts.jsonl path is required')
-    process.exit(1)
-  }
-
-  const agentCommand = positionals.slice(1)
-  if (agentCommand.length === 0) {
-    console.error('Error: ACP agent command is required')
-    console.error('Example: acp-harness capture prompts.jsonl bunx claude-code-acp')
-    process.exit(1)
-  }
-
-  // Load grader if specified
-  let grader: Grader | undefined
-  if (values.grader) {
-    try {
-      grader = await loadGrader(values.grader)
-    } catch (error) {
-      console.error(`Error: ${error instanceof Error ? error.message : error}`)
-      process.exit(1)
-    }
-  }
-
-  await runCapture({
-    promptsPath,
-    agentCommand,
-    outputPath: values.output,
-    cwd: values.cwd,
-    timeout: Number.parseInt(values.timeout ?? String(DEFAULT_HARNESS_TIMEOUT), 10),
-    progress: values.progress ?? false,
-    append: values.append ?? false,
-    grader,
-  })
-}
diff --git a/src/commands.ts b/src/commands.ts
new file mode 100644
index 0000000..cd1969c
--- /dev/null
+++ b/src/commands.ts
@@ -0,0 +1,33 @@
+/**
+ * CLI command implementations for agent evaluation harness.
+ *
+ * @remarks
+ * Re-exports all CLI commands for programmatic use.
+ * For CLI usage, run `agent-eval-harness <command> --help`.
+ *
+ * @packageDocumentation
+ */
+
+// Balance command
+export type { BalanceConfig } from './commands/balance.ts'
+export { balance, runBalance } from './commands/balance.ts'
+
+// Calibrate command
+export type { CalibrateConfig } from './commands/calibrate.ts'
+export { calibrate, runCalibrate } from './commands/calibrate.ts'
+
+// Capture command
+export type { CaptureConfig } from './commands/capture.ts'
+export { capture, runCapture } from './commands/capture.ts'
+
+// Summarize command
+export type { SummarizeConfig } from './commands/summarize.ts'
+export { runSummarize, summarize } from './commands/summarize.ts'
+
+// Trials command
+export type { TrialsConfig } from './commands/trials.ts'
+export { runTrials, trials } from './commands/trials.ts'
+
+// Validate-refs command
+export type { ValidateRefsConfig } from './commands/validate-refs.ts'
+export { runValidateRefs, validateRefs } from './commands/validate-refs.ts'
diff --git a/src/balance.ts b/src/commands/balance.ts
similarity index 97%
rename from src/balance.ts
rename to src/commands/balance.ts
index 0e7ef4c..fb53a8c 100644
--- a/src/balance.ts
+++ b/src/commands/balance.ts
@@ -9,8 +9,8 @@
  */
 
 import { parseArgs } from 'node:util'
+import type { BalanceAnalysis, CategoryDistribution, PromptCase } from '../schemas.ts'
 import { loadPrompts } from './capture.ts'
-import type { BalanceAnalysis, CategoryDistribution, PromptCase } from './schemas.ts'
 
 // ============================================================================
 // Types
@@ -218,7 +218,7 @@ export const balance = async (args: string[]): Promise<void> => {
   if (values.help) {
     // biome-ignore lint/suspicious/noConsole: CLI help output
     console.log(`
-Usage: acp-harness balance <prompts.jsonl> [options]
+Usage: agent-eval-harness balance <prompts.jsonl> [options]
 
 Arguments:
   prompts.jsonl     Input file with prompts
@@ -234,10 +234,10 @@ Output:
 
 Examples:
   # Analyze by default 'category' key
-  acp-harness balance prompts.jsonl -o balance.json
+  agent-eval-harness balance prompts.jsonl -o balance.json
 
   # Analyze by custom metadata key
-  acp-harness balance prompts.jsonl --key difficulty -o balance.json
+  agent-eval-harness balance prompts.jsonl --key difficulty -o balance.json
 `)
     return
   }
diff --git a/src/calibrate.ts b/src/commands/calibrate.ts
similarity index 87%
rename from src/calibrate.ts
rename to src/commands/calibrate.ts
index 068c068..38f0004 100644
--- a/src/calibrate.ts
+++ b/src/commands/calibrate.ts
@@ -9,10 +9,10 @@
  */
 
 import { parseArgs } from 'node:util'
-import { DEFAULT_CALIBRATION_SAMPLE_SIZE } from './constants.ts'
-import { loadGrader } from './grader-loader.ts'
-import type { CalibrationSample, CaptureResult, Grader, GraderResult, TrajectoryStep } from './schemas.ts'
-import { CaptureResultSchema } from './schemas.ts'
+import { loadResults, resolvePath } from '../core.ts'
+import { DEFAULT_CALIBRATION_SAMPLE_SIZE } from '../schemas/constants.ts'
+import { loadGrader } from '../schemas/grader-loader.ts'
+import type { CalibrationSample, Grader, GraderResult, TrajectoryStep } from '../schemas.ts'
 
 // ============================================================================
 // Types
@@ -30,32 +30,6 @@ export type CalibrateConfig = {
   grader?: Grader
 }
 
-// ============================================================================
-// Helpers
-// ============================================================================
-
-/** Resolve path relative to process.cwd() */
-const resolvePath = (path: string): string => {
-  if (path.startsWith('/')) return path
-  return `${process.cwd()}/${path}`
-}
-
-/** Load capture results from JSONL file */
-const loadResults = async (path: string): Promise<CaptureResult[]> => {
-  const content = await Bun.file(path).text()
-  return content
-    .trim()
-    .split('\n')
-    .filter(Boolean)
-    .map((line, index) => {
-      try {
-        return CaptureResultSchema.parse(JSON.parse(line))
-      } catch (error) {
-        throw new Error(`Invalid result at line ${index + 1}: ${error instanceof Error ? error.message : error}`)
-      }
-    })
-}
-
 /**
  * Randomly sample n elements from an array using Fisher-Yates shuffle.
  *
@@ -288,7 +262,7 @@ export const calibrate = async (args: string[]): Promise<void> => {
   if (values.help) {
     // biome-ignore lint/suspicious/noConsole: CLI help output
     console.log(`
-Usage: acp-harness calibrate <results.jsonl> [options]
+Usage: agent-eval-harness calibrate <results.jsonl> [options]
 
 Arguments:
   results.jsonl     Input file with scored capture results
@@ -305,10 +279,10 @@ Output:
 
 Examples:
   # Sample failures for review
-  acp-harness calibrate results.jsonl --sample 10 -o calibration.md
+  agent-eval-harness calibrate results.jsonl --sample 10 -o calibration.md
 
   # Re-score with different grader to compare
-  acp-harness calibrate results.jsonl --grader ./loose-grader.ts -o comparison.md
+  agent-eval-harness calibrate results.jsonl --grader ./loose-grader.ts -o comparison.md
 `)
     return
   }
diff --git a/src/commands/capture.ts b/src/commands/capture.ts
new file mode 100644
index 0000000..399f620
--- /dev/null
+++ b/src/commands/capture.ts
@@ -0,0 +1,393 @@
+/**
+ * Core trajectory capture command.
+ *
+ * @remarks
+ * Executes prompts against a CLI agent and captures full trajectories.
+ * This is the foundational command - all other views derive from its output.
+ *
+ * Output format is always full trajectory JSONL (`CaptureResultSchema`).
+ * Use `summarize` command to derive compact views.
+ *
+ * @packageDocumentation
+ */
+
+import { parseArgs } from 'node:util'
+import {
+  detectTrajectoryRichness,
+  extractOutput,
+  extractTrajectory,
+  getInputPreview,
+  hasToolErrors,
+  loadPrompts,
+  logProgress,
+  resolvePath,
+  writeOutput,
+} from '../core.ts'
+import { type HeadlessAdapterConfig, parseHeadlessConfig } from '../headless/headless.schemas.ts'
+import type { ParsedUpdate } from '../headless/headless-output-parser.ts'
+import { createSessionManager, type ProcessExitInfo, type PromptResult } from '../headless/headless-session-manager.ts'
+import { DEFAULT_HARNESS_TIMEOUT } from '../schemas/constants.ts'
+import { loadGrader } from '../schemas/grader-loader.ts'
+import type { CaptureResult, Grader, TrajectoryRichness } from '../schemas.ts'
+
+// ============================================================================
+// Re-exports for backward compatibility
+// ============================================================================
+
+// These functions are now in core/ but re-exported here for existing consumers
+export {
+  detectTrajectoryRichness,
+  extractContent,
+  extractFilePath,
+  extractOutput,
+  extractTrajectory,
+  hasToolErrors,
+  headTailPreview,
+  loadPrompts,
+} from '../core.ts'
+
+// ============================================================================
+// Types
+// ============================================================================
+
+/** Configuration for capture command */
+export type CaptureConfig = {
+  /** Path to prompts.jsonl file */
+  promptsPath: string
+  /** Path to agent schema JSON file */
+  schemaPath: string
+  /** Output file path (undefined for stdout) */
+  outputPath?: string
+  /** Working directory for agent */
+  cwd?: string
+  /** Timeout per prompt in milliseconds (overrides schema default) */
+  timeout?: number
+  /** Show progress to stderr */
+  progress?: boolean
+  /** Append to output file instead of overwriting */
+  append?: boolean
+  /** Optional grader function */
+  grader?: Grader
+  /** Enable debug mode for detailed output */
+  debug?: boolean
+}
+
+// ============================================================================
+// Capture Implementation
+// ============================================================================
+
+/**
+ * Execute capture with configuration object.
+ *
+ * @remarks
+ * Creates a fresh session for each JSONL entry to ensure isolation.
+ * Supports multi-turn conversations via `input: string[]`.
+ *
+ * @param config - Capture configuration
+ * @returns Array of capture results
+ */
+export const runCapture = async (config: CaptureConfig): Promise<CaptureResult[]> => {
+  const {
+    promptsPath,
+    schemaPath,
+    outputPath,
+    cwd,
+    timeout,
+    progress = false,
+    append = false,
+    grader,
+    debug = false,
+  } = config
+
+  // Load and validate schema
+  const schemaFile = Bun.file(schemaPath)
+  if (!(await schemaFile.exists())) {
+    throw new Error(`Schema file not found: ${schemaPath}`)
+  }
+
+  let schema: HeadlessAdapterConfig
+  try {
+    const rawSchema = await schemaFile.json()
+    schema = parseHeadlessConfig(rawSchema)
+  } catch (error) {
+    throw new Error(`Invalid schema: ${error instanceof Error ? error.message : String(error)}`)
+  }
+
+  // Load prompts
+  const prompts = await loadPrompts(promptsPath)
+
+  // Resolve output path
+  const resolvedOutputPath = outputPath ? resolvePath(outputPath) : undefined
+
+  // Determine effective timeout (CLI flag > schema default > harness default)
+  const schemaTimeout = 'timeout' in schema ? schema.timeout : undefined
+  const effectiveTimeout = timeout ?? schemaTimeout ?? DEFAULT_HARNESS_TIMEOUT
+
+  // Log progress info
+  logProgress(`Loaded ${prompts.length} prompts from ${promptsPath}`, progress)
+  logProgress(`Schema: ${schema.name} (${schemaPath})`, progress)
+  logProgress(`Timeout: ${effectiveTimeout}ms`, progress)
+  if (resolvedOutputPath) {
+    logProgress(`Output: ${resolvedOutputPath}`, progress)
+  }
+  if (debug) {
+    logProgress(`Debug mode: enabled`, progress)
+  }
+
+  // Create session manager with schema
+  const sessions = createSessionManager({
+    schema,
+    timeout: effectiveTimeout,
+    verbose: progress,
+    debug,
+  })
+
+  // Clear output file if not appending
+  if (resolvedOutputPath && !append) {
+    await Bun.write(resolvedOutputPath, '')
+  }
+
+  const workingDir = cwd ?? process.cwd()
+  const results: CaptureResult[] = []
+  let isFirstOutput = true
+
+  // Run evaluations sequentially - fresh session per entry
+  for (let i = 0; i < prompts.length; i++) {
+    const promptCase = prompts[i]
+    if (!promptCase) continue
+
+    logProgress(`[${i + 1}/${prompts.length}] ${promptCase.id}: ${getInputPreview(promptCase.input)}...`, progress)
+
+    const startTime = Date.now()
+    let result: CaptureResult
+
+    try {
+      // Create fresh session for each entry (ensures isolation)
+      const sessionStart = Date.now()
+      const session = await sessions.create(workingDir)
+      const sessionCreation = Date.now() - sessionStart
+      logProgress(`  Session: ${session.id}`, progress)
+
+      // Handle string or array input
+      const inputs = Array.isArray(promptCase.input) ? promptCase.input : [promptCase.input]
+      const turnCount = inputs.length
+
+      // Collect all updates from all turns
+      const allUpdates: ParsedUpdate[] = []
+      let lastExitInfo: ProcessExitInfo | undefined
+      let lastOutput = ''
+
+      // TODO: Per-prompt timeout from promptCase.timeout is documented but not yet implemented
+      // The session manager would need to accept timeout per-call to support this
+
+      // Execute each turn sequentially in the same session
+      for (const turnInput of inputs) {
+        const turnResult: PromptResult = await sessions.prompt(session.id, turnInput)
+        allUpdates.push(...turnResult.updates)
+        lastExitInfo = turnResult.exitInfo
+        lastOutput = turnResult.output
+      }
+
+      const endTime = Date.now()
+      const trajectory = extractTrajectory(allUpdates, startTime)
+
+      // Use last turn's output or extract from trajectory
+      const output = lastOutput || extractOutput(trajectory)
+      const toolErrors = hasToolErrors(trajectory) || (lastExitInfo?.timedOut ?? false)
+      const trajectoryRichness = detectTrajectoryRichness(trajectory)
+
+      result = {
+        id: promptCase.id,
+        input: promptCase.input, // Preserve original (string or array)
+        output,
+        ...(promptCase.hint && { hint: promptCase.hint }),
+        trajectory,
+        metadata: {
+          ...promptCase.metadata,
+          agent: schema.name,
+          trajectoryRichness,
+          turnCount,
+          ...(lastExitInfo && {
+            exitCode: lastExitInfo.exitCode,
+            signal: lastExitInfo.signal,
+            timedOut: lastExitInfo.timedOut,
+          }),
+        },
+        timing: {
+          start: startTime,
+          end: endTime,
+          firstResponse: trajectory.length > 0 ? trajectory[0]?.timestamp : undefined,
+          sessionCreation,
+          total: endTime - startTime,
+        },
+        toolErrors,
+      }
+
+      // Apply grader if provided
+      if (grader) {
+        result.score = await grader({
+          input: promptCase.input,
+          output,
+          hint: promptCase.hint,
+          trajectory,
+        })
+      }
+
+      // Clean up session
+      sessions.destroy(session.id)
+    } catch (error) {
+      const endTime = Date.now()
+      const message = error instanceof Error ? error.message : String(error)
+      const inputs = Array.isArray(promptCase.input) ? promptCase.input : [promptCase.input]
+
+      result = {
+        id: promptCase.id,
+        input: promptCase.input,
+        output: '',
+        trajectory: [],
+        metadata: {
+          ...promptCase.metadata,
+          agent: schema.name,
+          trajectoryRichness: 'minimal' as TrajectoryRichness,
+          turnCount: inputs.length,
+        },
+        timing: {
+          start: startTime,
+          end: endTime,
+          sessionCreation: 0,
+          total: endTime - startTime,
+        },
+        toolErrors: true,
+        errors: [message],
+      }
+    }
+
+    results.push(result)
+
+    // Write result immediately
+    const formatted = JSON.stringify(result)
+    await writeOutput(formatted, resolvedOutputPath, !isFirstOutput)
+    isFirstOutput = false
+
+    const statusIcon = result.toolErrors ? '!' : '✓'
+    const exitInfo = result.metadata?.timedOut
+      ? ' - TIMEOUT'
+      : result.metadata?.exitCode && result.metadata.exitCode !== 0
+        ? ` - exit ${result.metadata.exitCode}`
+        : ''
+    logProgress(`  ${statusIcon} (${result.timing.total}ms)${exitInfo}`, progress)
+  }
+
+  logProgress('Done!', progress)
+  return results
+}
+
+// ============================================================================
+// CLI Entry Point
+// ============================================================================
+
+/**
+ * Capture command CLI handler.
+ *
+ * @param args - Command line arguments (after 'capture')
+ */
+export const capture = async (args: string[]): Promise<void> => {
+  const { values, positionals } = parseArgs({
+    args,
+    options: {
+      schema: { type: 'string', short: 's' },
+      output: { type: 'string', short: 'o' },
+      cwd: { type: 'string', short: 'c' },
+      timeout: { type: 'string', short: 't' },
+      progress: { type: 'boolean', default: false },
+      append: { type: 'boolean', default: false },
+      grader: { type: 'string', short: 'g' },
+      debug: { type: 'boolean', default: false },
+      help: { type: 'boolean', short: 'h' },
+    },
+    allowPositionals: true,
+  })
+
+  if (values.help) {
+    // biome-ignore lint/suspicious/noConsole: CLI help output
+    console.log(`
+Usage: agent-eval-harness capture <prompts.jsonl> --schema <schema.json> [options]
+
+Arguments:
+  prompts.jsonl     Input file with evaluation prompts
+
+Options:
+  -s, --schema      Path to agent schema JSON file (required)
+  -o, --output      Output file (default: stdout)
+  -c, --cwd         Working directory for agent
+  -t, --timeout     Request timeout in ms (overrides schema default)
+  --progress        Show progress to stderr
+  --append          Append to output file instead of overwriting
+  -g, --grader      Path to grader (.ts/.js module or executable script)
+  --debug           Enable debug mode (shows raw output, JSONPath matching)
+  -h, --help        Show this help message
+
+Output Format:
+  Full trajectory JSONL with toolErrors indicator.
+  Use 'agent-eval-harness summarize' to derive compact views.
+
+Exit Info (in metadata):
+  exitCode      Process exit code (null if killed/timed out)
+  signal        Signal that killed process (if any)
+  timedOut      true if process was killed due to timeout
+
+Graders:
+  TS/JS modules must export a 'grade' function.
+  Executable scripts (Python, etc.) use stdin/stdout JSON protocol.
+
+Examples:
+  # Basic capture with schema
+  agent-eval-harness capture prompts.jsonl --schema claude.json -o results.jsonl
+
+  # With TypeScript grader
+  agent-eval-harness capture prompts.jsonl -s claude.json --grader ./grader.ts -o results.jsonl
+
+  # With debug mode
+  agent-eval-harness capture prompts.jsonl -s claude.json --debug -o results.jsonl
+
+  # With per-prompt timeout override (in prompts.jsonl):
+  {"id": "slow-task", "input": "...", "timeout": 180000}
+`)
+    return
+  }
+
+  const promptsPath = positionals[0]
+  if (!promptsPath) {
+    console.error('Error: prompts.jsonl path is required')
+    process.exit(1)
+  }
+
+  if (!values.schema) {
+    console.error('Error: --schema is required')
+    console.error('Example: agent-eval-harness capture prompts.jsonl --schema ./claude.json')
+    process.exit(1)
+  }
+
+  // Load grader if specified
+  let grader: Grader | undefined
+  if (values.grader) {
+    try {
+      grader = await loadGrader(values.grader)
+    } catch (error) {
+      console.error(`Error: ${error instanceof Error ? error.message : error}`)
+      process.exit(1)
+    }
+  }
+
+  await runCapture({
+    promptsPath,
+    schemaPath: values.schema,
+    outputPath: values.output,
+    cwd: values.cwd,
+    timeout: values.timeout ? Number.parseInt(values.timeout, 10) : undefined,
+    progress: values.progress ?? false,
+    append: values.append ?? false,
+    grader,
+    debug: values.debug ?? false,
+  })
+}
diff --git a/src/summarize.ts b/src/commands/summarize.ts
similarity index 84%
rename from src/summarize.ts
rename to src/commands/summarize.ts
index 1bbd62d..5709e55 100644
--- a/src/summarize.ts
+++ b/src/commands/summarize.ts
@@ -10,10 +10,9 @@
  */
 
 import { parseArgs } from 'node:util'
-import { extractContent, extractFilePath, headTailPreview } from './capture.ts'
-import { HEAD_LINES, MAX_CONTENT_LENGTH, TAIL_LINES } from './constants.ts'
-import type { CaptureResult, SummaryResult } from './schemas.ts'
-import { CaptureResultSchema } from './schemas.ts'
+import { extractContent, extractFilePath, headTailPreview, loadResults, resolvePath } from '../core.ts'
+import { HEAD_LINES, MAX_CONTENT_LENGTH, TAIL_LINES } from '../schemas/constants.ts'
+import type { CaptureResult, SummaryResult } from '../schemas.ts'
 
 // ============================================================================
 // Types
@@ -29,32 +28,6 @@ export type SummarizeConfig = {
   markdown?: boolean
 }
 
-// ============================================================================
-// Helpers
-// ============================================================================
-
-/** Resolve path relative to process.cwd() */
-const resolvePath = (path: string): string => {
-  if (path.startsWith('/')) return path
-  return `${process.cwd()}/${path}`
-}
-
-/** Load capture results from JSONL file */
-const loadResults = async (path: string): Promise<CaptureResult[]> => {
-  const content = await Bun.file(path).text()
-  return content
-    .trim()
-    .split('\n')
-    .filter(Boolean)
-    .map((line, index) => {
-      try {
-        return CaptureResultSchema.parse(JSON.parse(line))
-      } catch (error) {
-        throw new Error(`Invalid result at line ${index + 1}: ${error instanceof Error ? error.message : error}`)
-      }
-    })
-}
-
 /**
  * Format capture result as compact summary.
  *
@@ -217,7 +190,7 @@ export const summarize = async (args: string[]): Promise<void> => {
   if (values.help) {
     // biome-ignore lint/suspicious/noConsole: CLI help output
     console.log(`
-Usage: acp-harness summarize <results.jsonl> [options]
+Usage: agent-eval-harness summarize <results.jsonl> [options]
 
 Arguments:
   results.jsonl     Input file with capture results
@@ -233,10 +206,10 @@ Output Formats:
 
 Examples:
   # Summary JSONL for jq analysis
-  acp-harness summarize results.jsonl -o summary.jsonl
+  agent-eval-harness summarize results.jsonl -o summary.jsonl
 
   # Markdown for LLM evaluation
-  acp-harness summarize results.jsonl --markdown -o results.md
+  agent-eval-harness summarize results.jsonl --markdown -o results.md
 `)
     return
   }
diff --git a/src/tests/balance-helpers.spec.ts b/src/commands/tests/balance-helpers.spec.ts
similarity index 99%
rename from src/tests/balance-helpers.spec.ts
rename to src/commands/tests/balance-helpers.spec.ts
index 8590911..6641c34 100644
--- a/src/tests/balance-helpers.spec.ts
+++ b/src/commands/tests/balance-helpers.spec.ts
@@ -1,6 +1,6 @@
 import { describe, expect, test } from 'bun:test'
+import type { CategoryDistribution, PromptCase } from '../../schemas.ts'
 import { analyzeCategories, findUnderrepresented, generateSuggestions } from '../balance.ts'
-import type { CategoryDistribution, PromptCase } from '../schemas.ts'
 
 // ============================================================================
 // analyzeCategories
diff --git a/src/tests/calibrate-helpers.spec.ts b/src/commands/tests/calibrate-helpers.spec.ts
similarity index 99%
rename from src/tests/calibrate-helpers.spec.ts
rename to src/commands/tests/calibrate-helpers.spec.ts
index 64738da..becdff1 100644
--- a/src/tests/calibrate-helpers.spec.ts
+++ b/src/commands/tests/calibrate-helpers.spec.ts
@@ -1,6 +1,6 @@
 import { describe, expect, test } from 'bun:test'
+import type { TrajectoryStep } from '../../schemas.ts'
 import { getTrajectorySnippet, sampleArray } from '../calibrate.ts'
-import type { TrajectoryStep } from '../schemas.ts'
 
 // ============================================================================
 // sampleArray
diff --git a/src/tests/capture-cli.spec.ts b/src/commands/tests/capture-cli.spec.ts
similarity index 91%
rename from src/tests/capture-cli.spec.ts
rename to src/commands/tests/capture-cli.spec.ts
index bc19d62..ebd751c 100644
--- a/src/tests/capture-cli.spec.ts
+++ b/src/commands/tests/capture-cli.spec.ts
@@ -7,7 +7,7 @@ import { loadPrompts } from '../capture.ts'
 // ============================================================================
 
 describe('loadPrompts', () => {
-  const testPromptFile = '/tmp/acp-harness-test-prompts.jsonl'
+  const testPromptFile = '/tmp/agent-eval-harness-test-prompts.jsonl'
 
   beforeEach(async () => {
     await Bun.$`rm -f ${testPromptFile}`.nothrow()
@@ -110,22 +110,23 @@ describe('runCapture configuration', () => {
     // Type-level test - if this compiles, the types are correct
     const config: CaptureConfig = {
       promptsPath: '/tmp/prompts.jsonl',
-      agentCommand: ['bunx', 'test-agent'],
+      schemaPath: './schemas/claude-headless.json',
       outputPath: '/tmp/output.jsonl',
       cwd: '/tmp',
       timeout: 30000,
       progress: true,
       append: false,
+      debug: false,
     }
 
     expect(config.promptsPath).toBe('/tmp/prompts.jsonl')
-    expect(config.agentCommand).toEqual(['bunx', 'test-agent'])
+    expect(config.schemaPath).toBe('./schemas/claude-headless.json')
   })
 
   test('CaptureConfig allows minimal configuration', () => {
     const config: CaptureConfig = {
       promptsPath: '/tmp/prompts.jsonl',
-      agentCommand: ['echo', 'test'],
+      schemaPath: './test-schema.json',
     }
 
     expect(config.outputPath).toBeUndefined()
@@ -151,13 +152,14 @@ describe('capture CLI', () => {
     const stdout = await new Response(proc.stdout).text()
     await proc.exited
 
-    expect(stdout).toContain('Usage: acp-harness capture')
+    expect(stdout).toContain('Usage: agent-eval-harness capture')
     expect(stdout).toContain('prompts.jsonl')
     expect(stdout).toContain('-o, --output')
     expect(stdout).toContain('-c, --cwd')
     expect(stdout).toContain('-t, --timeout')
     expect(stdout).toContain('--progress')
     expect(stdout).toContain('-g, --grader')
+    expect(stdout).toContain('-s, --schema')
   })
 
   test('shows error for missing prompts file argument', async () => {
@@ -173,7 +175,7 @@ describe('capture CLI', () => {
     expect(stderr).toContain('prompts.jsonl path is required')
   })
 
-  test('shows error for missing agent command', async () => {
+  test('shows error for missing schema argument', async () => {
     const proc = Bun.spawn(['bun', './bin/cli.ts', 'capture', '/tmp/prompts.jsonl'], {
       stdout: 'pipe',
       stderr: 'pipe',
@@ -183,6 +185,6 @@ describe('capture CLI', () => {
     const exitCode = await proc.exited
 
     expect(exitCode).not.toBe(0)
-    expect(stderr).toContain('ACP agent command is required')
+    expect(stderr).toContain('--schema is required')
   })
 })
diff --git a/src/tests/capture-helpers.spec.ts b/src/commands/tests/capture-helpers.spec.ts
similarity index 61%
rename from src/tests/capture-helpers.spec.ts
rename to src/commands/tests/capture-helpers.spec.ts
index 6b664d1..5995115 100644
--- a/src/tests/capture-helpers.spec.ts
+++ b/src/commands/tests/capture-helpers.spec.ts
@@ -1,17 +1,16 @@
 import { describe, expect, test } from 'bun:test'
-import type { SessionNotification } from '@agentclientprotocol/sdk'
+import type { ParsedUpdate } from '../../headless/headless-output-parser.ts'
+import type { TrajectoryStep } from '../../schemas.ts'
 import {
   detectTrajectoryRichness,
   extractContent,
   extractFilePath,
   extractOutput,
-  extractTokenCounts,
   extractTrajectory,
   hasToolErrors,
   headTailPreview,
   loadPrompts,
 } from '../capture.ts'
-import type { TrajectoryStep } from '../schemas.ts'
 
 // ============================================================================
 // loadPrompts
@@ -104,176 +103,106 @@ describe('loadPrompts', () => {
 describe('extractTrajectory', () => {
   const baseTime = 0
 
-  test('extracts thoughts from agent_thought_chunk notifications', () => {
-    const notifications: SessionNotification[] = [
+  test('extracts thoughts from thought type updates', () => {
+    const updates: ParsedUpdate[] = [
       {
-        sessionId: 's1',
-        update: {
-          sessionUpdate: 'agent_thought_chunk',
-          content: { type: 'text', text: 'Let me think about this...' },
-        },
+        type: 'thought',
+        content: 'Let me think about this...',
+        raw: { type: 'thought', text: 'Let me think about this...' },
       },
     ]
 
-    const trajectory = extractTrajectory(notifications, baseTime)
+    const trajectory = extractTrajectory(updates, baseTime)
 
     expect(trajectory).toHaveLength(1)
     expect(trajectory[0]?.type).toBe('thought')
-    // Type narrowing after explicit assertion
     const step = trajectory[0]!
     expect(step.type === 'thought' && step.content).toBe('Let me think about this...')
   })
 
-  test('extracts messages from agent_message_chunk notifications', () => {
-    const notifications: SessionNotification[] = [
+  test('extracts messages from message type updates', () => {
+    const updates: ParsedUpdate[] = [
       {
-        sessionId: 's1',
-        update: {
-          sessionUpdate: 'agent_message_chunk',
-          content: { type: 'text', text: 'Here is my answer.' },
-        },
+        type: 'message',
+        content: 'Here is my answer.',
+        raw: { type: 'message', text: 'Here is my answer.' },
       },
     ]
 
-    const trajectory = extractTrajectory(notifications, baseTime)
+    const trajectory = extractTrajectory(updates, baseTime)
 
     expect(trajectory).toHaveLength(1)
     expect(trajectory[0]?.type).toBe('message')
-    // Type narrowing after explicit assertion
     const step = trajectory[0]!
     expect(step.type === 'message' && step.content).toBe('Here is my answer.')
   })
 
-  test('extracts tool calls with initial pending status', () => {
-    const notifications: SessionNotification[] = [
+  test('extracts tool calls with title and status', () => {
+    const updates: ParsedUpdate[] = [
       {
-        sessionId: 's1',
-        update: {
-          sessionUpdate: 'tool_call',
-          toolCallId: 't1',
-          title: 'Read',
-          status: 'pending',
-          rawInput: '{"file_path": "/test.ts"}',
-        },
+        type: 'tool_call',
+        title: 'Read',
+        status: 'pending',
+        raw: { tool: 'Read', input: { file_path: '/test.ts' } },
       },
     ]
 
-    const trajectory = extractTrajectory(notifications, baseTime)
+    const trajectory = extractTrajectory(updates, baseTime)
 
     expect(trajectory).toHaveLength(1)
     expect(trajectory[0]?.type).toBe('tool_call')
-    // Type narrowing after explicit assertion
     const step = trajectory[0]!
     expect(step.type === 'tool_call' && step.name).toBe('Read')
     expect(step.type === 'tool_call' && step.status).toBe('pending')
-    expect(step.type === 'tool_call' && step.input).toBe('{"file_path": "/test.ts"}')
-  })
-
-  test('updates tool call status on subsequent notifications', () => {
-    const notifications: SessionNotification[] = [
-      {
-        sessionId: 's1',
-        update: {
-          sessionUpdate: 'tool_call',
-          toolCallId: 't1',
-          title: 'Read',
-          status: 'pending',
-        },
-      },
-      {
-        sessionId: 's1',
-        update: {
-          sessionUpdate: 'tool_call',
-          toolCallId: 't1',
-          title: 'Read',
-          status: 'completed',
-          rawOutput: 'file contents here',
-        },
-      },
-    ]
-
-    const trajectory = extractTrajectory(notifications, baseTime)
-
-    // Should still be 1 entry, just updated
-    expect(trajectory).toHaveLength(1)
-    expect(trajectory[0]?.type).toBe('tool_call')
-    // Type narrowing after explicit assertion
-    const step = trajectory[0]!
-    expect(step.type === 'tool_call' && step.status).toBe('completed')
-    expect(step.type === 'tool_call' && step.output).toBe('file contents here')
-  })
-
-  test('tracks multiple independent tool calls', () => {
-    const notifications: SessionNotification[] = [
-      {
-        sessionId: 's1',
-        update: { sessionUpdate: 'tool_call', toolCallId: 't1', title: 'Read', status: 'completed' },
-      },
-      {
-        sessionId: 's1',
-        update: { sessionUpdate: 'tool_call', toolCallId: 't2', title: 'Write', status: 'completed' },
-      },
-    ]
-
-    const trajectory = extractTrajectory(notifications, baseTime)
-
-    expect(trajectory).toHaveLength(2)
-    expect(trajectory[0]?.type).toBe('tool_call')
-    expect(trajectory[1]?.type).toBe('tool_call')
-    // Type narrowing after explicit assertions
-    const step0 = trajectory[0]!
-    const step1 = trajectory[1]!
-    expect(step0.type === 'tool_call' && step0.name).toBe('Read')
-    expect(step1.type === 'tool_call' && step1.name).toBe('Write')
   })
 
-  test('extracts plan entries', () => {
-    const notifications: SessionNotification[] = [
+  test('extracts plan type updates', () => {
+    const updates: ParsedUpdate[] = [
       {
-        sessionId: 's1',
-        update: {
-          sessionUpdate: 'plan',
+        type: 'plan',
+        raw: {
           entries: [
-            { content: 'Step 1', status: 'completed', priority: 'high' },
-            { content: 'Step 2', status: 'in_progress', priority: 'medium' },
+            { content: 'Step 1', status: 'completed' },
+            { content: 'Step 2', status: 'in_progress' },
           ],
         },
       },
     ]
 
-    const trajectory = extractTrajectory(notifications, baseTime)
+    const trajectory = extractTrajectory(updates, baseTime)
 
     expect(trajectory).toHaveLength(1)
     expect(trajectory[0]?.type).toBe('plan')
-    // Type narrowing after explicit assertion
+    // Note: extractTrajectory creates plan entries from the update type
+    // but doesn't extract entries from raw (they are captured via output parser mappings)
     const step = trajectory[0]!
-    expect(step.type === 'plan' && step.entries).toHaveLength(2)
+    expect(step.type === 'plan').toBe(true)
   })
 
-  test('handles empty notifications', () => {
+  test('handles empty updates', () => {
     const trajectory = extractTrajectory([], baseTime)
     expect(trajectory).toEqual([])
   })
 
   test('assigns timestamps relative to start time', () => {
-    // Mock Date.now to control timestamps
     const originalNow = Date.now
     try {
       let currentTime = 1000
 
       Date.now = () => currentTime
 
-      const notifications: SessionNotification[] = [
+      const updates: ParsedUpdate[] = [
         {
-          sessionId: 's1',
-          update: { sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: 'First' } },
+          type: 'message',
+          content: 'First',
+          raw: { type: 'message', text: 'First' },
         },
       ]
 
       const startTime = 1000
       currentTime = 1500 // 500ms later
 
-      const trajectory = extractTrajectory(notifications, startTime)
+      const trajectory = extractTrajectory(updates, startTime)
 
       expect(trajectory[0]?.timestamp).toBe(500)
     } finally {
@@ -281,65 +210,26 @@ describe('extractTrajectory', () => {
     }
   })
 
-  test('calculates tool call duration correctly', () => {
-    const originalNow = Date.now
-    try {
-      let currentTime = 1000
-
-      Date.now = () => currentTime
-
-      const startTime = 1000
-
-      // Simulate time passing between notifications
-      // First notification at t=100 (currentTime = 1100)
-      // Second notification at t=600 (currentTime = 1600)
-      const notifications: SessionNotification[] = []
-
-      currentTime = 1100 // First call at 100ms relative to start
-      notifications.push({
-        sessionId: 's1',
-        update: { sessionUpdate: 'tool_call', toolCallId: 't1', title: 'Bash', status: 'pending' },
-      })
-
-      currentTime = 1600 // Second call at 600ms relative to start
-      notifications.push({
-        sessionId: 's1',
-        update: { sessionUpdate: 'tool_call', toolCallId: 't1', title: 'Bash', status: 'completed' },
-      })
-
-      // Now process all notifications in one call
-      // But the issue is extractTrajectory calls Date.now() for each notification
-      // so we need to mock it to return different values for each call
-
-      let callCount = 0
-      const times = [1100, 1600]
-      Date.now = () => times[callCount++] ?? 1600
-
-      const trajectory = extractTrajectory(notifications, startTime)
-
-      expect(trajectory[0]?.type).toBe('tool_call')
-      // Type narrowing after explicit assertion - Duration should be 500ms (600 - 100)
-      const step = trajectory[0]!
-      expect(step.type === 'tool_call' && step.duration).toBe(500)
-    } finally {
-      Date.now = originalNow
-    }
-  })
-
-  test('ignores non-text content in thought chunks', () => {
-    const notifications: SessionNotification[] = [
+  test('handles updates without content for message/thought types', () => {
+    const updates: ParsedUpdate[] = [
       {
-        sessionId: 's1',
-        update: {
-          sessionUpdate: 'agent_thought_chunk',
-          // Image content should be skipped
-          content: { type: 'image', data: 'base64', mimeType: 'image/png' },
-        },
+        type: 'message',
+        content: undefined, // No content - will have empty string
+        raw: { type: 'message' },
+      },
+      {
+        type: 'message',
+        content: 'Has content',
+        raw: { type: 'message', text: 'Has content' },
       },
     ]
 
-    const trajectory = extractTrajectory(notifications, baseTime)
-    expect(trajectory).toHaveLength(0)
+    const trajectory = extractTrajectory(updates, baseTime)
+
+    // Both messages are included - ones without content get empty string
+    expect(trajectory).toHaveLength(2)
+    expect(trajectory[0]?.type).toBe('message')
+    expect(trajectory[1]?.type).toBe('message')
   })
 })
 
@@ -632,84 +522,3 @@ describe('detectTrajectoryRichness', () => {
     expect(detectTrajectoryRichness(trajectory)).toBe('full')
   })
 })
-
-// ============================================================================
-// extractTokenCounts
-// ============================================================================
-
-describe('extractTokenCounts', () => {
-  test('returns undefined when no usage data present', () => {
-    const updates: SessionNotification[] = [
-      {
-        sessionId: 's1',
-        update: { sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: 'Hello' } },
-      },
-    ]
-
-    const result = extractTokenCounts(updates)
-
-    expect(result.inputTokens).toBeUndefined()
-    expect(result.outputTokens).toBeUndefined()
-  })
-
-  test('extracts token counts from usage field when present', () => {
-    const updates: SessionNotification[] = [
-      {
-        sessionId: 's1',
-        update: { sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: 'Hello' } },
-        // @ts-expect-error - SessionNotification type doesn't include 'usage' field, but adapters like Claude Code add it at runtime
-        usage: { inputTokens: 50, outputTokens: 30 },
-      },
-    ]
-
-    const result = extractTokenCounts(updates)
-
-    expect(result.inputTokens).toBe(50)
-    expect(result.outputTokens).toBe(30)
-  })
-
-  test('accumulates token counts across multiple updates', () => {
-    const updates: SessionNotification[] = [
-      {
-        sessionId: 's1',
-        update: { sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: 'First' } },
-        // @ts-expect-error - SessionNotification type doesn't include 'usage' field, but adapters like Claude Code add it at runtime
-        usage: { inputTokens: 50, outputTokens: 30 },
-      },
-      {
-        sessionId: 's1',
-        update: { sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: 'Second' } },
-        // @ts-expect-error - SessionNotification type doesn't include 'usage' field, but adapters like Claude Code add it at runtime
-        usage: { inputTokens: 25, outputTokens: 45 },
-      },
-    ]
-
-    const result = extractTokenCounts(updates)
-
-    expect(result.inputTokens).toBe(75) // 50 + 25
-    expect(result.outputTokens).toBe(75) // 30 + 45
-  })
-
-  test('handles empty updates array', () => {
-    const result = extractTokenCounts([])
-
-    expect(result.inputTokens).toBeUndefined()
-    expect(result.outputTokens).toBeUndefined()
-  })
-
-  test('handles partial token counts (only input or output)', () => {
-    const updates: SessionNotification[] = [
-      {
-        sessionId: 's1',
-        update: { sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: 'Hello' } },
-        // @ts-expect-error - SessionNotification type doesn't include 'usage' field, but adapters like Claude Code add it at runtime
-        usage: { inputTokens: 100 },
-      },
-    ]
-
-    const result = extractTokenCounts(updates)
-
-    expect(result.inputTokens).toBe(100)
-    expect(result.outputTokens).toBeUndefined()
-  })
-})
diff --git a/src/tests/summarize-helpers.spec.ts b/src/commands/tests/summarize-helpers.spec.ts
similarity index 99%
rename from src/tests/summarize-helpers.spec.ts
rename to src/commands/tests/summarize-helpers.spec.ts
index e3ac8e3..9df86d1 100644
--- a/src/tests/summarize-helpers.spec.ts
+++ b/src/commands/tests/summarize-helpers.spec.ts
@@ -1,5 +1,5 @@
 import { describe, expect, test } from 'bun:test'
-import type { CaptureResult } from '../schemas.ts'
+import type { CaptureResult } from '../../schemas.ts'
 import { formatMarkdown, formatSummary } from '../summarize.ts'
 
 // ============================================================================
diff --git a/src/tests/trials-calculations.spec.ts b/src/commands/tests/trials-calculations.spec.ts
similarity index 100%
rename from src/tests/trials-calculations.spec.ts
rename to src/commands/tests/trials-calculations.spec.ts
diff --git a/src/tests/trials-cli.spec.ts b/src/commands/tests/trials-cli.spec.ts
similarity index 89%
rename from src/tests/trials-cli.spec.ts
rename to src/commands/tests/trials-cli.spec.ts
index 88bb42d..f89d8c5 100644
--- a/src/tests/trials-cli.spec.ts
+++ b/src/commands/tests/trials-cli.spec.ts
@@ -9,24 +9,25 @@ describe('TrialsConfig configuration', () => {
   test('TrialsConfig type accepts valid configuration', () => {
     const config: TrialsConfig = {
       promptsPath: '/tmp/prompts.jsonl',
-      agentCommand: ['bunx', 'test-agent'],
+      schemaPath: './schemas/claude-headless.json',
       k: 5,
       outputPath: '/tmp/output.jsonl',
       cwd: '/tmp',
       timeout: 30000,
       progress: true,
       append: false,
+      debug: false,
     }
 
     expect(config.promptsPath).toBe('/tmp/prompts.jsonl')
-    expect(config.agentCommand).toEqual(['bunx', 'test-agent'])
+    expect(config.schemaPath).toBe('./schemas/claude-headless.json')
     expect(config.k).toBe(5)
   })
 
   test('TrialsConfig allows minimal configuration', () => {
     const config: TrialsConfig = {
       promptsPath: '/tmp/prompts.jsonl',
-      agentCommand: ['echo', 'test'],
+      schemaPath: './test-schema.json',
       k: 3,
     }
 
@@ -53,7 +54,7 @@ describe('trials CLI', () => {
     const stdout = await new Response(proc.stdout).text()
     await proc.exited
 
-    expect(stdout).toContain('Usage: acp-harness trials')
+    expect(stdout).toContain('Usage: agent-eval-harness trials')
     expect(stdout).toContain('prompts.jsonl')
     expect(stdout).toContain('-o, --output')
     expect(stdout).toContain('-k')
@@ -61,6 +62,7 @@ describe('trials CLI', () => {
     expect(stdout).toContain('-t, --timeout')
     expect(stdout).toContain('--progress')
     expect(stdout).toContain('-g, --grader')
+    expect(stdout).toContain('-s, --schema')
     expect(stdout).toContain('pass@k')
   })
 
@@ -77,7 +79,7 @@ describe('trials CLI', () => {
     expect(stderr).toContain('prompts.jsonl path is required')
   })
 
-  test('shows error for missing agent command', async () => {
+  test('shows error for missing schema argument', async () => {
     const proc = Bun.spawn(['bun', './bin/cli.ts', 'trials', '/tmp/prompts.jsonl'], {
       stdout: 'pipe',
       stderr: 'pipe',
@@ -87,7 +89,7 @@ describe('trials CLI', () => {
     const exitCode = await proc.exited
 
     expect(exitCode).not.toBe(0)
-    expect(stderr).toContain('ACP agent command is required')
+    expect(stderr).toContain('--schema is required')
   })
 })
 
@@ -105,7 +107,7 @@ describe('schemas CLI', () => {
     const stdout = await new Response(proc.stdout).text()
     await proc.exited
 
-    expect(stdout).toContain('Usage: acp-harness schemas')
+    expect(stdout).toContain('Usage: agent-eval-harness schemas')
     expect(stdout).toContain('-o, --output')
     expect(stdout).toContain('-j, --json')
     expect(stdout).toContain('-s, --split')
diff --git a/src/trials.ts b/src/commands/trials.ts
similarity index 51%
rename from src/trials.ts
rename to src/commands/trials.ts
index cbadfaa..c462236 100644
--- a/src/trials.ts
+++ b/src/commands/trials.ts
@@ -11,14 +11,14 @@
  * @packageDocumentation
  */
 
-import { appendFile } from 'node:fs/promises'
 import { parseArgs } from 'node:util'
-import { createACPClient } from './acp-client.ts'
-import { createPrompt } from './acp-helpers.ts'
-import { extractOutput, extractTrajectory, loadPrompts } from './capture.ts'
-import { DEFAULT_HARNESS_TIMEOUT, DEFAULT_TRIAL_COUNT } from './constants.ts'
-import { loadGrader } from './grader-loader.ts'
-import type { Grader, TrialEntry, TrialResult } from './schemas.ts'
+import { extractOutput, extractTrajectory, loadPrompts, logProgress, resolvePath, writeOutput } from '../core.ts'
+import { type HeadlessAdapterConfig, parseHeadlessConfig } from '../headless/headless.schemas.ts'
+import type { ParsedUpdate } from '../headless/headless-output-parser.ts'
+import { createSessionManager } from '../headless/headless-session-manager.ts'
+import { DEFAULT_HARNESS_TIMEOUT, DEFAULT_TRIAL_COUNT } from '../schemas/constants.ts'
+import { loadGrader } from '../schemas/grader-loader.ts'
+import type { Grader, TrialEntry, TrialResult } from '../schemas.ts'
 
 // ============================================================================
 // Pass@k/Pass^k Calculation
@@ -77,15 +77,15 @@ export const calculatePassExpK = (passes: number, k: number): number => {
 export type TrialsConfig = {
   /** Path to prompts.jsonl file */
   promptsPath: string
-  /** ACP agent command */
-  agentCommand: string[]
+  /** Path to agent schema JSON file */
+  schemaPath: string
   /** Number of trials per prompt */
   k: number
   /** Output file path */
   outputPath?: string
   /** Working directory for agent */
   cwd?: string
-  /** Timeout per prompt in milliseconds */
+  /** Timeout per prompt in milliseconds (overrides schema default) */
   timeout?: number
   /** Show progress to stderr */
   progress?: boolean
@@ -93,37 +93,8 @@ export type TrialsConfig = {
   append?: boolean
   /** Optional grader function */
   grader?: Grader
-}
-
-// ============================================================================
-// Helpers
-// ============================================================================
-
-/** Resolve path relative to process.cwd() */
-const resolvePath = (path: string): string => {
-  if (path.startsWith('/')) return path
-  return `${process.cwd()}/${path}`
-}
-
-/** Write output line */
-const writeOutput = async (line: string, outputPath?: string, append?: boolean): Promise<void> => {
-  if (outputPath) {
-    if (append) {
-      await appendFile(outputPath, `${line}\n`)
-    } else {
-      await Bun.write(outputPath, `${line}\n`)
-    }
-  } else {
-    // biome-ignore lint/suspicious/noConsole: CLI stdout output
-    console.log(line)
-  }
-}
-
-/** Log progress to stderr */
-const logProgress = (message: string, showProgress: boolean): void => {
-  if (showProgress) {
-    console.error(message)
-  }
+  /** Enable debug mode */
+  debug?: boolean
 }
 
 // ============================================================================
@@ -139,35 +110,56 @@ const logProgress = (message: string, showProgress: boolean): void => {
 export const runTrials = async (config: TrialsConfig): Promise<TrialResult[]> => {
   const {
     promptsPath,
-    agentCommand,
+    schemaPath,
     k,
     outputPath,
     cwd,
-    timeout = DEFAULT_HARNESS_TIMEOUT,
+    timeout,
     progress = false,
     append = false,
     grader,
+    debug = false,
   } = config
 
+  // Load and validate schema
+  const schemaFile = Bun.file(schemaPath)
+  if (!(await schemaFile.exists())) {
+    throw new Error(`Schema file not found: ${schemaPath}`)
+  }
+
+  let schema: HeadlessAdapterConfig
+  try {
+    const rawSchema = await schemaFile.json()
+    schema = parseHeadlessConfig(rawSchema)
+  } catch (error) {
+    throw new Error(`Invalid schema: ${error instanceof Error ? error.message : String(error)}`)
+  }
+
   // Load prompts
   const prompts = await loadPrompts(promptsPath)
 
   // Resolve output path
   const resolvedOutputPath = outputPath ? resolvePath(outputPath) : undefined
 
+  // Determine effective timeout (CLI flag > schema default > harness default)
+  const schemaTimeout = 'timeout' in schema ? schema.timeout : undefined
+  const effectiveTimeout = timeout ?? schemaTimeout ?? DEFAULT_HARNESS_TIMEOUT
+
   // Log progress info
   logProgress(`Loaded ${prompts.length} prompts from ${promptsPath}`, progress)
   logProgress(`Running ${k} trials per prompt`, progress)
-  logProgress(`Command: ${agentCommand.join(' ')}`, progress)
+  logProgress(`Schema: ${schema.name} (${schemaPath})`, progress)
+  logProgress(`Timeout: ${effectiveTimeout}ms`, progress)
   if (grader) {
     logProgress('Grader: enabled (will compute pass@k metrics)', progress)
   }
 
-  // Create ACP client
-  const client = createACPClient({
-    command: agentCommand,
-    cwd,
-    timeout,
+  // Create session manager with schema
+  const sessions = createSessionManager({
+    schema,
+    timeout: effectiveTimeout,
+    verbose: progress,
+    debug,
   })
 
   // Clear output file if not appending
@@ -175,117 +167,115 @@ export const runTrials = async (config: TrialsConfig): Promise<TrialResult[]> =>
     await Bun.write(resolvedOutputPath, '')
   }
 
-  // Session params - agents auto-discover MCP configs from cwd
-  const sessionParams = {
-    cwd: cwd ?? process.cwd(),
-  }
-
+  const workingDir = cwd ?? process.cwd()
   const results: TrialResult[] = []
   let isFirstOutput = true
 
-  try {
-    logProgress('Connecting to agent...', progress)
-    await client.connect()
-    logProgress('Connected!', progress)
+  // Run evaluations
+  for (let i = 0; i < prompts.length; i++) {
+    const promptCase = prompts[i]
+    if (!promptCase) continue
 
-    // Run evaluations
-    for (let i = 0; i < prompts.length; i++) {
-      const promptCase = prompts[i]
-      if (!promptCase) continue
+    logProgress(`[${i + 1}/${prompts.length}] ${promptCase.id}: Running ${k} trials...`, progress)
 
-      logProgress(`[${i + 1}/${prompts.length}] ${promptCase.id}: Running ${k} trials...`, progress)
+    const trialEntries: TrialEntry[] = []
 
-      const trialEntries: TrialEntry[] = []
+    for (let trialNum = 1; trialNum <= k; trialNum++) {
+      // Create fresh session for each trial
+      const session = await sessions.create(workingDir)
+      const startTime = Date.now()
 
-      for (let trialNum = 1; trialNum <= k; trialNum++) {
-        // Create fresh session for each trial
-        const session = await client.createSession(sessionParams)
-        const startTime = Date.now()
+      try {
+        // Handle string or array input
+        const inputs = Array.isArray(promptCase.input) ? promptCase.input : [promptCase.input]
+        const allUpdates: ParsedUpdate[] = []
 
-        try {
-          const inputText = Array.isArray(promptCase.input) ? promptCase.input.join('\n') : promptCase.input
-          const prompt = createPrompt(inputText)
-          const { updates } = await client.promptSync(session.id, prompt)
+        // TODO: Per-prompt timeout from promptCase.timeout is documented but not yet implemented
 
-          const endTime = Date.now()
-          const trajectory = extractTrajectory(updates, startTime)
-          const output = extractOutput(trajectory)
+        // Execute each turn sequentially
+        for (const turnInput of inputs) {
+          const turnResult = await sessions.prompt(session.id, turnInput)
+          allUpdates.push(...turnResult.updates)
+        }
+
+        const endTime = Date.now()
+        const trajectory = extractTrajectory(allUpdates, startTime)
+        const output = extractOutput(trajectory)
 
-          const entry: TrialEntry = {
-            trialNum,
+        const entry: TrialEntry = {
+          trialNum,
+          output,
+          trajectory,
+          duration: endTime - startTime,
+        }
+
+        // Apply grader if provided
+        if (grader) {
+          const graderResult = await grader({
+            input: promptCase.input,
             output,
+            hint: promptCase.hint,
             trajectory,
-            duration: endTime - startTime,
-          }
-
-          // Apply grader if provided
-          if (grader) {
-            const graderResult = await grader({
-              input: promptCase.input,
-              output,
-              hint: promptCase.hint,
-              trajectory,
-            })
-            entry.pass = graderResult.pass
-            entry.score = graderResult.score
-            entry.reasoning = graderResult.reasoning
-          }
-
-          trialEntries.push(entry)
-          logProgress(
-            `    Trial ${trialNum}/${k}: ${entry.pass !== undefined ? (entry.pass ? '✓' : '✗') : '?'}`,
-            progress,
-          )
-        } catch (error) {
-          const endTime = Date.now()
-          const message = error instanceof Error ? error.message : String(error)
-
-          trialEntries.push({
-            trialNum,
-            output: '',
-            trajectory: [],
-            duration: endTime - startTime,
-            pass: false,
-            reasoning: `Error: ${message}`,
           })
-          logProgress(`    Trial ${trialNum}/${k}: ! (error)`, progress)
+          entry.pass = graderResult.pass
+          entry.score = graderResult.score
+          entry.reasoning = graderResult.reasoning
         }
-      }
 
-      // Build result
-      const result: TrialResult = {
-        id: promptCase.id,
-        input: promptCase.input,
-        ...(promptCase.hint && { hint: promptCase.hint }),
-        k,
-        trials: trialEntries,
-      }
+        trialEntries.push(entry)
+        logProgress(
+          `    Trial ${trialNum}/${k}: ${entry.pass !== undefined ? (entry.pass ? '✓' : '✗') : '?'}`,
+          progress,
+        )
 
-      // Calculate metrics if grader was used
-      if (grader) {
-        const passes = trialEntries.filter((t) => t.pass).length
-        result.passRate = passes / k
-        result.passAtK = calculatePassAtK(passes, k)
-        result.passExpK = calculatePassExpK(passes, k)
+        // Clean up session
+        sessions.destroy(session.id)
+      } catch (error) {
+        const endTime = Date.now()
+        const message = error instanceof Error ? error.message : String(error)
+
+        trialEntries.push({
+          trialNum,
+          output: '',
+          trajectory: [],
+          duration: endTime - startTime,
+          pass: false,
+          reasoning: `Error: ${message}`,
+        })
+        logProgress(`    Trial ${trialNum}/${k}: ! (error)`, progress)
       }
+    }
 
-      results.push(result)
+    // Build result
+    const result: TrialResult = {
+      id: promptCase.id,
+      input: promptCase.input,
+      ...(promptCase.hint && { hint: promptCase.hint }),
+      k,
+      trials: trialEntries,
+    }
 
-      // Write result immediately
-      const formatted = JSON.stringify(result)
-      await writeOutput(formatted, resolvedOutputPath, !isFirstOutput)
-      isFirstOutput = false
+    // Calculate metrics if grader was used
+    if (grader) {
+      const passes = trialEntries.filter((t) => t.pass).length
+      result.passRate = passes / k
+      result.passAtK = calculatePassAtK(passes, k)
+      result.passExpK = calculatePassExpK(passes, k)
+    }
 
-      if (grader) {
-        logProgress(
-          `  → passRate=${(result.passRate ?? 0).toFixed(2)}, pass@${k}=${(result.passAtK ?? 0).toFixed(2)}`,
-          progress,
-        )
-      }
+    results.push(result)
+
+    // Write result immediately
+    const formatted = JSON.stringify(result)
+    await writeOutput(formatted, resolvedOutputPath, !isFirstOutput)
+    isFirstOutput = false
+
+    if (grader) {
+      logProgress(
+        `  → passRate=${(result.passRate ?? 0).toFixed(2)}, pass@${k}=${(result.passAtK ?? 0).toFixed(2)}`,
+        progress,
+      )
     }
-  } finally {
-    logProgress('Disconnecting...', progress)
-    await client.disconnect()
   }
 
   logProgress('Done!', progress)
@@ -305,13 +295,15 @@ export const trials = async (args: string[]): Promise<void> => {
   const { values, positionals } = parseArgs({
     args,
     options: {
+      schema: { type: 'string', short: 's' },
       output: { type: 'string', short: 'o' },
       k: { type: 'string', short: 'k', default: String(DEFAULT_TRIAL_COUNT) },
       cwd: { type: 'string', short: 'c' },
-      timeout: { type: 'string', short: 't', default: String(DEFAULT_HARNESS_TIMEOUT) },
+      timeout: { type: 'string', short: 't' },
       progress: { type: 'boolean', default: false },
       append: { type: 'boolean', default: false },
       grader: { type: 'string', short: 'g' },
+      debug: { type: 'boolean', default: false },
       help: { type: 'boolean', short: 'h' },
     },
     allowPositionals: true,
@@ -320,20 +312,21 @@ export const trials = async (args: string[]): Promise<void> => {
   if (values.help) {
     // biome-ignore lint/suspicious/noConsole: CLI help output
     console.log(`
-Usage: acp-harness trials <prompts.jsonl> <command> [args...] [options]
+Usage: agent-eval-harness trials <prompts.jsonl> --schema <schema.json> [options]
 
 Arguments:
   prompts.jsonl     Input file with evaluation prompts
-  command [args]    ACP agent command to execute
 
 Options:
+  -s, --schema      Path to agent schema JSON file (required)
   -o, --output      Output file (default: stdout)
   -k                Number of trials per prompt (default: ${DEFAULT_TRIAL_COUNT})
-  -c, --cwd         Working directory for agent (agents auto-discover MCP configs from here)
-  -t, --timeout     Request timeout in ms (default: ${DEFAULT_HARNESS_TIMEOUT})
+  -c, --cwd         Working directory for agent
+  -t, --timeout     Request timeout in ms (overrides schema default)
   --progress        Show progress to stderr
   --append          Append to output file
   -g, --grader      Path to grader (.ts/.js module or executable script)
+  --debug           Enable debug mode
   -h, --help        Show this help message
 
 Output Format:
@@ -346,13 +339,13 @@ Graders:
 
 Examples:
   # Capture only
-  acp-harness trials prompts.jsonl bunx claude-code-acp -k 5 -o trials.jsonl
+  agent-eval-harness trials prompts.jsonl -s claude.json -k 5 -o trials.jsonl
 
   # With TypeScript grader
-  acp-harness trials prompts.jsonl bunx claude-code-acp -k 5 --grader ./grader.ts -o trials.jsonl
+  agent-eval-harness trials prompts.jsonl -s claude.json -k 5 --grader ./grader.ts -o trials.jsonl
 
   # With Python grader
-  acp-harness trials prompts.jsonl bunx claude-code-acp -k 5 --grader ./grader.py -o trials.jsonl
+  agent-eval-harness trials prompts.jsonl -s claude.json -k 5 --grader ./grader.py -o trials.jsonl
 `)
     return
   }
@@ -363,9 +356,9 @@ Examples:
     process.exit(1)
   }
 
-  const agentCommand = positionals.slice(1)
-  if (agentCommand.length === 0) {
-    console.error('Error: ACP agent command is required')
+  if (!values.schema) {
+    console.error('Error: --schema is required')
+    console.error('Example: agent-eval-harness trials prompts.jsonl --schema ./claude.json')
     process.exit(1)
   }
 
@@ -382,13 +375,14 @@ Examples:
 
   await runTrials({
     promptsPath,
-    agentCommand,
+    schemaPath: values.schema,
     k: Number.parseInt(values.k ?? String(DEFAULT_TRIAL_COUNT), 10),
     outputPath: values.output,
     cwd: values.cwd,
-    timeout: Number.parseInt(values.timeout ?? String(DEFAULT_HARNESS_TIMEOUT), 10),
+    timeout: values.timeout ? Number.parseInt(values.timeout, 10) : undefined,
     progress: values.progress ?? false,
     append: values.append ?? false,
     grader,
+    debug: values.debug ?? false,
   })
 }
diff --git a/src/validate-refs.ts b/src/commands/validate-refs.ts
similarity index 94%
rename from src/validate-refs.ts
rename to src/commands/validate-refs.ts
index f177d90..1885c20 100644
--- a/src/validate-refs.ts
+++ b/src/commands/validate-refs.ts
@@ -9,9 +9,9 @@
  */
 
 import { parseArgs } from 'node:util'
+import { loadGrader } from '../schemas/grader-loader.ts'
+import type { Grader, ValidationResult } from '../schemas.ts'
 import { loadPrompts } from './capture.ts'
-import { loadGrader } from './grader-loader.ts'
-import type { Grader, ValidationResult } from './schemas.ts'
 
 // ============================================================================
 // Types
@@ -133,7 +133,7 @@ export const validateRefs = async (args: string[]): Promise<void> => {
   if (values.help) {
     // biome-ignore lint/suspicious/noConsole: CLI help output
     console.log(`
-Usage: acp-harness validate-refs <prompts.jsonl> --grader <grader.ts> [options]
+Usage: agent-eval-harness validate-refs <prompts.jsonl> --grader <grader.ts> [options]
 
 Arguments:
   prompts.jsonl     Input file with prompts (must have 'reference' field)
@@ -155,7 +155,7 @@ Prompt Format:
   }
 
 Examples:
-  acp-harness validate-refs prompts.jsonl --grader ./grader.ts -o validation.jsonl
+  agent-eval-harness validate-refs prompts.jsonl --grader ./grader.ts -o validation.jsonl
 `)
     return
   }
diff --git a/src/core.ts b/src/core.ts
new file mode 100644
index 0000000..9474dcf
--- /dev/null
+++ b/src/core.ts
@@ -0,0 +1,28 @@
+/**
+ * Core utilities re-export.
+ *
+ * @remarks
+ * Public API for core utilities. Import from here for external use.
+ *
+ * @packageDocumentation
+ */
+
+export {
+  // Trajectory
+  detectTrajectoryRichness,
+  extractContent,
+  extractFilePath,
+  extractOutput,
+  extractTrajectory,
+  // Output
+  getInputPreview,
+  hasToolErrors,
+  headTailPreview,
+  // Loading
+  loadJsonl,
+  loadPrompts,
+  loadResults,
+  logProgress,
+  resolvePath,
+  writeOutput,
+} from './core/core.ts'
diff --git a/src/core/core.ts b/src/core/core.ts
new file mode 100644
index 0000000..67865ce
--- /dev/null
+++ b/src/core/core.ts
@@ -0,0 +1,25 @@
+/**
+ * Core utilities for agent-eval-harness.
+ *
+ * @remarks
+ * Re-exports shared utilities used across all commands:
+ * - Loading: JSONL file parsing for prompts and results
+ * - Trajectory: Extraction and analysis of agent trajectories
+ * - Output: Writing results, progress logging, path resolution
+ *
+ * @packageDocumentation
+ */
+
+// Loading utilities
+export { loadJsonl, loadPrompts, loadResults } from './loading.ts'
+// Output utilities
+export { getInputPreview, headTailPreview, logProgress, resolvePath, writeOutput } from './output.ts'
+// Trajectory utilities
+export {
+  detectTrajectoryRichness,
+  extractContent,
+  extractFilePath,
+  extractOutput,
+  extractTrajectory,
+  hasToolErrors,
+} from './trajectory.ts'
diff --git a/src/core/loading.ts b/src/core/loading.ts
new file mode 100644
index 0000000..04771db
--- /dev/null
+++ b/src/core/loading.ts
@@ -0,0 +1,96 @@
+/**
+ * Shared loading utilities for JSONL files.
+ *
+ * @remarks
+ * Provides consistent loading and parsing of prompts and results files.
+ * Used by capture, trials, summarize, calibrate, and pipeline commands.
+ *
+ * @packageDocumentation
+ */
+
+import type { CaptureResult, PromptCase } from '../schemas.ts'
+import { CaptureResultSchema, PromptCaseSchema } from '../schemas.ts'
+
+/**
+ * Load prompts from a JSONL file.
+ *
+ * @remarks
+ * Each line in the file should be a valid JSON object matching PromptCaseSchema.
+ * Supports both single-turn (string input) and multi-turn (string[] input) formats.
+ *
+ * @param path - Path to the prompts.jsonl file
+ * @returns Parsed and validated prompt cases
+ * @throws Error if file cannot be read or any line is invalid
+ *
+ * @public
+ */
+export const loadPrompts = async (path: string): Promise<PromptCase[]> => {
+  const content = await Bun.file(path).text()
+  return content
+    .trim()
+    .split('\n')
+    .filter(Boolean)
+    .map((line, index) => {
+      try {
+        return PromptCaseSchema.parse(JSON.parse(line))
+      } catch (error) {
+        throw new Error(`Invalid prompt at line ${index + 1}: ${error instanceof Error ? error.message : error}`)
+      }
+    })
+}
+
+/**
+ * Load capture results from a JSONL file.
+ *
+ * @remarks
+ * Each line should be a valid JSON object matching CaptureResultSchema.
+ * Used by summarize, calibrate, and compare commands.
+ *
+ * @param path - Path to the results.jsonl file
+ * @returns Parsed and validated capture results
+ * @throws Error if file cannot be read or any line is invalid
+ *
+ * @public
+ */
+export const loadResults = async (path: string): Promise<CaptureResult[]> => {
+  const content = await Bun.file(path).text()
+  return content
+    .trim()
+    .split('\n')
+    .filter(Boolean)
+    .map((line, index) => {
+      try {
+        return CaptureResultSchema.parse(JSON.parse(line))
+      } catch (error) {
+        throw new Error(`Invalid result at line ${index + 1}: ${error instanceof Error ? error.message : error}`)
+      }
+    })
+}
+
+/**
+ * Load raw JSONL file as parsed JSON objects.
+ *
+ * @remarks
+ * Lower-level loading without schema validation.
+ * Useful for pipeline commands that need flexible input handling.
+ *
+ * @param path - Path to JSONL file
+ * @returns Array of parsed JSON objects
+ * @throws Error if file cannot be read or any line is invalid JSON
+ *
+ * @public
+ */
+export const loadJsonl = async <T = unknown>(path: string): Promise<T[]> => {
+  const content = await Bun.file(path).text()
+  return content
+    .trim()
+    .split('\n')
+    .filter(Boolean)
+    .map((line, index) => {
+      try {
+        return JSON.parse(line) as T
+      } catch (error) {
+        throw new Error(`Invalid JSON at line ${index + 1}: ${error instanceof Error ? error.message : error}`)
+      }
+    })
+}
diff --git a/src/core/output.ts b/src/core/output.ts
new file mode 100644
index 0000000..f4fbf5f
--- /dev/null
+++ b/src/core/output.ts
@@ -0,0 +1,121 @@
+/**
+ * Shared output utilities for writing results and logging.
+ *
+ * @remarks
+ * Provides consistent output handling across all commands:
+ * - Writing to stdout or files
+ * - Progress logging to stderr
+ * - Path resolution
+ * - Content preview (head/tail)
+ *
+ * @packageDocumentation
+ */
+
+import { appendFile } from 'node:fs/promises'
+import { HEAD_LINES, TAIL_LINES } from '../schemas/constants.ts'
+
+/**
+ * Write output line to stdout or file.
+ *
+ * @remarks
+ * When writing to a file, supports both overwrite and append modes.
+ * When writing to stdout, uses console.log.
+ *
+ * @param line - Content to write (without trailing newline)
+ * @param outputPath - Optional file path (stdout if undefined)
+ * @param append - If true, append to file instead of overwrite
+ *
+ * @public
+ */
+export const writeOutput = async (line: string, outputPath?: string, append?: boolean): Promise<void> => {
+  if (outputPath) {
+    if (append) {
+      await appendFile(outputPath, `${line}\n`)
+    } else {
+      await Bun.write(outputPath, `${line}\n`)
+    }
+  } else {
+    // biome-ignore lint/suspicious/noConsole: CLI stdout output
+    console.log(line)
+  }
+}
+
+/**
+ * Log progress message to stderr.
+ *
+ * @remarks
+ * Progress output goes to stderr to avoid polluting stdout
+ * when piping command output.
+ *
+ * @param message - Progress message to display
+ * @param showProgress - If false, message is suppressed
+ *
+ * @public
+ */
+export const logProgress = (message: string, showProgress: boolean): void => {
+  if (showProgress) {
+    console.error(message)
+  }
+}
+
+/**
+ * Resolve path relative to process.cwd().
+ *
+ * @remarks
+ * Absolute paths (starting with /) are returned as-is.
+ * Relative paths are joined with current working directory.
+ *
+ * @param path - Path to resolve
+ * @returns Absolute path
+ *
+ * @public
+ */
+export const resolvePath = (path: string): string => {
+  if (path.startsWith('/')) return path
+  return `${process.cwd()}/${path}`
+}
+
+/**
+ * Create head/tail preview of content.
+ *
+ * @remarks
+ * Shows first N and last M lines with omission indicator in between.
+ * Useful for large files/content in markdown output.
+ *
+ * @param content - Full content string
+ * @param headLines - Number of lines from start (default from constants)
+ * @param tailLines - Number of lines from end (default from constants)
+ * @returns Truncated content with omission indicator
+ *
+ * @public
+ */
+export const headTailPreview = (content: string, headLines = HEAD_LINES, tailLines = TAIL_LINES): string => {
+  const lines = content.split('\n')
+  if (lines.length <= headLines + tailLines) {
+    return content
+  }
+  const head = lines.slice(0, headLines).join('\n')
+  const tail = lines.slice(-tailLines).join('\n')
+  const omitted = lines.length - headLines - tailLines
+  return `${head}\n\n// ... ${omitted} lines omitted ...\n\n${tail}`
+}
+
+/**
+ * Get preview text for input (handles string or array).
+ *
+ * @remarks
+ * For arrays (multi-turn), shows turn count and preview of first turn.
+ * For strings, shows first 50 characters.
+ *
+ * @param input - String or array input
+ * @returns Preview text suitable for progress display
+ *
+ * @public
+ */
+export const getInputPreview = (input: string | string[]): string => {
+  if (Array.isArray(input)) {
+    const first = input[0] ?? ''
+    return `[${input.length} turns] ${first.slice(0, 40)}...`
+  }
+  return input.slice(0, 50)
+}
diff --git a/src/core/tests/core.spec.ts b/src/core/tests/core.spec.ts
new file mode 100644
index 0000000..cae3bf1
--- /dev/null
+++ b/src/core/tests/core.spec.ts
@@ -0,0 +1,309 @@
+/**
+ * Unit tests for core utilities.
+ *
+ * @remarks
+ * Tests for shared utility functions in the core module:
+ * - loading: loadPrompts, loadResults, loadJsonl
+ * - trajectory: extractTrajectory, extractOutput, hasToolErrors
+ * - output: writeOutput, logProgress, headTailPreview
+ *
+ * @packageDocumentation
+ */
+
+import { afterEach, describe, expect, test } from 'bun:test'
+import { unlink, writeFile } from 'node:fs/promises'
+import type { ParsedUpdate } from '../../headless/headless-output-parser.ts'
+import { loadJsonl, loadPrompts, loadResults } from '../loading.ts'
+import { headTailPreview, resolvePath } from '../output.ts'
+import { detectTrajectoryRichness, extractOutput, extractTrajectory, hasToolErrors } from '../trajectory.ts'
+
+// ============================================================================
+// Loading Tests
+// ============================================================================
+
+describe('loadJsonl', () => {
+  const testFile = '/tmp/core-test-jsonl.jsonl'
+
+  afterEach(async () => {
+    try {
+      await unlink(testFile)
+    } catch {
+      // Ignore if file doesn't exist
+    }
+  })
+
+  test('loads and parses JSONL file', async () => {
+    await writeFile(testFile, '{"a":1}\n{"a":2}\n{"a":3}')
+    const results = await loadJsonl<{ a: number }>(testFile)
+    expect(results.length).toBe(3)
+    expect(results[0]?.a).toBe(1)
+    expect(results[2]?.a).toBe(3)
+  })
+
+  test('skips empty lines', async () => {
+    await writeFile(testFile, '{"a":1}\n\n{"a":2}\n')
+    const results = await loadJsonl<{ a: number }>(testFile)
+    expect(results.length).toBe(2)
+  })
+
+  test('handles empty file', async () => {
+    await writeFile(testFile, '')
+    const results = await loadJsonl(testFile)
+    expect(results.length).toBe(0)
+  })
+})
+
+describe('loadPrompts', () => {
+  const testFile = '/tmp/core-test-prompts.jsonl'
+
+  afterEach(async () => {
+    try {
+      await unlink(testFile)
+    } catch {
+      // Ignore
+    }
+  })
+
+  test('loads valid prompts', async () => {
+    await writeFile(testFile, '{"id":"p1","input":"hello"}\n{"id":"p2","input":"world"}')
+    const prompts = await loadPrompts(testFile)
+    expect(prompts.length).toBe(2)
+    expect(prompts[0]?.id).toBe('p1')
+    expect(prompts[0]?.input).toBe('hello')
+  })
+
+  test('loads multi-turn prompts', async () => {
+    await writeFile(testFile, '{"id":"m1","input":["turn1","turn2"]}')
+    const prompts = await loadPrompts(testFile)
+    expect(prompts.length).toBe(1)
+    expect(Array.isArray(prompts[0]?.input)).toBe(true)
+    expect((prompts[0]?.input as string[]).length).toBe(2)
+  })
+})
+
+describe('loadResults', () => {
+  const testFile = '/tmp/core-test-results.jsonl'
+
+  afterEach(async () => {
+    try {
+      await unlink(testFile)
+    } catch {
+      // Ignore
+    }
+  })
+
+  test('loads capture results with full schema', async () => {
+    const result = {
+      id: 'r1',
+      input: 'test',
+      output: 'result',
+      trajectory: [],
+      metadata: {},
+      toolErrors: false,
+      timing: {
+        start: 0,
+        end: 100,
+        total: 100,
+        sessionCreation: 10,
+      },
+    }
+    await writeFile(testFile, JSON.stringify(result))
+    const results = await loadResults(testFile)
+    expect(results.length).toBe(1)
+    expect(results[0]?.id).toBe('r1')
+    expect(results[0]?.output).toBe('result')
+  })
+})
+
+// ============================================================================
+// Trajectory Tests
+// ============================================================================
+
+describe('extractTrajectory', () => {
+  const startTime = 1000
+
+  test('extracts message updates', () => {
+    const updates: ParsedUpdate[] = [{ type: 'message', content: 'Hello', raw: {} }]
+    const trajectory = extractTrajectory(updates, startTime)
+    expect(trajectory.length).toBe(1)
+    expect(trajectory[0]?.type).toBe('message')
+    expect(trajectory[0]?.type === 'message' && trajectory[0]?.content).toBe('Hello')
+  })
+
+  test('extracts thought updates', () => {
+    const updates: ParsedUpdate[] = [{ type: 'thought', content: 'Thinking...', raw: {} }]
+    const trajectory = extractTrajectory(updates, startTime)
+    expect(trajectory.length).toBe(1)
+    expect(trajectory[0]?.type).toBe('thought')
+  })
+
+  test('extracts tool_call with title', () => {
+    const updates: ParsedUpdate[] = [
+      {
+        type: 'tool_call',
+        title: 'Read',
+        status: 'completed',
+        raw: {},
+      },
+    ]
+    const trajectory = extractTrajectory(updates, startTime)
+    expect(trajectory.length).toBe(1)
+    expect(trajectory[0]?.type).toBe('tool_call')
+    const step = trajectory[0]
+    if (step?.type === 'tool_call') {
+      expect(step.name).toBe('Read')
+    }
+  })
+
+  test('handles empty updates', () => {
+    const trajectory = extractTrajectory([], startTime)
+    expect(trajectory.length).toBe(0)
+  })
+})
+
+describe('extractOutput', () => {
+  test('concatenates all message content', () => {
+    const trajectory = [
+      { type: 'thought' as const, content: 'Thinking', timestamp: 50 },
+      { type: 'message' as const, content: 'First message', timestamp: 100 },
+      { type: 'message' as const, content: 'Final answer', timestamp: 150 },
+    ]
+    const output = extractOutput(trajectory)
+    // extractOutput joins all messages with newline
+    expect(output).toBe('First message\nFinal answer')
+  })
+
+  test('returns empty string when no messages', () => {
+    const trajectory = [{ type: 'thought' as const, content: 'Thinking only', timestamp: 50 }]
+    const output = extractOutput(trajectory)
+    expect(output).toBe('')
+  })
+
+  test('handles empty trajectory', () => {
+    const output = extractOutput([])
+    expect(output).toBe('')
+  })
+})
+
+describe('hasToolErrors', () => {
+  test('returns false for successful tool calls', () => {
+    const trajectory = [
+      {
+        type: 'tool_call' as const,
+        name: 'Read',
+        status: 'completed',
+        timestamp: 100,
+      },
+    ]
+    expect(hasToolErrors(trajectory)).toBe(false)
+  })
+
+  test('returns true for failed status', () => {
+    const trajectory = [
+      {
+        type: 'tool_call' as const,
+        name: 'Read',
+        status: 'failed',
+        timestamp: 100,
+      },
+    ]
+    // hasToolErrors checks for status === 'failed'
+    expect(hasToolErrors(trajectory)).toBe(true)
+  })
+
+  test('returns false for error status (not failed)', () => {
+    // The implementation checks for 'failed', not 'error'
+    const trajectory = [
+      {
+        type: 'tool_call' as const,
+        name: 'Read',
+        status: 'error',
+        timestamp: 100,
+      },
+    ]
+    expect(hasToolErrors(trajectory)).toBe(false)
+  })
+
+  test('returns false for empty trajectory', () => {
+    expect(hasToolErrors([])).toBe(false)
+  })
+})
+
+describe('detectTrajectoryRichness', () => {
+  test('returns full when has thoughts', () => {
+    const trajectory = [
+      { type: 'thought' as const, content: 'Let me think', timestamp: 50 },
+      { type: 'message' as const, content: 'Done', timestamp: 150 },
+    ]
+    expect(detectTrajectoryRichness(trajectory)).toBe('full')
+  })
+
+  test('returns full when has tool_calls', () => {
+    const trajectory = [
+      {
+        type: 'tool_call' as const,
+        name: 'Read',
+        status: 'completed',
+        timestamp: 100,
+      },
+      { type: 'message' as const, content: 'Done', timestamp: 150 },
+    ]
+    // Any tool_call means 'full'
+    expect(detectTrajectoryRichness(trajectory)).toBe('full')
+  })
+
+  test('returns messages-only when only messages', () => {
+    const trajectory = [{ type: 'message' as const, content: 'Just a message', timestamp: 100 }]
+    expect(detectTrajectoryRichness(trajectory)).toBe('messages-only')
+  })
+
+  test('returns minimal for empty trajectory', () => {
+    // Empty trajectory returns 'minimal', not 'messages-only'
+    expect(detectTrajectoryRichness([])).toBe('minimal')
+  })
+})
+
+// ============================================================================
+// Output Tests
+// ============================================================================
+
+describe('headTailPreview', () => {
+  test('returns full content when short', () => {
+    const content = 'line1\nline2\nline3'
+    const preview = headTailPreview(content, 5, 3)
+    expect(preview).toBe(content)
+  })
+
+  test('truncates long content with omission indicator', () => {
+    const lines = Array.from({ length: 20 }, (_, i) => `line${i + 1}`).join('\n')
+    const preview = headTailPreview(lines, 3, 2)
+
+    expect(preview).toContain('line1')
+    expect(preview).toContain('line2')
+    expect(preview).toContain('line3')
+    // Actual format uses "// ... N lines omitted ..."
+    expect(preview).toContain('// ... 15 lines omitted ...')
+    expect(preview).toContain('line19')
+    expect(preview).toContain('line20')
+  })
+
+  test('handles exact boundary', () => {
+    const lines = 'line1\nline2\nline3\nline4\nline5'
+    const preview = headTailPreview(lines, 3, 2)
+    // 5 lines is exactly head(3) + tail(2), no truncation needed
+    expect(preview).toBe(lines)
+  })
+})
+
+describe('resolvePath', () => {
+  test('resolves relative path from cwd', () => {
+    const resolved = resolvePath('./test.txt')
+    expect(resolved.endsWith('test.txt')).toBe(true)
+    expect(resolved.startsWith('/')).toBe(true)
+  })
+
+  test('returns absolute path unchanged', () => {
+    const path = '/absolute/path/file.txt'
+    expect(resolvePath(path)).toBe(path)
+  })
+})
diff --git a/src/core/trajectory.ts b/src/core/trajectory.ts
new file mode 100644
index 0000000..f1803c3
--- /dev/null
+++ b/src/core/trajectory.ts
@@ -0,0 +1,166 @@
+/**
+ * Shared trajectory utilities for extraction and analysis.
+ *
+ * @remarks
+ * Provides functions for extracting trajectory data from parsed updates,
+ * detecting richness levels, and checking for tool errors.
+ *
+ * @packageDocumentation
+ */
+
+import type { ParsedUpdate } from '../headless/headless-output-parser.ts'
+import type { TrajectoryRichness, TrajectoryStep } from '../schemas.ts'
+import { ToolInputSchema } from '../schemas.ts'
+
+/**
+ * Extract trajectory from parsed updates.
+ *
+ * @remarks
+ * Converts ParsedUpdate stream into TrajectoryStep array.
+ * Handles tool call deduplication (start/completion events).
+ *
+ * @param updates - Parsed updates from output parser
+ * @param startTime - Reference time for timestamp calculation
+ * @returns Array of trajectory steps with relative timestamps
+ *
+ * @public
+ */
+export const extractTrajectory = (updates: ParsedUpdate[], startTime: number): TrajectoryStep[] => {
+  const trajectory: TrajectoryStep[] = []
+  const toolCallMap = new Map<string, { start: number; step: TrajectoryStep & { type: 'tool_call' } }>()
+
+  for (const update of updates) {
+    const timestamp = Date.now() - startTime
+
+    if (update.type === 'thought') {
+      trajectory.push({
+        type: 'thought',
+        content: update.content ?? '',
+        timestamp,
+      })
+    } else if (update.type === 'message') {
+      trajectory.push({
+        type: 'message',
+        content: update.content ?? '',
+        timestamp,
+      })
+    } else if (update.type === 'tool_call') {
+      const toolCallId = update.title ?? `tool_${Date.now()}`
+      const existing = toolCallMap.get(toolCallId)
+
+      if (existing && update.status === 'completed') {
+        // Update existing tool call with completion info
+        existing.step.status = update.status
+        existing.step.duration = timestamp - existing.start
+      } else if (!existing) {
+        // New tool call
+        const step: TrajectoryStep & { type: 'tool_call' } = {
+          type: 'tool_call',
+          name: update.title ?? 'unknown',
+          status: update.status ?? 'pending',
+          timestamp,
+        }
+        toolCallMap.set(toolCallId, { start: timestamp, step })
+        trajectory.push(step)
+      }
+    } else if (update.type === 'plan') {
+      trajectory.push({
+        type: 'plan',
+        entries: [],
+        timestamp,
+      })
+    }
+  }
+
+  return trajectory
+}
+
+/**
+ * Extract final text output from trajectory.
+ *
+ * @remarks
+ * Concatenates all message step content to produce final output string.
+ *
+ * @param trajectory - Trajectory steps from capture
+ * @returns Concatenated message content
+ *
+ * @public
+ */
+export const extractOutput = (trajectory: TrajectoryStep[]): string => {
+  return trajectory
+    .filter((step): step is TrajectoryStep & { type: 'message' } => step.type === 'message')
+    .map((step) => step.content)
+    .join('\n')
+}
+
+/**
+ * Check if any tool calls failed in trajectory.
+ *
+ * @param trajectory - Trajectory steps from capture
+ * @returns True if any tool call has 'failed' status
+ *
+ * @public
+ */
+export const hasToolErrors = (trajectory: TrajectoryStep[]): boolean => {
+  return trajectory.some((step) => step.type === 'tool_call' && step.status === 'failed')
+}
+
+/**
+ * Detect trajectory richness level from captured steps.
+ *
+ * @remarks
+ * Different adapters provide varying levels of detail:
+ * - `full`: Has thoughts, tool calls, or plans (e.g., Claude Code)
+ * - `messages-only`: Only message steps present
+ * - `minimal`: Empty or unknown content
+ *
+ * Uses single-pass iteration with early exit for efficiency.
+ *
+ * @param trajectory - Trajectory steps from capture
+ * @returns Detected richness level
+ *
+ * @public
+ */
+export const detectTrajectoryRichness = (trajectory: TrajectoryStep[]): TrajectoryRichness => {
+  let hasMessages = false
+
+  for (const step of trajectory) {
+    // Early exit: any of these means 'full' richness
+    if (step.type === 'thought' || step.type === 'tool_call' || step.type === 'plan') {
+      return 'full'
+    }
+    if (step.type === 'message') {
+      hasMessages = true
+    }
+  }
+
+  return hasMessages ? 'messages-only' : 'minimal'
+}
+
+/**
+ * Extract file path from tool input if present.
+ *
+ * @param input - Tool call input object
+ * @returns File path string or undefined
+ *
+ * @public
+ */
+export const extractFilePath = (input: unknown): string | undefined => {
+  const result = ToolInputSchema.safeParse(input)
+  if (!result.success) return undefined
+  return result.data.file_path ?? result.data.path
+}
+
+/**
+ * Extract content from tool input if present.
+ *
+ * @param input - Tool call input object
+ * @returns Content string or undefined
+ *
+ * @public
+ */
+export const extractContent = (input: unknown): string | undefined => {
+  const result = ToolInputSchema.safeParse(input)
+  if (!result.success) return undefined
+  return result.data.content ?? result.data.new_string
+}
diff --git a/src/harness.ts b/src/harness.ts
index dad3547..042208d 100644
--- a/src/harness.ts
+++ b/src/harness.ts
@@ -3,7 +3,7 @@
  *
  * @remarks
  * Re-exports all harness command modules for programmatic use.
- * For CLI usage, run `acp-harness <command> --help`.
+ * For CLI usage, run `agent-eval-harness <command> --help`.
  *
  * **Commands:**
  * - `capture` - Core trajectory capture
@@ -18,22 +18,29 @@
  * @packageDocumentation
  */
 
-export type { BalanceConfig } from './balance.ts'
-export { balance, runBalance } from './balance.ts'
-export type { CalibrateConfig } from './calibrate.ts'
-export { calibrate, runCalibrate } from './calibrate.ts'
+export type { BalanceConfig } from './commands/balance.ts'
+export { balance, runBalance } from './commands/balance.ts'
+export type { CalibrateConfig } from './commands/calibrate.ts'
+export { calibrate, runCalibrate } from './commands/calibrate.ts'
 // Config types
-export type { CaptureConfig } from './capture.ts'
+export type { CaptureConfig } from './commands/capture.ts'
 // Command implementations (for programmatic use)
-export { capture, extractOutput, extractTrajectory, hasToolErrors, loadPrompts, runCapture } from './capture.ts'
+export {
+  capture,
+  extractOutput,
+  extractTrajectory,
+  hasToolErrors,
+  loadPrompts,
+  runCapture,
+} from './commands/capture.ts'
+export type { SummarizeConfig } from './commands/summarize.ts'
+export { runSummarize, summarize } from './commands/summarize.ts'
+export type { TrialsConfig } from './commands/trials.ts'
+export { runTrials, trials } from './commands/trials.ts'
+export type { ValidateRefsConfig } from './commands/validate-refs.ts'
+export { runValidateRefs, validateRefs } from './commands/validate-refs.ts'
 export type { HeadlessAdapterConfig } from './headless.ts'
 // Headless adapter factory
 export { headless } from './headless.ts'
-export type { SchemasConfig } from './schemas-cli.ts'
-export { runSchemas, schemasCli } from './schemas-cli.ts'
-export type { SummarizeConfig } from './summarize.ts'
-export { runSummarize, summarize } from './summarize.ts'
-export type { TrialsConfig } from './trials.ts'
-export { runTrials, trials } from './trials.ts'
-export type { ValidateRefsConfig } from './validate-refs.ts'
-export { runValidateRefs, validateRefs } from './validate-refs.ts'
+export type { SchemasConfig } from './schemas/schemas-cli.ts'
+export { runSchemas, schemasCli } from './schemas/schemas-cli.ts'
diff --git a/src/headless.ts b/src/headless.ts
index 34f8484..02530b5 100644
--- a/src/headless.ts
+++ b/src/headless.ts
@@ -1,5 +1,5 @@
 /**
- * Headless ACP adapter factory - schema-driven adapter for any CLI agent.
+ * Headless adapter factory - schema-driven adapter for any CLI agent.
  *
  * @remarks
  * Re-exports public API from the headless module. The headless adapter enables
@@ -8,12 +8,12 @@
  *
  * **CLI Usage:**
  * ```bash
- * acp-harness headless --schema ./my-agent.json
+ * agent-eval-harness headless --schema ./my-agent.json
  * ```
  *
  * **Programmatic Usage:**
  * ```typescript
- * import { parseHeadlessConfig, createSessionManager } from '@plaited/acp-harness/headless'
+ * import { parseHeadlessConfig, createSessionManager } from '@plaited/agent-eval-harness/headless'
  *
  * const schema = parseHeadlessConfig(jsonConfig)
  * const sessions = createSessionManager({ schema })
@@ -34,7 +34,7 @@ export {
   ResultConfigSchema,
   ResumeConfigSchema,
   safeParseHeadlessConfig,
-} from './headless.schemas.ts'
+} from './headless/headless.schemas.ts'
 // Types
 export type {
   HeadlessAdapterConfig,
@@ -45,27 +45,28 @@ export type {
   PromptConfig,
   ResultConfig,
   ResumeConfig,
-} from './headless.types.ts'
+} from './headless/headless.types.ts'
 // CLI entry point
-export { headless } from './headless-cli.ts'
-export type { HistoryBuilder, HistoryBuilderConfig, HistoryTurn } from './headless-history-builder.ts'
+export { headless } from './headless/headless-cli.ts'
+export type { HistoryBuilder, HistoryBuilderConfig, HistoryTurn } from './headless/headless-history-builder.ts'
 // History builder
-export { createHistoryBuilder } from './headless-history-builder.ts'
+export { createHistoryBuilder } from './headless/headless-history-builder.ts'
 export type {
   OutputParser,
   ParsedResult,
   ParsedUpdate,
   ResultParseResult,
   SessionUpdateType,
-} from './headless-output-parser.ts'
+} from './headless/headless-output-parser.ts'
 // Output parser
-export { createOutputParser, jsonPath, jsonPathString } from './headless-output-parser.ts'
+export { createOutputParser, jsonPath, jsonPathString } from './headless/headless-output-parser.ts'
 export type {
+  ProcessExitInfo,
   PromptResult,
   Session,
   SessionManager,
   SessionManagerConfig,
   UpdateCallback,
-} from './headless-session-manager.ts'
+} from './headless/headless-session-manager.ts'
 // Session manager
-export { createSessionManager } from './headless-session-manager.ts'
+export { createSessionManager } from './headless/headless-session-manager.ts'
diff --git a/src/headless-cli.ts b/src/headless/headless-cli.ts
similarity index 90%
rename from src/headless-cli.ts
rename to src/headless/headless-cli.ts
index e5370a7..1c260c7 100644
--- a/src/headless-cli.ts
+++ b/src/headless/headless-cli.ts
@@ -1,15 +1,15 @@
 #!/usr/bin/env bun
 /**
- * Headless ACP adapter factory CLI entry point.
+ * Headless adapter factory CLI entry point.
  *
  * @remarks
- * This module implements a schema-driven ACP adapter that can interact with
+ * This module implements a schema-driven adapter that can interact with
  * ANY headless CLI agent. The adapter:
  *
  * 1. Reads a JSON schema defining how to interact with the CLI
  * 2. Spawns the CLI process per schema's command + flags
  * 3. Parses stdout using schema's outputEvents mappings
- * 4. Emits ACP session/update notifications
+ * 4. Emits session update notifications
  * 5. Manages session state for multi-turn (stream or iterative mode)
  *
  * @packageDocumentation
@@ -17,7 +17,7 @@
 
 import { createInterface } from 'node:readline'
 import { parseArgs } from 'node:util'
-import { ACP_PROTOCOL_VERSION } from './constants.ts'
+import { PROTOCOL_VERSION } from '../schemas/constants.ts'
 import { type HeadlessAdapterConfig, parseHeadlessConfig } from './headless.schemas.ts'
 import { createSessionManager, type SessionManager } from './headless-session-manager.ts'
 
@@ -104,12 +104,12 @@ const createHandlers = (schema: HeadlessAdapterConfig, sessions: SessionManager)
   const handleInitialize = async (params: unknown): Promise<unknown> => {
     const { protocolVersion } = params as { protocolVersion: number }
 
-    if (protocolVersion !== ACP_PROTOCOL_VERSION) {
+    if (protocolVersion !== PROTOCOL_VERSION) {
       throw new Error(`Unsupported protocol version: ${protocolVersion}`)
     }
 
     return {
-      protocolVersion: ACP_PROTOCOL_VERSION,
+      protocolVersion: PROTOCOL_VERSION,
       agentInfo: {
         name: schema.name,
         version: '1.0.0',
@@ -160,9 +160,9 @@ const createHandlers = (schema: HeadlessAdapterConfig, sessions: SessionManager)
 
     // Execute prompt and stream updates
     const result = await sessions.prompt(sessionId, promptText, (update) => {
-      // Map parsed update to ACP session update format
-      const acpUpdate = mapToACPUpdate(update)
-      sendSessionUpdate(sessionId, acpUpdate)
+      // Map parsed update to session update format
+      const sessionUpdate = mapToSessionUpdate(update)
+      sendSessionUpdate(sessionId, sessionUpdate)
     })
 
     return {
@@ -188,9 +188,9 @@ const createHandlers = (schema: HeadlessAdapterConfig, sessions: SessionManager)
 }
 
 /**
- * Maps a parsed update to ACP session update format.
+ * Maps a parsed update to session update format.
  */
-const mapToACPUpdate = (update: { type: string; content?: string; title?: string; status?: string }): unknown => {
+const mapToSessionUpdate = (update: { type: string; content?: string; title?: string; status?: string }): unknown => {
   switch (update.type) {
     case 'thought':
       return {
@@ -359,7 +359,7 @@ export const headless = async (args: string[]): Promise<void> => {
   if (values.help) {
     // biome-ignore lint/suspicious/noConsole: CLI help output
     console.log(`
-Usage: acp-harness headless --schema <path> [--verbose]
+Usage: agent-eval-harness headless --schema <path> [--verbose]
 
 Arguments:
   -s, --schema    Path to headless adapter schema (JSON)
@@ -367,9 +367,9 @@ Arguments:
   -h, --help      Show this help message
 
 Description:
-  Schema-driven ACP adapter for ANY headless CLI agent. The adapter reads
+  Schema-driven adapter for ANY headless CLI agent. The adapter reads
   a JSON schema defining how to interact with the CLI and translates between
-  ACP protocol and CLI stdio.
+  protocol and CLI stdio.
 
 Schema Format:
   {
@@ -385,23 +385,17 @@ Schema Format:
 
 Examples:
   # Run with Claude headless schema
-  acp-harness headless --schema ./claude-headless.json
+  agent-eval-harness headless --schema ./claude-headless.json
 
   # Use in capture pipeline
-  acp-harness capture prompts.jsonl \\
-    acp-harness headless --schema ./claude-headless.json \\
-    -o results.jsonl
-
-  # Validate adapter compliance
-  acp-harness adapter:check \\
-    acp-harness headless --schema ./gemini-headless.json
+  agent-eval-harness capture prompts.jsonl --schema ./claude-headless.json -o results.jsonl
 `)
     return
   }
 
   if (!values.schema) {
     console.error('Error: --schema is required')
-    console.error('Example: acp-harness headless --schema ./my-agent.json')
+    console.error('Example: agent-eval-harness headless --schema ./my-agent.json')
     process.exit(1)
   }
 
diff --git a/src/headless-history-builder.ts b/src/headless/headless-history-builder.ts
similarity index 100%
rename from src/headless-history-builder.ts
rename to src/headless/headless-history-builder.ts
diff --git a/src/headless-output-parser.ts b/src/headless/headless-output-parser.ts
similarity index 76%
rename from src/headless-output-parser.ts
rename to src/headless/headless-output-parser.ts
index d5a697d..fa89e01 100644
--- a/src/headless-output-parser.ts
+++ b/src/headless/headless-output-parser.ts
@@ -2,19 +2,19 @@
  * Generic output parser for headless CLI agents.
  *
  * @remarks
- * Uses schema-defined mappings to convert CLI JSON output into ACP session updates.
+ * Uses schema-defined mappings to convert CLI JSON output into session updates.
  * Supports JSONPath-like expressions for matching and extraction.
  *
  * @packageDocumentation
  */
 
-import type { HeadlessAdapterConfig, OutputEventMapping } from './headless.schemas.ts'
+import type { HeadlessAdapterConfig, OutputEventMapping, PassthroughTypeMap } from './headless.schemas.ts'
 
 // ============================================================================
 // Types
 // ============================================================================
 
-/** ACP session update types */
+/** session update types */
 export type SessionUpdateType = 'thought' | 'tool_call' | 'message' | 'plan'
 
 /** Parsed session update from CLI output */
@@ -159,6 +159,61 @@ export const jsonPathString = (obj: unknown, path: string): string | undefined =
 // Output Parser Factory
 // ============================================================================
 
+/**
+ * Parse line using passthrough mode.
+ *
+ * @remarks
+ * Passthrough mode directly maps the agent's type field to session update types.
+ * Simpler than JSONPath for agents with well-structured output.
+ *
+ * @param line - JSON string from CLI stdout
+ * @param typeMap - Passthrough type mapping configuration
+ * @returns Parsed update or null if no mapping matches
+ */
+const parsePassthrough = (line: string, typeMap: PassthroughTypeMap): ParsedUpdate | null => {
+  let event: Record<string, unknown>
+  try {
+    event = JSON.parse(line) as Record<string, unknown>
+  } catch {
+    return null
+  }
+
+  const typeField = typeMap.typeField ?? 'type'
+  const eventType = event[typeField]
+
+  if (typeof eventType !== 'string') {
+    return null
+  }
+
+  // Check if this type has a mapping
+  const typeValues = typeMap.typeValues as Record<string, SessionUpdateType> | undefined
+  const mappedType = typeValues?.[eventType]
+  if (!mappedType) {
+    // No explicit mapping - try direct match if it's a valid session type
+    const validTypes = ['thought', 'tool_call', 'message', 'plan'] as const
+    if (!validTypes.includes(eventType as (typeof validTypes)[number])) {
+      return null
+    }
+    // Use the event type directly if it's already a valid session type
+    return {
+      type: eventType as SessionUpdateType,
+      content: typeof event.content === 'string' ? event.content : undefined,
+      title: typeof event.name === 'string' ? event.name : typeof event.title === 'string' ? event.title : undefined,
+      status: typeof event.status === 'string' ? event.status : undefined,
+      raw: event,
+    }
+  }
+
+  // Use mapped type
+  return {
+    type: mappedType,
+    content: typeof event.content === 'string' ? event.content : undefined,
+    title: typeof event.name === 'string' ? event.name : typeof event.title === 'string' ? event.title : undefined,
+    status: typeof event.status === 'string' ? event.status : undefined,
+    raw: event,
+  }
+}
+
 /**
  * Creates an output parser from adapter configuration.
  *
@@ -166,13 +221,17 @@ export const jsonPathString = (obj: unknown, path: string): string | undefined =
  * The parser uses the schema's outputEvents mappings to:
  * 1. Match incoming JSON lines against patterns
  * 2. Extract content using JSONPath expressions
- * 3. Emit ACP session update objects
+ * 3. Emit session update objects
+ *
+ * Supports two modes:
+ * - 'jsonpath' (default): Uses outputEvents for complex pattern matching
+ * - 'passthrough': Direct type mapping for well-structured output
  *
  * @param config - Headless adapter configuration
  * @returns Parser function for individual lines
  */
 export const createOutputParser = (config: HeadlessAdapterConfig) => {
-  const { outputEvents, result } = config
+  const { result, outputMode = 'jsonpath', outputEvents = [], passthroughTypeMap } = config
 
   /**
    * Parses a single JSON line from CLI output.
@@ -181,6 +240,16 @@ export const createOutputParser = (config: HeadlessAdapterConfig) => {
    * @returns Parsed update, array of updates (for wildcard matches), or null if no mapping matches
    */
   const parseLine = (line: string): ParsedUpdate | ParsedUpdate[] | null => {
+    // Use passthrough mode if configured
+    if (outputMode === 'passthrough' && passthroughTypeMap) {
+      return parsePassthrough(line, passthroughTypeMap)
+    }
+
+    // JSONPath mode (default)
+    if (!outputEvents || outputEvents.length === 0) {
+      return null
+    }
+
     let event: unknown
     try {
       event = JSON.parse(line)
diff --git a/src/headless-session-manager.ts b/src/headless/headless-session-manager.ts
similarity index 73%
rename from src/headless-session-manager.ts
rename to src/headless/headless-session-manager.ts
index 40a266f..08b4e68 100644
--- a/src/headless-session-manager.ts
+++ b/src/headless/headless-session-manager.ts
@@ -5,7 +5,7 @@
  * Manages the lifecycle of CLI agent sessions including:
  * - Process spawning and tracking
  * - Stream mode (persistent process) vs iterative mode (new process per turn)
- * - Output parsing and ACP update emission
+ * - Output parsing and update emission
  * - Session state management
  *
  * @packageDocumentation
@@ -38,7 +38,17 @@ export type Session = {
   turnCount: number
 }
 
-/** Update callback for emitting ACP session updates */
+/** Process exit information for debugging */
+export type ProcessExitInfo = {
+  /** Exit code (null if killed by signal or timed out) */
+  exitCode: number | null
+  /** Signal that killed the process (if any) */
+  signal?: string
+  /** Whether the process was killed due to timeout */
+  timedOut: boolean
+}
+
+/** Update callback for emitting session updates */
 export type UpdateCallback = (update: ParsedUpdate) => void
 
 /** Prompt result with final output */
@@ -49,16 +59,27 @@ export type PromptResult = {
   updates: ParsedUpdate[]
   /** Session ID from CLI (if available) */
   cliSessionId?: string
+  /** Process exit information */
+  exitInfo?: ProcessExitInfo
 }
 
 /** Session manager configuration */
 export type SessionManagerConfig = {
   /** Headless adapter configuration */
   schema: HeadlessAdapterConfig
-  /** Default timeout for operations in ms */
+  /** Default timeout for operations in ms (overrides schema timeout) */
   timeout?: number
-  /** Whether to show debug output (constructed commands) */
+  /** Whether to show debug output (constructed commands, raw stdout) */
   verbose?: boolean
+  /**
+   * Debug mode - shows detailed output for troubleshooting.
+   * When enabled:
+   * - Raw CLI stdout/stderr is logged
+   * - JSONPath match attempts and results are shown
+   * - Process spawn/exit info is displayed
+   * - Timing for each stage is reported
+   */
+  debug?: boolean
 }
 
 // ============================================================================
@@ -86,10 +107,26 @@ export type SessionManagerConfig = {
  * @returns Session manager with create, prompt, and cancel methods
  */
 export const createSessionManager = (config: SessionManagerConfig) => {
-  const { schema, timeout = 60000, verbose = false } = config
+  const { schema, verbose = false, debug = false } = config
+  // Use schema timeout if available, otherwise default to 60000ms
+  const schemaTimeout = 'timeout' in schema ? (schema.timeout ?? 60000) : 60000
+  const timeout = config.timeout ?? schemaTimeout
   const sessions = new Map<string, Session>()
   const outputParser = createOutputParser(schema)
 
+  /**
+   * Debug logging helper - only logs when debug mode is enabled.
+   */
+  const debugLog = (category: string, message: string, data?: unknown): void => {
+    if (debug) {
+      const timestamp = new Date().toISOString()
+      console.error(`[${timestamp}] [${category}] ${message}`)
+      if (data !== undefined) {
+        console.error(JSON.stringify(data, null, 2))
+      }
+    }
+  }
+
   /**
    * Creates a new session.
    *
@@ -108,8 +145,16 @@ export const createSessionManager = (config: SessionManagerConfig) => {
 
     // Initialize mode-specific state
     if (schema.sessionMode === 'iterative') {
+      // Normalize historyTemplate: v2 schemas can have object format, convert to string
+      let templateString: string | undefined
+      if (typeof schema.historyTemplate === 'object' && schema.historyTemplate !== null) {
+        // Use turnFormat from object-style template
+        templateString = schema.historyTemplate.turnFormat
+      } else {
+        templateString = schema.historyTemplate
+      }
       session.history = createHistoryBuilder({
-        template: schema.historyTemplate,
+        template: templateString,
       })
     }
 
@@ -190,7 +235,7 @@ export const createSessionManager = (config: SessionManagerConfig) => {
       }
     }
 
-    return collectOutput(session, outputParser, onUpdate, timeout)
+    return collectOutput(session, outputParser, onUpdate, timeout, debugLog)
   }
 
   /**
@@ -221,7 +266,7 @@ export const createSessionManager = (config: SessionManagerConfig) => {
       writePromptToStdin(session.process, fullPrompt, true)
     }
 
-    const result = await collectOutput(session, outputParser, onUpdate, timeout)
+    const result = await collectOutput(session, outputParser, onUpdate, timeout, debugLog)
 
     // Store in history for next turn
     session.history?.addTurn(promptText, result.output)
@@ -269,7 +314,7 @@ export const createSessionManager = (config: SessionManagerConfig) => {
     }
 
     // Debug output: show constructed command
-    if (verbose) {
+    if (verbose || debug) {
       const stdinNote = schema.prompt.stdin ? ' (+ stdin)' : ''
       console.error(`[headless] Command: ${args.join(' ')}${stdinNote}`)
     }
@@ -374,19 +419,22 @@ const writePromptToStdin = (process: Subprocess, prompt: string, closeAfterWrite
  * @param session - Active session
  * @param parser - Output parser
  * @param onUpdate - Update callback
- * @param timeout - Timeout in ms
+ * @param timeoutMs - Timeout in ms
+ * @param logDebug - Debug logging function
  * @returns Collected output and updates
  */
 const collectOutput = async (
   session: Session,
   parser: OutputParser,
   onUpdate: UpdateCallback | undefined,
-  timeout: number,
+  timeoutMs: number,
+  logDebug: (category: string, message: string, data?: unknown) => void,
 ): Promise<PromptResult> => {
   const updates: ParsedUpdate[] = []
   let output = ''
   let cliSessionId: string | undefined
   const accumulatedMessages: string[] = []
+  let timedOut = false
 
   const stdout = session.process?.stdout
   if (!stdout || typeof stdout === 'number') {
@@ -397,18 +445,29 @@ const collectOutput = async (
   const decoder = new TextDecoder()
   let buffer = ''
 
-  const timeoutPromise = new Promise<never>((_, reject) => {
-    setTimeout(() => reject(new Error(`Prompt timed out after ${timeout}ms`)), timeout)
+  // Track timeout with a timer ID so we can clear it
+  let timeoutId: Timer | undefined
+
+  const timeoutPromise = new Promise<'timeout'>((resolve) => {
+    timeoutId = setTimeout(() => resolve('timeout'), timeoutMs)
   })
 
+  logDebug('process', `Starting output collection with ${timeoutMs}ms timeout`)
+
   try {
-    const readLoop = async () => {
+    const readLoop = async (): Promise<'complete'> => {
       readLines: while (true) {
         const { done, value } = await reader.read()
 
-        if (done) break
+        if (done) {
+          logDebug('process', 'Process stdout closed')
+          break
+        }
 
-        buffer += decoder.decode(value, { stream: true })
+        const chunk = decoder.decode(value, { stream: true })
+        logDebug('raw', `Received ${chunk.length} bytes`)
+
+        buffer += chunk
 
         // Process complete lines
         const lines = buffer.split('\n')
@@ -417,6 +476,8 @@ const collectOutput = async (
         for (const line of lines) {
           if (!line.trim()) continue
 
+          logDebug('line', `Processing line: ${line.slice(0, 100)}${line.length > 100 ? '...' : ''}`)
+
           // Parse as update first (so updates are emitted even for result lines)
           const update = parser.parseLine(line)
           if (update !== null) {
@@ -424,6 +485,12 @@ const collectOutput = async (
             const updatesToProcess = Array.isArray(update) ? update : [update]
 
             for (const singleUpdate of updatesToProcess) {
+              logDebug('parse', `Matched event: ${singleUpdate.type}`, {
+                title: singleUpdate.title,
+                status: singleUpdate.status,
+                content: singleUpdate.content?.slice(0, 50),
+              })
+
               updates.push(singleUpdate)
               onUpdate?.(singleUpdate)
 
@@ -438,35 +505,81 @@ const collectOutput = async (
                 if (typeof raw.session_id === 'string') {
                   cliSessionId = raw.session_id
                   session.cliSessionId = cliSessionId
+                  logDebug('session', `Extracted CLI session ID: ${cliSessionId}`)
                 }
               }
             }
+          } else {
+            logDebug('parse', 'No matching event mapping for line')
           }
 
           // Check for final result (after emitting update)
           const resultCheck = parser.parseResult(line)
           if (resultCheck.isResult) {
             output = resultCheck.content
+            logDebug('result', `Found result: ${output.slice(0, 100)}${output.length > 100 ? '...' : ''}`)
             break readLines // Exit both loops immediately on result
           }
         }
       }
+      return 'complete'
     }
 
-    await Promise.race([readLoop(), timeoutPromise])
+    const raceResult = await Promise.race([readLoop(), timeoutPromise])
+
+    if (raceResult === 'timeout') {
+      timedOut = true
+      logDebug('timeout', `Process timed out after ${timeoutMs}ms`)
+
+      // Kill the process on timeout
+      if (session.process && !session.process.killed) {
+        session.process.kill('SIGTERM')
+        logDebug('process', 'Sent SIGTERM to process')
+      }
+    }
   } finally {
+    if (timeoutId) {
+      clearTimeout(timeoutId)
+    }
     reader.releaseLock()
   }
 
   // Fallback: if result contentPath didn't yield output, use accumulated messages
   if (!output && accumulatedMessages.length > 0) {
     output = accumulatedMessages.join('\n')
+    logDebug('fallback', `Using accumulated messages as output (${accumulatedMessages.length} messages)`)
+  }
+
+  // Get exit info from process
+  let exitInfo: ProcessExitInfo | undefined
+  if (session.process) {
+    try {
+      // Wait for process to exit (with a short timeout to not block)
+      const exitCode = await Promise.race([
+        session.process.exited,
+        new Promise<null>((resolve) => setTimeout(() => resolve(null), 1000)),
+      ])
+
+      exitInfo = {
+        exitCode: exitCode,
+        timedOut,
+        signal: timedOut ? 'SIGTERM' : undefined,
+      }
+
+      logDebug('exit', `Process exit info`, exitInfo)
+    } catch {
+      exitInfo = {
+        exitCode: null,
+        timedOut,
+      }
+    }
   }
 
   return {
     output,
     updates,
     cliSessionId,
+    exitInfo,
   }
 }
 
diff --git a/src/headless.schemas.ts b/src/headless/headless.schemas.ts
similarity index 73%
rename from src/headless.schemas.ts
rename to src/headless/headless.schemas.ts
index a27c63f..818ec98 100644
--- a/src/headless.schemas.ts
+++ b/src/headless/headless.schemas.ts
@@ -1,5 +1,5 @@
 /**
- * Zod schemas for headless ACP adapter configuration.
+ * Zod schemas for headless adapter configuration.
  *
  * @remarks
  * These schemas define how to interact with ANY headless CLI agent via a
@@ -16,11 +16,11 @@ import { z } from 'zod'
 // ============================================================================
 
 /**
- * Schema for matching CLI output to ACP update types.
+ * Schema for matching CLI output to session update types.
  *
  * @remarks
  * Uses JSONPath-like patterns to match events in CLI JSON output
- * and map them to ACP session update types.
+ * and map them to session update types.
  */
 export const OutputEventMatchSchema = z.object({
   /** JSONPath to match event type in CLI output (e.g., "$.type") */
@@ -53,18 +53,18 @@ export const OutputEventExtractSchema = z.object({
 export type OutputEventExtract = z.infer<typeof OutputEventExtractSchema>
 
 /**
- * Schema for mapping CLI output events to ACP update types.
+ * Schema for mapping CLI output events to session update types.
  *
  * @remarks
  * Each mapping specifies:
  * 1. How to match events (match.path + match.value)
- * 2. What ACP update type to emit (emitAs)
+ * 2. What session update type to emit (emitAs)
  * 3. What content to extract (extract)
  */
 export const OutputEventMappingSchema = z.object({
   /** Matching criteria for CLI output */
   match: OutputEventMatchSchema,
-  /** ACP session update type to emit */
+  /** session update type to emit */
   emitAs: z.enum(['thought', 'tool_call', 'message', 'plan']),
   /** Content extraction configuration */
   extract: OutputEventExtractSchema.optional(),
@@ -155,20 +155,46 @@ export const ResultConfigSchema = z.object({
 /** Result configuration type */
 export type ResultConfig = z.infer<typeof ResultConfigSchema>
 
+// ============================================================================
+// Passthrough Type Mapping Schema
+// ============================================================================
+
+/**
+ * Schema for passthrough type mapping.
+ *
+ * @remarks
+ * Used when outputMode is 'passthrough' to map agent's native type names
+ * to standard session update types. Useful for agents with well-structured
+ * output that doesn't need complex JSONPath parsing.
+ */
+export const PassthroughTypeMapSchema = z.object({
+  /** JSON field that contains the event type (default: "type") */
+  typeField: z.string().default('type'),
+  /** Mapping from agent type values to session update types */
+  typeValues: z.record(z.string(), z.enum(['thought', 'tool_call', 'message', 'plan'])).optional(),
+})
+
+/** Passthrough type mapping type */
+export type PassthroughTypeMap = z.infer<typeof PassthroughTypeMapSchema>
+
 // ============================================================================
 // Main Adapter Schema
 // ============================================================================
 
 /**
- * Schema for headless ACP adapter configuration.
+ * Schema for headless adapter configuration.
  *
  * @remarks
  * This schema defines everything needed to interact with a headless CLI agent:
  * - Command and flags to spawn
  * - How to pass prompts
- * - How to parse output
+ * - How to parse output (jsonpath or passthrough mode)
  * - Session handling mode
  *
+ * Supports two output parsing modes:
+ * - 'jsonpath': Use outputEvents for complex JSONPath-based parsing (default)
+ * - 'passthrough': Direct type mapping for well-structured output
+ *
  * Example (Claude):
  * ```json
  * {
@@ -176,6 +202,7 @@ export type ResultConfig = z.infer<typeof ResultConfigSchema>
  *   "name": "claude-headless",
  *   "command": ["claude"],
  *   "sessionMode": "stream",
+ *   "timeout": 90000,
  *   "prompt": { "flag": "-p" },
  *   "output": { "flag": "--output-format", "value": "stream-json" },
  *   "outputEvents": [...]
@@ -183,7 +210,7 @@ export type ResultConfig = z.infer<typeof ResultConfigSchema>
  * ```
  */
 export const HeadlessAdapterSchema = z.object({
-  /** Schema version for forward compatibility */
+  /** Schema version */
   version: z.literal(1),
 
   /** Human-readable adapter name */
@@ -199,6 +226,9 @@ export const HeadlessAdapterSchema = z.object({
    */
   sessionMode: z.enum(['stream', 'iterative']),
 
+  /** Default timeout for this agent in milliseconds (can be overridden per-prompt) */
+  timeout: z.number().optional(),
+
   /** How to pass the prompt */
   prompt: PromptConfigSchema,
 
@@ -214,14 +244,41 @@ export const HeadlessAdapterSchema = z.object({
   /** Working directory flag (if CLI needs explicit --cwd) */
   cwdFlag: z.string().optional(),
 
-  /** Output event mappings - how to parse CLI output into ACP updates */
-  outputEvents: z.array(OutputEventMappingSchema),
+  /**
+   * Output parsing mode:
+   * - 'jsonpath': Use outputEvents for complex JSONPath-based parsing (default)
+   * - 'passthrough': Direct type mapping for well-structured output
+   */
+  outputMode: z.enum(['jsonpath', 'passthrough']).default('jsonpath'),
+
+  /** Output event mappings - how to parse CLI output into updates (jsonpath mode) */
+  outputEvents: z.array(OutputEventMappingSchema).optional(),
+
+  /** Type mapping for passthrough mode */
+  passthroughTypeMap: PassthroughTypeMapSchema.optional(),
 
   /** Final result extraction configuration */
   result: ResultConfigSchema,
 
-  /** Template for formatting conversation history (iterative mode only) */
-  historyTemplate: z.string().optional(),
+  /**
+   * Template for formatting conversation history (iterative mode only).
+   *
+   * @remarks
+   * Supports both string format (simple) and object format (advanced):
+   * - String: "User: {{input}}\nAssistant: {{output}}"
+   * - Object: { system: "...", turnFormat: "..." }
+   */
+  historyTemplate: z
+    .union([
+      z.string(),
+      z.object({
+        /** System prefix for accumulated history */
+        system: z.string().optional(),
+        /** Format for each turn: {{input}} and {{output}} placeholders */
+        turnFormat: z.string(),
+      }),
+    ])
+    .optional(),
 })
 
 /** Headless adapter configuration type */
diff --git a/src/headless.types.ts b/src/headless/headless.types.ts
similarity index 88%
rename from src/headless.types.ts
rename to src/headless/headless.types.ts
index 938dfd9..95b0a80 100644
--- a/src/headless.types.ts
+++ b/src/headless/headless.types.ts
@@ -1,5 +1,5 @@
 /**
- * Type exports for headless ACP adapter.
+ * Type exports for headless adapter.
  *
  * @remarks
  * Re-exports all types from the schemas module for external consumers.
diff --git a/src/tests/headless.spec.ts b/src/headless/tests/headless.spec.ts
similarity index 98%
rename from src/tests/headless.spec.ts
rename to src/headless/tests/headless.spec.ts
index f9c2497..9cbd60c 100644
--- a/src/tests/headless.spec.ts
+++ b/src/headless/tests/headless.spec.ts
@@ -1,5 +1,5 @@
 /**
- * Unit tests for headless ACP adapter factory.
+ * Unit tests for headless adapter factory.
  *
  * @remarks
  * Tests cover:
@@ -86,7 +86,7 @@ describe('HeadlessAdapterSchema', () => {
   })
 
   describe('validates schema files from disk', () => {
-    const schemasDir = '.claude/skills/acp-adapters/schemas'
+    const schemasDir = '.claude/skills/headless-adapters/schemas'
 
     test('validates claude-headless.json from disk', async () => {
       const content = await Bun.file(`${schemasDir}/claude-headless.json`).json()
@@ -178,7 +178,7 @@ describe('HeadlessAdapterSchema', () => {
       expect(result.success).toBe(false)
     })
 
-    test('rejects wrong version', () => {
+    test('rejects unsupported version', () => {
       const invalid = { ...validClaudeSchema, version: 2 }
       const result = HeadlessAdapterSchema.safeParse(invalid)
       expect(result.success).toBe(false)
@@ -236,7 +236,7 @@ describe('HeadlessAdapterSchema', () => {
     })
 
     test('throws for invalid input', () => {
-      expect(() => parseHeadlessConfig({ version: 2 })).toThrow()
+      expect(() => parseHeadlessConfig({ version: 99 })).toThrow()
     })
   })
 
@@ -250,7 +250,7 @@ describe('HeadlessAdapterSchema', () => {
     })
 
     test('returns failure for invalid input', () => {
-      const result = safeParseHeadlessConfig({ version: 2 })
+      const result = safeParseHeadlessConfig({ version: 99 })
       expect(result.success).toBe(false)
     })
   })
diff --git a/src/integration_tests/acp-claude.spec.ts b/src/integration_tests/acp-claude.spec.ts
deleted file mode 100644
index 9ed3639..0000000
--- a/src/integration_tests/acp-claude.spec.ts
+++ /dev/null
@@ -1,170 +0,0 @@
-/**
- * Headless Adapter integration Tests - Claude Code
- *
- * @remarks
- * These tests verify the headless ACP adapter works correctly with Claude Code
- * using the schema-driven approach from `.claude/skills/acp-adapters/schemas/`.
- *
- * Run locally with API key:
- * ```bash
- * ANTHROPIC_API_KEY=sk-... bun test ./src/tests/acp-claude.spec.ts
- * ```
- *
- * Prerequisites:
- * 1. Claude CLI installed (`bunx @anthropic-ai/claude-code`)
- * 2. API key: `ANTHROPIC_API_KEY` environment variable
- *
- * These tests make real API calls and consume credits.
- *
- * MCP servers are auto-discovered from project root via:
- * - `.mcp.json` - MCP server configuration
- */
-
-import { afterAll, beforeAll, describe, expect, setDefaultTimeout, test } from 'bun:test'
-import { join } from 'node:path'
-import { type ACPClient, createACPClient } from '../acp-client.ts'
-import { createPrompt, summarizeResponse } from '../acp-helpers.ts'
-
-// Long timeout for real agent interactions (2 minutes)
-setDefaultTimeout(120000)
-
-// Use project root as cwd - agents discover MCP servers from config files
-const PROJECT_ROOT = process.cwd()
-
-// Schema path for Claude headless adapter
-const SCHEMA_PATH = join(PROJECT_ROOT, '.claude/skills/acp-adapters/schemas/claude-headless.json')
-
-// Get API key from environment
-const API_KEY = process.env.ANTHROPIC_API_KEY ?? ''
-
-// Skip all tests if no API key is available
-const describeWithApiKey = API_KEY ? describe : describe.skip
-
-describeWithApiKey('Headless Adapter Integration - Claude', () => {
-  let client: ACPClient
-
-  beforeAll(async () => {
-    // Use headless adapter with Claude schema
-    client = createACPClient({
-      command: ['bun', 'src/headless-cli.ts', '--', '--schema', SCHEMA_PATH],
-      timeout: 120000, // 2 min timeout for initialization
-      env: {
-        ANTHROPIC_API_KEY: API_KEY,
-      },
-    })
-
-    await client.connect()
-  })
-
-  afterAll(async () => {
-    await client?.disconnect()
-  })
-
-  test('connects and initializes via headless adapter', () => {
-    expect(client.isConnected()).toBe(true)
-
-    const initResult = client.getInitializeResult()
-    expect(initResult).toBeDefined()
-    expect(initResult?.protocolVersion).toBeDefined()
-  })
-
-  test('reports agent capabilities', () => {
-    const capabilities = client.getCapabilities()
-    expect(capabilities).toBeDefined()
-  })
-
-  test('creates session with project cwd', async () => {
-    // Session uses project root - agent discovers MCP servers from .mcp.json
-    const session = await client.createSession({
-      cwd: PROJECT_ROOT,
-    })
-
-    expect(session).toBeDefined()
-    expect(session.id).toBeDefined()
-    expect(typeof session.id).toBe('string')
-  })
-
-  test('sends prompt and receives response', async () => {
-    const session = await client.createSession({
-      cwd: PROJECT_ROOT,
-    })
-
-    // Simple prompt that doesn't require tools
-    const { result, updates } = await client.promptSync(
-      session.id,
-      createPrompt('What is 2 + 2? Reply with just the number.'),
-    )
-
-    expect(result).toBeDefined()
-    expect(updates).toBeInstanceOf(Array)
-
-    // Summarize and verify response structure
-    const summary = summarizeResponse(updates)
-    expect(summary.text).toBeDefined()
-    expect(summary.text.length).toBeGreaterThan(0)
-  })
-
-  test('streaming prompt yields updates', async () => {
-    const session = await client.createSession({
-      cwd: PROJECT_ROOT,
-    })
-
-    const events: string[] = []
-
-    for await (const event of client.prompt(session.id, createPrompt('Say "hello" and nothing else.'))) {
-      events.push(event.type)
-      if (event.type === 'complete') {
-        expect(event.result).toBeDefined()
-      }
-    }
-
-    expect(events).toContain('complete')
-  })
-
-  test('uses MCP server from project config', async () => {
-    // This test verifies that Claude discovers MCP servers from .mcp.json
-    // The bun-docs MCP server is configured at project root
-    const session = await client.createSession({
-      cwd: PROJECT_ROOT,
-    })
-
-    // Query the bun-docs MCP server (configured in .mcp.json)
-    const { updates } = await client.promptSync(
-      session.id,
-      createPrompt(
-        'Use the bun-docs MCP server to search for information about Bun.serve(). ' +
-          'What are the key options for creating an HTTP server with Bun?',
-      ),
-    )
-
-    const summary = summarizeResponse(updates)
-
-    // Response should contain Bun server-related information
-    expect(summary.text.length).toBeGreaterThan(0)
-    // Should mention server/HTTP-related concepts from Bun docs
-    expect(summary.text.toLowerCase()).toMatch(/serve|server|http|port|fetch|handler/)
-  })
-
-  test('multi-turn conversation maintains context', async () => {
-    // Multi-turn: multiple prompts to same session via headless adapter
-    const session = await client.createSession({
-      cwd: PROJECT_ROOT,
-    })
-
-    // Turn 1: Establish context
-    const { updates: turn1Updates } = await client.promptSync(
-      session.id,
-      createPrompt('Remember this number: 42. Just confirm you have it.'),
-    )
-    const turn1Summary = summarizeResponse(turn1Updates)
-    expect(turn1Summary.text).toMatch(/42|forty.?two|remember/i)
-
-    // Turn 2: Reference previous context
-    const { updates: turn2Updates } = await client.promptSync(
-      session.id,
-      createPrompt('What number did I ask you to remember? Reply with just the number.'),
-    )
-    const turn2Summary = summarizeResponse(turn2Updates)
-    expect(turn2Summary.text).toMatch(/42/)
-  })
-})
diff --git a/src/integration_tests/acp-gemini.spec.ts b/src/integration_tests/acp-gemini.spec.ts
deleted file mode 100644
index c1602b7..0000000
--- a/src/integration_tests/acp-gemini.spec.ts
+++ /dev/null
@@ -1,174 +0,0 @@
-/**
- * Headless Adapter integration Tests - Gemini CLI
- *
- * @remarks
- * These tests verify the headless ACP adapter works correctly with Gemini CLI
- * using the schema-driven approach from `.claude/skills/acp-adapters/schemas/`.
- *
- * Run locally with API key:
- * ```bash
- * GEMINI_API_KEY=... bun test ./src/tests/acp-gemini.spec.ts
- * ```
- *
- * Prerequisites:
- * 1. Gemini CLI installed (`npm install -g @anthropic-ai/gemini-cli`)
- * 2. API key: `GEMINI_API_KEY` environment variable
- *
- * These tests make real API calls and consume credits.
- *
- * MCP servers are auto-discovered from project root via:
- * - `.gemini/settings.json` - Gemini MCP server configuration
- */
-
-import { afterAll, beforeAll, describe, expect, setDefaultTimeout, test } from 'bun:test'
-import { join } from 'node:path'
-import { type ACPClient, createACPClient } from '../acp-client.ts'
-import { createPrompt, summarizeResponse } from '../acp-helpers.ts'
-
-// Long timeout for real agent interactions (2 minutes)
-setDefaultTimeout(120000)
-
-// Use project root as cwd - agents discover MCP servers from config files
-const PROJECT_ROOT = process.cwd()
-
-// Schema path for Gemini headless adapter
-const SCHEMA_PATH = join(PROJECT_ROOT, '.claude/skills/acp-adapters/schemas/gemini-headless.json')
-
-// Gemini CLI accepts GEMINI_API_KEY
-// Use either one if available
-const GEMINI_API_KEY = process.env.GEMINI_API_KEY ?? ''
-
-// Skip all tests if no API key is available
-const describeWithApiKey = GEMINI_API_KEY ? describe : describe.skip
-
-describeWithApiKey('Headless Adapter Integration - Gemini', () => {
-  let client: ACPClient
-
-  beforeAll(async () => {
-    // Use headless adapter with Gemini schema
-    // Pass both API key variants - Gemini CLI should pick up whichever it prefers
-    client = createACPClient({
-      command: ['bun', 'src/headless-cli.ts', '--', '--schema', SCHEMA_PATH],
-      timeout: 120000, // 2 min timeout for initialization
-      env: {
-        GEMINI_API_KEY,
-      },
-    })
-
-    await client.connect()
-  })
-
-  afterAll(async () => {
-    await client?.disconnect()
-  })
-
-  test('connects and initializes via headless adapter', () => {
-    expect(client.isConnected()).toBe(true)
-
-    const initResult = client.getInitializeResult()
-    expect(initResult).toBeDefined()
-    expect(initResult?.protocolVersion).toBeDefined()
-  })
-
-  test('reports agent capabilities', () => {
-    const capabilities = client.getCapabilities()
-    expect(capabilities).toBeDefined()
-  })
-
-  test('creates session with project cwd', async () => {
-    // Session uses project root - agent discovers MCP servers from .gemini/settings.json
-    const session = await client.createSession({
-      cwd: PROJECT_ROOT,
-    })
-
-    expect(session).toBeDefined()
-    expect(session.id).toBeDefined()
-    expect(typeof session.id).toBe('string')
-  })
-
-  test('sends prompt and receives response', async () => {
-    const session = await client.createSession({
-      cwd: PROJECT_ROOT,
-    })
-
-    // Simple prompt that doesn't require tools
-    const { result, updates } = await client.promptSync(
-      session.id,
-      createPrompt('What is 2 + 2? Reply with just the number.'),
-    )
-
-    expect(result).toBeDefined()
-    expect(updates).toBeInstanceOf(Array)
-
-    // Summarize and verify response structure
-    const summary = summarizeResponse(updates)
-    expect(summary.text).toBeDefined()
-    expect(summary.text.length).toBeGreaterThan(0)
-    // Should contain "4" somewhere in the response
-    expect(summary.text).toMatch(/4/)
-  })
-
-  test('streaming prompt yields updates', async () => {
-    const session = await client.createSession({
-      cwd: PROJECT_ROOT,
-    })
-
-    const events: string[] = []
-
-    for await (const event of client.prompt(session.id, createPrompt('Say "hello" and nothing else.'))) {
-      events.push(event.type)
-      if (event.type === 'complete') {
-        expect(event.result).toBeDefined()
-      }
-    }
-
-    expect(events).toContain('complete')
-  })
-
-  test('uses MCP server from project config', async () => {
-    // This test verifies that Gemini discovers MCP servers from .gemini/settings.json
-    // The agent-client-protocol MCP server is configured at project root
-    const session = await client.createSession({
-      cwd: PROJECT_ROOT,
-    })
-
-    // Query the agent-client-protocol MCP server (configured in .gemini/settings.json)
-    const { updates } = await client.promptSync(
-      session.id,
-      createPrompt(
-        'Use the agent-client-protocol MCP server to search for information about ACP. ' +
-          'What is the Agent Client Protocol and what problem does it solve?',
-      ),
-    )
-
-    const summary = summarizeResponse(updates)
-
-    // Response should contain ACP-related information
-    expect(summary.text.length).toBeGreaterThan(0)
-    // Should mention protocol/agent-related concepts
-    expect(summary.text.toLowerCase()).toMatch(/agent|protocol|client|json-rpc|stdio/)
-  })
-
-  test('multi-turn conversation maintains context (iterative mode)', async () => {
-    // Multi-turn via headless adapter in iterative mode (history accumulation)
-    const session = await client.createSession({
-      cwd: PROJECT_ROOT,
-    })
-
-    // Turn 1: Establish context
-    const { updates: turn1Updates } = await client.promptSync(
-      session.id,
-      createPrompt('Remember this number: 42. Just confirm you have it.'),
-    )
-    const turn1Summary = summarizeResponse(turn1Updates)
-    expect(turn1Summary.text).toMatch(/42|forty.?two|remember/i)
-
-    // Turn 2: Reference previous context
-    const { updates: turn2Updates } = await client.promptSync(
-      session.id,
-      createPrompt('What number did I ask you to remember? Reply with just the number.'),
-    )
-    const turn2Summary = summarizeResponse(turn2Updates)
-    expect(turn2Summary.text).toMatch(/42/)
-  })
-})
diff --git a/src/integration_tests/claude.spec.ts b/src/integration_tests/claude.spec.ts
new file mode 100644
index 0000000..ccda94a
--- /dev/null
+++ b/src/integration_tests/claude.spec.ts
@@ -0,0 +1,157 @@
+/**
+ * Integration tests for Claude Code headless adapter.
+ *
+ * @remarks
+ * Tests verify the headless session manager works correctly with Claude Code CLI
+ * using the schema-driven approach from `.claude/skills/headless-adapters/schemas/`.
+ *
+ * Run locally with API key:
+ * ```bash
+ * ANTHROPIC_API_KEY=sk-... bun test ./src/integration_tests/claude.spec.ts
+ * ```
+ *
+ * Prerequisites:
+ * 1. Claude CLI installed (`curl -fsSL https://claude.ai/install.sh | bash`)
+ * 2. API key: `ANTHROPIC_API_KEY` environment variable
+ *
+ * These tests make real API calls and consume credits.
+ */
+
+import { afterAll, beforeAll, describe, expect, setDefaultTimeout, test } from 'bun:test'
+import { join } from 'node:path'
+import { parseHeadlessConfig } from '../headless/headless.schemas.ts'
+import { createSessionManager } from '../headless/headless-session-manager.ts'
+
+// Long timeout for real agent interactions (2 minutes)
+setDefaultTimeout(120000)
+
+// Use project root as cwd - agents discover MCP servers from config files
+const PROJECT_ROOT = process.cwd()
+
+// Schema path for Claude headless adapter
+const SCHEMA_PATH = join(PROJECT_ROOT, '.claude/skills/headless-adapters/schemas/claude-headless.json')
+
+// Get API key from environment
+const API_KEY = process.env.ANTHROPIC_API_KEY ?? ''
+
+// Skip all tests if no API key is available
+const describeWithApiKey = API_KEY ? describe : describe.skip
+
+describeWithApiKey('Claude Code Integration', () => {
+  let sessionManager: ReturnType<typeof createSessionManager>
+  let schemaConfig: ReturnType<typeof parseHeadlessConfig>
+
+  beforeAll(async () => {
+    // Load JSON from file, then parse with Zod schema
+    const schemaJson = await Bun.file(SCHEMA_PATH).json()
+    schemaConfig = parseHeadlessConfig(schemaJson)
+
+    // Create session manager with the schema
+    sessionManager = createSessionManager({
+      schema: schemaConfig,
+      timeout: 120000,
+      debug: false,
+    })
+  })
+
+  afterAll(async () => {
+    // Cleanup handled automatically by session manager
+  })
+
+  test('creates session successfully', async () => {
+    const session = await sessionManager.create(PROJECT_ROOT)
+
+    expect(session).toBeDefined()
+    expect(session.id).toBeDefined()
+    expect(typeof session.id).toBe('string')
+    expect(session.active).toBe(true)
+    expect(session.cwd).toBe(PROJECT_ROOT)
+  })
+
+  test('sends prompt and receives response', async () => {
+    const session = await sessionManager.create(PROJECT_ROOT)
+
+    // Simple prompt that doesn't require tools
+    const result = await sessionManager.prompt(session.id, 'What is 2 + 2? Reply with just the number.')
+
+    expect(result).toBeDefined()
+    expect(result.output).toBeDefined()
+    expect(result.output.length).toBeGreaterThan(0)
+    expect(result.updates).toBeInstanceOf(Array)
+
+    // Should contain "4" somewhere in the response
+    expect(result.output).toMatch(/4/)
+  })
+
+  test('collects trajectory updates during execution', async () => {
+    const session = await sessionManager.create(PROJECT_ROOT)
+    const collectedUpdates: unknown[] = []
+
+    const result = await sessionManager.prompt(session.id, 'Say "hello" and nothing else.', (update) => {
+      collectedUpdates.push(update)
+    })
+
+    expect(result.updates.length).toBeGreaterThan(0)
+
+    // Should have at least one message update
+    const messageUpdates = result.updates.filter((u) => u.type === 'message')
+    expect(messageUpdates.length).toBeGreaterThan(0)
+  })
+
+  test('uses MCP server from project config', async () => {
+    // This test verifies that Claude discovers MCP servers from .mcp.json
+    // The bun-docs MCP server is configured at project root
+    const session = await sessionManager.create(PROJECT_ROOT)
+
+    // Query the bun-docs MCP server (configured in .mcp.json)
+    const result = await sessionManager.prompt(
+      session.id,
+      'Use the bun-docs MCP server to search for information about Bun.serve(). ' +
+        'What are the key options for creating an HTTP server with Bun?',
+    )
+
+    // Response should contain Bun server-related information
+    expect(result.output.length).toBeGreaterThan(0)
+    // Should mention server/HTTP-related concepts from Bun docs
+    expect(result.output.toLowerCase()).toMatch(/serve|server|http|port|fetch|handler/)
+  })
+
+  test('multi-turn conversation maintains context (stream mode)', async () => {
+    // Multi-turn: multiple prompts to same session
+    const session = await sessionManager.create(PROJECT_ROOT)
+
+    // Turn 1: Establish context
+    const turn1Result = await sessionManager.prompt(session.id, 'Remember this number: 42. Just confirm you have it.')
+    expect(turn1Result.output).toMatch(/42|forty.?two|remember/i)
+
+    // Turn 2: Reference previous context
+    const turn2Result = await sessionManager.prompt(
+      session.id,
+      'What number did I ask you to remember? Reply with just the number.',
+    )
+    expect(turn2Result.output).toMatch(/42/)
+  })
+
+  test('receives valid trajectory updates', async () => {
+    const session = await sessionManager.create(PROJECT_ROOT)
+
+    // Prompt that generates a response with trajectory updates
+    const result = await sessionManager.prompt(
+      session.id,
+      'What programming language is this project written in? Look at the file extensions.',
+    )
+
+    // Result should have output
+    expect(result.output).toBeDefined()
+    expect(result.output.length).toBeGreaterThan(0)
+
+    // Should have collected updates during execution
+    expect(result.updates).toBeInstanceOf(Array)
+    expect(result.updates.length).toBeGreaterThan(0)
+
+    // All updates should have valid types
+    const validTypes = ['thought', 'tool_call', 'message', 'plan']
+    const allValidTypes = result.updates.every((u) => validTypes.includes(u.type))
+    expect(allValidTypes).toBe(true)
+  })
+})
diff --git a/src/integration_tests/gemini.spec.ts b/src/integration_tests/gemini.spec.ts
new file mode 100644
index 0000000..76cf2ea
--- /dev/null
+++ b/src/integration_tests/gemini.spec.ts
@@ -0,0 +1,139 @@
+/**
+ * Integration tests for Gemini CLI headless adapter.
+ *
+ * @remarks
+ * Tests verify the headless session manager works correctly with Gemini CLI
+ * using the schema-driven approach from `.claude/skills/headless-adapters/schemas/`.
+ *
+ * Run locally with API key:
+ * ```bash
+ * GEMINI_API_KEY=... bun test ./src/integration_tests/gemini.spec.ts
+ * ```
+ *
+ * Prerequisites:
+ * 1. Gemini CLI installed (`npm install -g @google/gemini-cli`)
+ * 2. API key: `GEMINI_API_KEY` environment variable
+ *
+ * These tests make real API calls and consume credits.
+ */
+
+import { afterAll, beforeAll, describe, expect, setDefaultTimeout, test } from 'bun:test'
+import { join } from 'node:path'
+import { parseHeadlessConfig } from '../headless/headless.schemas.ts'
+import { createSessionManager } from '../headless/headless-session-manager.ts'
+
+// Long timeout for real agent interactions (2 minutes)
+setDefaultTimeout(120000)
+
+// Use project root as cwd - agents discover MCP servers from config files
+const PROJECT_ROOT = process.cwd()
+
+// Schema path for Gemini headless adapter
+const SCHEMA_PATH = join(PROJECT_ROOT, '.claude/skills/headless-adapters/schemas/gemini-headless.json')
+
+// Get API key from environment
+const GEMINI_API_KEY = process.env.GEMINI_API_KEY ?? ''
+
+// Skip all tests if no API key is available
+const describeWithApiKey = GEMINI_API_KEY ? describe : describe.skip
+
+describeWithApiKey('Gemini CLI Integration', () => {
+  let sessionManager: ReturnType<typeof createSessionManager>
+  let schemaConfig: ReturnType<typeof parseHeadlessConfig>
+
+  beforeAll(async () => {
+    // Load JSON from file, then parse with Zod schema
+    const schemaJson = await Bun.file(SCHEMA_PATH).json()
+    schemaConfig = parseHeadlessConfig(schemaJson)
+
+    // Create session manager with the schema
+    sessionManager = createSessionManager({
+      schema: schemaConfig,
+      timeout: 120000,
+      debug: false,
+    })
+  })
+
+  afterAll(async () => {
+    // Cleanup handled automatically by session manager
+  })
+
+  test('creates session successfully', async () => {
+    const session = await sessionManager.create(PROJECT_ROOT)
+
+    expect(session).toBeDefined()
+    expect(session.id).toBeDefined()
+    expect(typeof session.id).toBe('string')
+    expect(session.active).toBe(true)
+    expect(session.cwd).toBe(PROJECT_ROOT)
+  })
+
+  test('sends prompt and receives response', async () => {
+    const session = await sessionManager.create(PROJECT_ROOT)
+
+    // Simple prompt that doesn't require tools
+    const result = await sessionManager.prompt(session.id, 'What is 2 + 2? Reply with just the number.')
+
+    expect(result).toBeDefined()
+    expect(result.output).toBeDefined()
+    expect(result.output.length).toBeGreaterThan(0)
+    expect(result.updates).toBeInstanceOf(Array)
+
+    // Should contain "4" somewhere in the response
+    expect(result.output).toMatch(/4/)
+  })
+
+  test('collects trajectory updates during execution', async () => {
+    const session = await sessionManager.create(PROJECT_ROOT)
+    const collectedUpdates: unknown[] = []
+
+    const result = await sessionManager.prompt(session.id, 'Say "hello" and nothing else.', (update) => {
+      collectedUpdates.push(update)
+    })
+
+    expect(result.updates.length).toBeGreaterThan(0)
+
+    // Should have at least one message update
+    const messageUpdates = result.updates.filter((u) => u.type === 'message')
+    expect(messageUpdates.length).toBeGreaterThan(0)
+  })
+
+  test('multi-turn conversation maintains context (iterative mode)', async () => {
+    // Multi-turn via headless adapter in iterative mode (history accumulation)
+    const session = await sessionManager.create(PROJECT_ROOT)
+
+    // Turn 1: Establish context
+    const turn1Result = await sessionManager.prompt(session.id, 'Remember this number: 42. Just confirm you have it.')
+    expect(turn1Result.output).toMatch(/42|forty.?two|remember/i)
+
+    // Turn 2: Reference previous context
+    const turn2Result = await sessionManager.prompt(
+      session.id,
+      'What number did I ask you to remember? Reply with just the number.',
+    )
+    expect(turn2Result.output).toMatch(/42/)
+  })
+
+  test('handles simple math question correctly', async () => {
+    const session = await sessionManager.create(PROJECT_ROOT)
+
+    const result = await sessionManager.prompt(session.id, 'Calculate 15 * 7. Reply with just the number.')
+
+    // Gemini CLI may include formatting variations (newlines, spaces)
+    // Strip whitespace to verify the correct answer is present
+    expect(result.output.replace(/\s/g, '')).toContain('105')
+  })
+
+  test('processes longer response without timeout', async () => {
+    const session = await sessionManager.create(PROJECT_ROOT)
+
+    const result = await sessionManager.prompt(
+      session.id,
+      'List 5 programming languages and one key feature of each. Be brief.',
+    )
+
+    expect(result.output.length).toBeGreaterThan(50)
+    // Should mention at least some programming languages
+    expect(result.output.toLowerCase()).toMatch(/python|javascript|java|rust|go|typescript|c\+\+|ruby/)
+  })
+})
diff --git a/src/pipeline.ts b/src/pipeline.ts
new file mode 100644
index 0000000..7c3c1bd
--- /dev/null
+++ b/src/pipeline.ts
@@ -0,0 +1,34 @@
+/**
+ * Pipeline commands re-export.
+ *
+ * @remarks
+ * Public API for pipeline commands. Import from here for external use.
+ *
+ * @packageDocumentation
+ */
+
+export {
+  // Types
+  type CompareConfig,
+  type ComparisonGrader,
+  type ComparisonGraderInput,
+  type ComparisonGraderResult,
+  type ComparisonRanking,
+  type ComparisonResult,
+  // Commands
+  compare,
+  type ExtractConfig,
+  type ExtractedResult,
+  extract,
+  type FormatConfig,
+  type FormatStyle,
+  format,
+  type GradeConfig,
+  type GradedResult,
+  grade,
+  type LabeledRun,
+  type RawOutput,
+  type RunConfig,
+  type RunMode,
+  run,
+} from './pipeline/pipeline.ts'
diff --git a/src/pipeline/compare.ts b/src/pipeline/compare.ts
new file mode 100644
index 0000000..14d3b44
--- /dev/null
+++ b/src/pipeline/compare.ts
@@ -0,0 +1,325 @@
+/**
+ * Pipeline compare command - compare multiple runs of the same prompts.
+ *
+ * @remarks
+ * Compares results from different configurations (agents, MCP servers, models)
+ * using a user-provided comparison grader that ranks the runs.
+ *
+ * Terminology: "runs" (not "agents") because comparisons can be:
+ * - Same agent, different MCP servers
+ * - Same agent, different skills enabled
+ * - Same agent, different system prompts
+ * - Same agent, different model versions
+ * - Different agents entirely
+ *
+ * @packageDocumentation
+ */
+
+import { basename, extname } from 'node:path'
+import { parseArgs } from 'node:util'
+import { loadResults, logProgress, writeOutput } from '../core.ts'
+import type { CaptureResult } from '../schemas.ts'
+import type {
+  CompareConfig,
+  ComparisonGrader,
+  ComparisonGraderInput,
+  ComparisonResult,
+  LabeledRun,
+} from './pipeline.types.ts'
+
+/**
+ * Load comparison grader from file.
+ *
+ * @remarks
+ * Similar to loadGrader but expects ComparisonGrader interface.
+ *
+ * @param path - Path to grader module
+ * @returns Loaded comparison grader function
+ */
+const loadComparisonGrader = async (path: string): Promise<ComparisonGrader> => {
+  const module = await import(path)
+
+  if (typeof module.grade === 'function') {
+    return module.grade as ComparisonGrader
+  }
+  if (typeof module.default === 'function') {
+    return module.default as ComparisonGrader
+  }
+  if (typeof module.compare === 'function') {
+    return module.compare as ComparisonGrader
+  }
+
+  throw new Error(`Comparison grader must export 'grade', 'compare', or 'default' function`)
+}
+
+/**
+ * Derive label from file path.
+ *
+ * @param path - File path
+ * @returns Label derived from filename without extension
+ */
+const labelFromPath = (path: string): string => {
+  const base = basename(path)
+  const ext = extname(base)
+  return base.slice(0, -ext.length)
+}
+
+/**
+ * Parse labeled run argument.
+ *
+ * @remarks
+ * Supports formats:
+ * - "path.jsonl" - label derived from filename
+ * - "label:path.jsonl" - explicit label
+ *
+ * @param arg - Run argument string
+ * @returns Labeled run object
+ */
+const parseLabeledRun = (arg: string): LabeledRun => {
+  const colonIndex = arg.indexOf(':')
+
+  // Check if this looks like a label:path format (not a Windows drive letter)
+  if (colonIndex > 0 && colonIndex !== 1) {
+    return {
+      label: arg.slice(0, colonIndex),
+      path: arg.slice(colonIndex + 1),
+    }
+  }
+
+  return {
+    label: labelFromPath(arg),
+    path: arg,
+  }
+}
+
+/**
+ * Execute pipeline compare with configuration.
+ *
+ * @param config - Compare configuration
+ */
+export const runCompare = async (config: CompareConfig): Promise<void> => {
+  const { runs, graderPath, outputPath, progress = false } = config
+
+  if (runs.length < 2) {
+    throw new Error('At least 2 runs required for comparison')
+  }
+
+  // Load comparison grader
+  const grader = await loadComparisonGrader(graderPath)
+
+  logProgress(`Comparing ${runs.length} runs with: ${graderPath}`, progress)
+  for (const run of runs) {
+    logProgress(`  - ${run.label}: ${run.path}`, progress)
+  }
+
+  // Load all runs
+  const runResults: Record<string, CaptureResult[]> = {}
+  for (const run of runs) {
+    logProgress(`Loading ${run.label}...`, progress)
+    runResults[run.label] = await loadResults(run.path)
+  }
+
+  // Build map of prompt IDs to runs
+  const promptIds = new Set<string>()
+  for (const results of Object.values(runResults)) {
+    for (const result of results) {
+      promptIds.add(result.id)
+    }
+  }
+
+  logProgress(`Comparing ${promptIds.size} prompts...`, progress)
+
+  let isFirstOutput = true
+
+  // Clear output file if specified
+  if (outputPath) {
+    await Bun.write(outputPath, '')
+  }
+
+  const results: ComparisonResult[] = []
+
+  for (const promptId of promptIds) {
+    logProgress(`  ${promptId}`, progress)
+
+    // Build comparison input
+    const runsData: ComparisonGraderInput['runs'] = {}
+    let input: string | string[] = ''
+    let hint: string | undefined
+
+    for (const [label, labelResults] of Object.entries(runResults)) {
+      const result = labelResults.find((r) => r.id === promptId)
+      if (result) {
+        runsData[label] = {
+          output: result.output,
+          trajectory: result.trajectory,
+        }
+        // Use first found input/hint as the reference
+        if (!input) {
+          input = result.input
+          hint = result.hint
+        }
+      }
+    }
+
+    // Skip if not present in at least 2 runs
+    if (Object.keys(runsData).length < 2) {
+      logProgress(`    Skipped (only in ${Object.keys(runsData).length} run)`, progress)
+      continue
+    }
+
+    // Apply comparison grader
+    const graderInput: ComparisonGraderInput = {
+      id: promptId,
+      input,
+      hint,
+      runs: runsData,
+    }
+
+    const graderResult = await grader(graderInput)
+
+    const comparisonResult: ComparisonResult = {
+      id: promptId,
+      input,
+      hint,
+      rankings: graderResult.rankings,
+      reasoning: graderResult.reasoning,
+    }
+
+    results.push(comparisonResult)
+
+    // Log winner
+    const winner = graderResult.rankings.find((r) => r.rank === 1)
+    if (winner) {
+      logProgress(`    Winner: ${winner.run} (${winner.score.toFixed(2)})`, progress)
+    }
+
+    await writeOutput(JSON.stringify(comparisonResult), outputPath, !isFirstOutput)
+    isFirstOutput = false
+  }
+
+  // Summary statistics
+  logProgress('', progress)
+  logProgress('=== Summary ===', progress)
+
+  const winCounts: Record<string, number> = {}
+  for (const run of runs) {
+    winCounts[run.label] = 0
+  }
+
+  for (const result of results) {
+    const winner = result.rankings.find((r) => r.rank === 1)
+    if (winner && winner.run in winCounts) {
+      const currentCount = winCounts[winner.run] ?? 0
+      winCounts[winner.run] = currentCount + 1
+    }
+  }
+
+  for (const [label, wins] of Object.entries(winCounts)) {
+    const pct = ((wins / results.length) * 100).toFixed(1)
+    logProgress(`  ${label}: ${wins} wins (${pct}%)`, progress)
+  }
+
+  logProgress('Done!', progress)
+}
+
+/**
+ * Pipeline compare command CLI handler.
+ *
+ * @param args - Command line arguments (after 'compare')
+ */
+export const compare = async (args: string[]): Promise<void> => {
+  const { values, positionals } = parseArgs({
+    args,
+    options: {
+      run: { type: 'string', multiple: true },
+      grader: { type: 'string', short: 'g' },
+      output: { type: 'string', short: 'o' },
+      progress: { type: 'boolean', default: false },
+      help: { type: 'boolean', short: 'h' },
+    },
+    allowPositionals: true,
+  })
+
+  if (values.help) {
+    // biome-ignore lint/suspicious/noConsole: CLI help output
+    console.log(`
+Usage: agent-eval-harness compare [files...] --grader <grader> [options]
+
+Compare multiple runs of the same prompts.
+
+Arguments:
+  files...          Result files to compare (positional, unlimited)
+
+Options:
+  --run             Labeled run format: "label:path.jsonl" (alternative to positional)
+  -g, --grader      Path to comparison grader (.ts/.js module) (required)
+  -o, --output      Output file (default: stdout)
+  --progress        Show progress to stderr
+  -h, --help        Show this help message
+
+Comparison Grader:
+  Must export 'grade' or 'compare' function with signature:
+    (params: ComparisonGraderInput) => Promise<ComparisonGraderResult>
+
+  Input includes all runs' results for a single prompt.
+  Output should rank runs from best to worst.
+
+Examples:
+  # Compare multiple result files (positional)
+  agent-eval-harness compare run1.jsonl run2.jsonl run3.jsonl -g ./compare-grader.ts
+
+  # With explicit labels
+  agent-eval-harness compare \\
+    --run "with-bun-mcp:results-bun.jsonl" \\
+    --run "vanilla:results-vanilla.jsonl" \\
+    -g ./compare-grader.ts
+
+  # Mix positional and labeled
+  agent-eval-harness compare results-*.jsonl \\
+    --run "baseline:baseline.jsonl" \\
+    -g ./compare-grader.ts -o comparison.jsonl
+
+  # Typical workflow
+  # 1. Capture with different configs
+  agent-eval-harness capture prompts.jsonl -s claude.json -o vanilla.jsonl
+  agent-eval-harness capture prompts.jsonl -s claude-with-mcp.json -o with-mcp.jsonl
+
+  # 2. Compare results
+  agent-eval-harness compare vanilla.jsonl with-mcp.jsonl -g ./compare-grader.ts
+`)
+    return
+  }
+
+  if (!values.grader) {
+    console.error('Error: --grader is required')
+    process.exit(1)
+  }
+
+  // Collect runs from positional args and --run flags
+  const runs: LabeledRun[] = []
+
+  // Positional arguments (file paths)
+  for (const arg of positionals) {
+    runs.push(parseLabeledRun(arg))
+  }
+
+  // --run flags
+  if (values.run) {
+    for (const arg of values.run) {
+      runs.push(parseLabeledRun(arg))
+    }
+  }
+
+  if (runs.length < 2) {
+    console.error('Error: At least 2 result files required for comparison')
+    console.error('Example: agent-eval-harness compare run1.jsonl run2.jsonl -g ./grader.ts')
+    process.exit(1)
+  }
+
+  await runCompare({
+    runs,
+    graderPath: values.grader,
+    outputPath: values.output,
+    progress: values.progress,
+  })
+}
diff --git a/src/pipeline/extract.ts b/src/pipeline/extract.ts
new file mode 100644
index 0000000..3ec29ef
--- /dev/null
+++ b/src/pipeline/extract.ts
@@ -0,0 +1,241 @@
+/**
+ * Pipeline extract command - parse raw output into trajectories.
+ *
+ * @remarks
+ * Converts RawOutput from `run` command into ExtractedResult with
+ * parsed trajectory and final output. Uses the same schema-driven
+ * parsing as the capture command.
+ *
+ * @packageDocumentation
+ */
+
+import { parseArgs } from 'node:util'
+import { loadJsonl, logProgress, writeOutput } from '../core.ts'
+import { parseHeadlessConfig } from '../headless/headless.schemas.ts'
+import { createOutputParser } from '../headless/headless-output-parser.ts'
+import type { TrajectoryStep } from '../schemas.ts'
+import type { ExtractedResult, RawOutput } from './pipeline.types.ts'
+
+/**
+ * Extract trajectory from raw output using schema parser.
+ *
+ * @param rawOutput - Raw output from run command
+ * @param parser - Output parser created from schema
+ * @returns Extracted result with trajectory
+ */
+const extractFromRaw = (rawOutput: RawOutput, parser: ReturnType<typeof createOutputParser>): ExtractedResult => {
+  const trajectory: TrajectoryStep[] = []
+  let finalOutput = ''
+  let toolErrors = false
+
+  // Parse each raw line
+  for (const line of rawOutput.rawLines) {
+    // Try to parse as trajectory update
+    const parsed = parser.parseLine(line)
+    if (parsed) {
+      const updates = Array.isArray(parsed) ? parsed : [parsed]
+      for (const update of updates) {
+        const timestamp = Date.now() - rawOutput.timing.start
+
+        if (update.type === 'thought') {
+          trajectory.push({
+            type: 'thought',
+            content: update.content ?? '',
+            timestamp,
+          })
+        } else if (update.type === 'message') {
+          trajectory.push({
+            type: 'message',
+            content: update.content ?? '',
+            timestamp,
+          })
+        } else if (update.type === 'tool_call') {
+          trajectory.push({
+            type: 'tool_call',
+            name: update.title ?? 'unknown',
+            status: update.status ?? 'pending',
+            timestamp,
+          })
+          if (update.status === 'failed') {
+            toolErrors = true
+          }
+        } else if (update.type === 'plan') {
+          trajectory.push({
+            type: 'plan',
+            entries: [],
+            timestamp,
+          })
+        }
+      }
+    }
+
+    // Try to parse as result
+    const result = parser.parseResult(line)
+    if (result.isResult) {
+      finalOutput = result.content
+    }
+  }
+
+  // If no explicit result, extract from messages
+  if (!finalOutput) {
+    finalOutput = trajectory
+      .filter((step): step is TrajectoryStep & { type: 'message' } => step.type === 'message')
+      .map((step) => step.content)
+      .join('\n')
+  }
+
+  return {
+    id: rawOutput.id,
+    input: rawOutput.input,
+    hint: rawOutput.hint,
+    output: finalOutput,
+    trajectory,
+    toolErrors: toolErrors || !!rawOutput.error,
+    timing: rawOutput.timing,
+    ...(rawOutput.error && { error: rawOutput.error }),
+  }
+}
+
+/**
+ * Execute pipeline extract with configuration.
+ *
+ * @param schemaPath - Path to headless adapter schema
+ * @param rawOutputs - Raw outputs from run command
+ * @param outputPath - Optional output file path
+ * @param progress - Show progress to stderr
+ */
+export const runExtract = async (
+  schemaPath: string,
+  rawOutputs: RawOutput[],
+  outputPath?: string,
+  progress = false,
+): Promise<void> => {
+  // Load and validate schema
+  const schemaFile = Bun.file(schemaPath)
+  if (!(await schemaFile.exists())) {
+    throw new Error(`Schema file not found: ${schemaPath}`)
+  }
+
+  const rawSchema = await schemaFile.json()
+  const schema = parseHeadlessConfig(rawSchema)
+  const parser = createOutputParser(schema)
+
+  logProgress(`Extracting with schema: ${schema.name}`, progress)
+
+  let isFirstOutput = true
+
+  // Clear output file if specified
+  if (outputPath) {
+    await Bun.write(outputPath, '')
+  }
+
+  for (let i = 0; i < rawOutputs.length; i++) {
+    const rawOutput = rawOutputs[i]
+    if (!rawOutput) continue
+
+    logProgress(`[${i + 1}/${rawOutputs.length}] ${rawOutput.id}`, progress)
+
+    const extracted = extractFromRaw(rawOutput, parser)
+
+    await writeOutput(JSON.stringify(extracted), outputPath, !isFirstOutput)
+    isFirstOutput = false
+  }
+
+  logProgress('Done!', progress)
+}
+
+/**
+ * Read raw outputs from stdin.
+ *
+ * @returns Array of parsed raw outputs or null if stdin is empty
+ */
+const readStdinRawOutputs = async (): Promise<RawOutput[] | null> => {
+  if (process.stdin.isTTY) {
+    return null
+  }
+
+  const chunks: Buffer[] = []
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk)
+  }
+
+  const content = Buffer.concat(chunks).toString('utf-8').trim()
+  if (!content) return null
+
+  return content
+    .split('\n')
+    .filter(Boolean)
+    .map((line) => JSON.parse(line) as RawOutput)
+}
+
+/**
+ * Pipeline extract command CLI handler.
+ *
+ * @param args - Command line arguments (after 'extract')
+ */
+export const extract = async (args: string[]): Promise<void> => {
+  const { values, positionals } = parseArgs({
+    args,
+    options: {
+      schema: { type: 'string', short: 's' },
+      output: { type: 'string', short: 'o' },
+      progress: { type: 'boolean', default: false },
+      help: { type: 'boolean', short: 'h' },
+    },
+    allowPositionals: true,
+  })
+
+  if (values.help) {
+    // biome-ignore lint/suspicious/noConsole: CLI help output
+    console.log(`
+Usage: agent-eval-harness extract [raw.jsonl] --schema <schema.json> [options]
+
+Parse raw output into trajectories and final output.
+
+Arguments:
+  raw.jsonl         Input file from 'run' command (or pipe from stdin)
+
+Options:
+  -s, --schema      Path to headless adapter schema (required)
+  -o, --output      Output file (default: stdout)
+  --progress        Show progress to stderr
+  -h, --help        Show this help message
+
+Examples:
+  # From file
+  agent-eval-harness extract raw.jsonl --schema claude.json -o extracted.jsonl
+
+  # Piped from run
+  agent-eval-harness run prompts.jsonl -s claude.json | agent-eval-harness extract -s claude.json
+
+  # Full pipeline
+  cat prompts.jsonl | \\
+    agent-eval-harness run -s claude.json | \\
+    agent-eval-harness extract -s claude.json | \\
+    agent-eval-harness grade --grader ./grader.ts
+`)
+    return
+  }
+
+  if (!values.schema) {
+    console.error('Error: --schema is required')
+    process.exit(1)
+  }
+
+  // Load raw outputs from file or stdin
+  const inputPath = positionals[0]
+  let rawOutputs: RawOutput[]
+
+  if (inputPath) {
+    rawOutputs = await loadJsonl<RawOutput>(inputPath)
+  } else {
+    const stdinOutputs = await readStdinRawOutputs()
+    if (!stdinOutputs || stdinOutputs.length === 0) {
+      console.error('Error: No raw output provided (use file argument or pipe to stdin)')
+      process.exit(1)
+    }
+    rawOutputs = stdinOutputs
+  }
+
+  await runExtract(values.schema, rawOutputs, values.output, values.progress)
+}
diff --git a/src/pipeline/format.ts b/src/pipeline/format.ts
new file mode 100644
index 0000000..843a6c5
--- /dev/null
+++ b/src/pipeline/format.ts
@@ -0,0 +1,292 @@
+/**
+ * Pipeline format command - convert results to different output formats.
+ *
+ * @remarks
+ * Transforms graded or extracted results into various formats:
+ * - jsonl: Pass-through JSONL (default)
+ * - markdown: Human-readable report
+ * - csv: Comma-separated values for spreadsheets
+ *
+ * @packageDocumentation
+ */
+
+import { parseArgs } from 'node:util'
+import { loadJsonl, logProgress, writeOutput } from '../core.ts'
+import type { CaptureResult } from '../schemas.ts'
+import type { ExtractedResult, FormatStyle, GradedResult } from './pipeline.types.ts'
+
+/** Union of all formattable result types */
+type FormattableResult = ExtractedResult | GradedResult | CaptureResult
+
+/**
+ * Check if result has a score (graded).
+ */
+const isGraded = (
+  result: FormattableResult,
+): result is GradedResult | (CaptureResult & { score: NonNullable<CaptureResult['score']> }) => {
+  return 'score' in result && result.score !== undefined
+}
+
+/**
+ * Format results as markdown report.
+ *
+ * @param results - Results to format
+ * @returns Markdown string
+ */
+const formatMarkdown = (results: FormattableResult[]): string => {
+  const lines: string[] = [
+    '# Evaluation Results',
+    '',
+    `Generated: ${new Date().toISOString()}`,
+    `Total: ${results.length} test cases`,
+    '',
+  ]
+
+  // Summary statistics if graded
+  const gradedResults = results.filter(isGraded)
+  if (gradedResults.length > 0) {
+    const passed = gradedResults.filter((r) => r.score.pass).length
+    const avgScore = gradedResults.reduce((sum, r) => sum + r.score.score, 0) / gradedResults.length
+
+    lines.push('## Summary')
+    lines.push('')
+    lines.push(
+      `- **Pass rate**: ${passed}/${gradedResults.length} (${((passed / gradedResults.length) * 100).toFixed(1)}%)`,
+    )
+    lines.push(`- **Average score**: ${avgScore.toFixed(3)}`)
+    lines.push('')
+  }
+
+  lines.push('## Results')
+  lines.push('')
+
+  for (const result of results) {
+    const input = Array.isArray(result.input) ? result.input.join(' → ') : result.input
+    const inputPreview = input.length > 100 ? `${input.slice(0, 100)}...` : input
+
+    lines.push(`### ${result.id}`)
+    lines.push('')
+    lines.push(`**Input**: ${inputPreview}`)
+    lines.push('')
+
+    if (result.hint) {
+      lines.push(`**Hint**: ${result.hint}`)
+      lines.push('')
+    }
+
+    const outputPreview = result.output.length > 500 ? `${result.output.slice(0, 500)}...` : result.output
+    lines.push(`**Output**:`)
+    lines.push('```')
+    lines.push(outputPreview)
+    lines.push('```')
+    lines.push('')
+
+    if (isGraded(result)) {
+      const icon = result.score.pass ? '✅' : '❌'
+      lines.push(`**Score**: ${icon} ${result.score.score.toFixed(3)} (${result.score.pass ? 'PASS' : 'FAIL'})`)
+      if (result.score.reasoning) {
+        lines.push(`**Reasoning**: ${result.score.reasoning}`)
+      }
+      lines.push('')
+    }
+
+    if (result.toolErrors) {
+      lines.push('⚠️ **Tool errors detected**')
+      lines.push('')
+    }
+
+    if ('error' in result && result.error) {
+      lines.push(`❌ **Error**: ${result.error}`)
+      lines.push('')
+    }
+
+    lines.push('---')
+    lines.push('')
+  }
+
+  return lines.join('\n')
+}
+
+/**
+ * Format results as CSV.
+ *
+ * @param results - Results to format
+ * @returns CSV string
+ */
+const formatCsv = (results: FormattableResult[]): string => {
+  const lines: string[] = []
+
+  // Header
+  const hasScores = results.some(isGraded)
+  const headers = ['id', 'input', 'hint', 'output', 'tool_errors', 'duration_ms']
+  if (hasScores) {
+    headers.push('pass', 'score', 'reasoning')
+  }
+  lines.push(headers.join(','))
+
+  // Data rows
+  for (const result of results) {
+    const input = Array.isArray(result.input) ? result.input.join(' | ') : result.input
+    const escapeCsv = (str: string) => `"${str.replace(/"/g, '""').replace(/\n/g, '\\n')}"`
+
+    const row = [
+      escapeCsv(result.id),
+      escapeCsv(input),
+      escapeCsv(result.hint ?? ''),
+      escapeCsv(result.output),
+      result.toolErrors ? 'true' : 'false',
+      String(result.timing.total),
+    ]
+
+    if (hasScores) {
+      if (isGraded(result)) {
+        row.push(
+          result.score.pass ? 'true' : 'false',
+          result.score.score.toFixed(3),
+          escapeCsv(result.score.reasoning ?? ''),
+        )
+      } else {
+        row.push('', '', '')
+      }
+    }
+
+    lines.push(row.join(','))
+  }
+
+  return lines.join('\n')
+}
+
+/**
+ * Execute pipeline format with configuration.
+ *
+ * @param style - Output format style
+ * @param results - Results to format
+ * @param outputPath - Optional output file path
+ * @param progress - Show progress to stderr
+ */
+export const runFormat = async (
+  style: FormatStyle,
+  results: FormattableResult[],
+  outputPath?: string,
+  progress = false,
+): Promise<void> => {
+  logProgress(`Formatting ${results.length} results as ${style}`, progress)
+
+  let output: string
+
+  switch (style) {
+    case 'jsonl':
+      // Pass-through as JSONL
+      output = results.map((r) => JSON.stringify(r)).join('\n')
+      break
+
+    case 'markdown':
+      output = formatMarkdown(results)
+      break
+
+    case 'csv':
+      output = formatCsv(results)
+      break
+  }
+
+  await writeOutput(output, outputPath, false)
+  logProgress('Done!', progress)
+}
+
+/**
+ * Read results from stdin.
+ *
+ * @returns Array of parsed results or null if stdin is empty
+ */
+const readStdinResults = async (): Promise<FormattableResult[] | null> => {
+  if (process.stdin.isTTY) {
+    return null
+  }
+
+  const chunks: Buffer[] = []
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk)
+  }
+
+  const content = Buffer.concat(chunks).toString('utf-8').trim()
+  if (!content) return null
+
+  return content
+    .split('\n')
+    .filter(Boolean)
+    .map((line) => JSON.parse(line) as FormattableResult)
+}
+
+/**
+ * Pipeline format command CLI handler.
+ *
+ * @param args - Command line arguments (after 'format')
+ */
+export const format = async (args: string[]): Promise<void> => {
+  const { values, positionals } = parseArgs({
+    args,
+    options: {
+      style: { type: 'string', short: 'f', default: 'jsonl' },
+      output: { type: 'string', short: 'o' },
+      progress: { type: 'boolean', default: false },
+      help: { type: 'boolean', short: 'h' },
+    },
+    allowPositionals: true,
+  })
+
+  if (values.help) {
+    // biome-ignore lint/suspicious/noConsole: CLI help output
+    console.log(`
+Usage: agent-eval-harness format [results.jsonl] [options]
+
+Convert results to different output formats.
+
+Arguments:
+  results.jsonl     Input file (or pipe from stdin)
+
+Options:
+  -f, --style       Output format: jsonl, markdown, csv (default: jsonl)
+  -o, --output      Output file (default: stdout)
+  --progress        Show progress to stderr
+  -h, --help        Show this help message
+
+Examples:
+  # Convert to markdown report
+  agent-eval-harness format graded.jsonl --style markdown -o report.md
+
+  # Piped from grade
+  agent-eval-harness grade extracted.jsonl -g ./grader.ts | agent-eval-harness format -f csv
+
+  # Full pipeline to markdown
+  cat prompts.jsonl | \\
+    agent-eval-harness run -s claude.json | \\
+    agent-eval-harness extract -s claude.json | \\
+    agent-eval-harness grade -g ./grader.ts | \\
+    agent-eval-harness format -f markdown > report.md
+`)
+    return
+  }
+
+  const style = values.style as FormatStyle
+  if (!['jsonl', 'markdown', 'csv'].includes(style)) {
+    console.error(`Error: Invalid format style '${style}'. Must be: jsonl, markdown, csv`)
+    process.exit(1)
+  }
+
+  // Load results from file or stdin
+  const inputPath = positionals[0]
+  let results: FormattableResult[]
+
+  if (inputPath) {
+    results = await loadJsonl<FormattableResult>(inputPath)
+  } else {
+    const stdinResults = await readStdinResults()
+    if (!stdinResults || stdinResults.length === 0) {
+      console.error('Error: No results provided (use file argument or pipe to stdin)')
+      process.exit(1)
+    }
+    results = stdinResults
+  }
+
+  await runFormat(style, results, values.output, values.progress)
+}
diff --git a/src/pipeline/grade.ts b/src/pipeline/grade.ts
new file mode 100644
index 0000000..0a56b3c
--- /dev/null
+++ b/src/pipeline/grade.ts
@@ -0,0 +1,169 @@
+/**
+ * Pipeline grade command - apply grader to extracted results.
+ *
+ * @remarks
+ * Takes ExtractedResult from `extract` command and adds grader scores.
+ * Uses the same grader loading mechanism as the capture command.
+ *
+ * @packageDocumentation
+ */
+
+import { parseArgs } from 'node:util'
+import { loadJsonl, logProgress, writeOutput } from '../core.ts'
+import { loadGrader } from '../schemas/grader-loader.ts'
+import type { ExtractedResult, GradedResult } from './pipeline.types.ts'
+
+/**
+ * Execute pipeline grade with configuration.
+ *
+ * @param graderPath - Path to grader module or executable
+ * @param extractedResults - Extracted results from extract command
+ * @param outputPath - Optional output file path
+ * @param progress - Show progress to stderr
+ */
+export const runGrade = async (
+  graderPath: string,
+  extractedResults: ExtractedResult[],
+  outputPath?: string,
+  progress = false,
+): Promise<void> => {
+  // Load grader
+  const grader = await loadGrader(graderPath)
+
+  logProgress(`Grading with: ${graderPath}`, progress)
+
+  let isFirstOutput = true
+
+  // Clear output file if specified
+  if (outputPath) {
+    await Bun.write(outputPath, '')
+  }
+
+  for (let i = 0; i < extractedResults.length; i++) {
+    const extracted = extractedResults[i]
+    if (!extracted) continue
+
+    logProgress(`[${i + 1}/${extractedResults.length}] ${extracted.id}`, progress)
+
+    // Apply grader
+    const score = await grader({
+      input: extracted.input,
+      output: extracted.output,
+      hint: extracted.hint,
+      trajectory: extracted.trajectory,
+    })
+
+    const graded: GradedResult = {
+      ...extracted,
+      score,
+    }
+
+    const icon = score.pass ? '✓' : '✗'
+    logProgress(`  ${icon} score=${score.score.toFixed(2)}`, progress)
+
+    await writeOutput(JSON.stringify(graded), outputPath, !isFirstOutput)
+    isFirstOutput = false
+  }
+
+  logProgress('Done!', progress)
+}
+
+/**
+ * Read extracted results from stdin.
+ *
+ * @returns Array of parsed extracted results or null if stdin is empty
+ */
+const readStdinExtracted = async (): Promise<ExtractedResult[] | null> => {
+  if (process.stdin.isTTY) {
+    return null
+  }
+
+  const chunks: Buffer[] = []
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk)
+  }
+
+  const content = Buffer.concat(chunks).toString('utf-8').trim()
+  if (!content) return null
+
+  return content
+    .split('\n')
+    .filter(Boolean)
+    .map((line) => JSON.parse(line) as ExtractedResult)
+}
+
+/**
+ * Pipeline grade command CLI handler.
+ *
+ * @param args - Command line arguments (after 'grade')
+ */
+export const grade = async (args: string[]): Promise<void> => {
+  const { values, positionals } = parseArgs({
+    args,
+    options: {
+      grader: { type: 'string', short: 'g' },
+      output: { type: 'string', short: 'o' },
+      progress: { type: 'boolean', default: false },
+      help: { type: 'boolean', short: 'h' },
+    },
+    allowPositionals: true,
+  })
+
+  if (values.help) {
+    // biome-ignore lint/suspicious/noConsole: CLI help output
+    console.log(`
+Usage: agent-eval-harness grade [extracted.jsonl] --grader <grader> [options]
+
+Apply grader to extracted results.
+
+Arguments:
+  extracted.jsonl   Input file from 'extract' command (or pipe from stdin)
+
+Options:
+  -g, --grader      Path to grader (.ts/.js module or executable script) (required)
+  -o, --output      Output file (default: stdout)
+  --progress        Show progress to stderr
+  -h, --help        Show this help message
+
+Graders:
+  TS/JS modules must export a 'grade' function.
+  Executable scripts (Python, etc.) use stdin/stdout JSON protocol.
+
+Examples:
+  # From file
+  agent-eval-harness grade extracted.jsonl --grader ./grader.ts -o graded.jsonl
+
+  # Piped from extract
+  agent-eval-harness extract raw.jsonl -s claude.json | agent-eval-harness grade -g ./grader.ts
+
+  # Full pipeline
+  cat prompts.jsonl | \\
+    agent-eval-harness run -s claude.json | \\
+    agent-eval-harness extract -s claude.json | \\
+    agent-eval-harness grade -g ./grader.ts > results.jsonl
+`)
+    return
+  }
+
+  if (!values.grader) {
+    console.error('Error: --grader is required')
+    process.exit(1)
+  }
+
+  // Load extracted results from file or stdin
+  const inputPath = positionals[0]
+  let extractedResults: ExtractedResult[]
+
+  if (inputPath) {
+    extractedResults = await loadJsonl<ExtractedResult>(inputPath)
+  } else {
+    const stdinResults = await readStdinExtracted()
+    if (!stdinResults || stdinResults.length === 0) {
+      console.error('Error: No extracted results provided (use file argument or pipe to stdin)')
+      process.exit(1)
+    }
+    extractedResults = stdinResults
+  }
+
+  await runGrade(values.grader, extractedResults, values.output, values.progress)
+}
diff --git a/src/pipeline/pipeline.ts b/src/pipeline/pipeline.ts
new file mode 100644
index 0000000..52a393f
--- /dev/null
+++ b/src/pipeline/pipeline.ts
@@ -0,0 +1,41 @@
+/**
+ * Pipeline commands for Unix-style composable evaluation.
+ *
+ * @remarks
+ * Re-exports pipeline commands and types.
+ *
+ * Commands:
+ * - run: Execute prompts and output raw results
+ * - extract: Parse raw output into trajectories
+ * - grade: Apply grader to extracted results
+ * - format: Convert results to different output formats
+ * - compare: Compare multiple runs of the same prompts
+ *
+ * @packageDocumentation
+ */
+
+// Commands
+export { compare } from './compare.ts'
+export { extract } from './extract.ts'
+export { format } from './format.ts'
+export { grade } from './grade.ts'
+// Types
+export type {
+  CompareConfig,
+  ComparisonGrader,
+  ComparisonGraderInput,
+  ComparisonGraderResult,
+  ComparisonRanking,
+  ComparisonResult,
+  ExtractConfig,
+  ExtractedResult,
+  FormatConfig,
+  FormatStyle,
+  GradeConfig,
+  GradedResult,
+  LabeledRun,
+  RawOutput,
+  RunConfig,
+  RunMode,
+} from './pipeline.types.ts'
+export { run } from './run.ts'
diff --git a/src/pipeline/pipeline.types.ts b/src/pipeline/pipeline.types.ts
new file mode 100644
index 0000000..c8864c6
--- /dev/null
+++ b/src/pipeline/pipeline.types.ts
@@ -0,0 +1,241 @@
+/**
+ * Type definitions for pipeline commands.
+ *
+ * @remarks
+ * These types define the data flow between pipeline stages:
+ * run → extract → grade → format
+ *
+ * Each stage transforms the data, enabling Unix-style piping.
+ *
+ * @packageDocumentation
+ */
+
+import type { GraderResult, TrajectoryStep } from '../schemas.ts'
+
+/**
+ * Raw output from the `run` command.
+ *
+ * @remarks
+ * Captures the raw agent output before trajectory extraction.
+ * Used when piping `run` output to `extract`.
+ */
+export type RawOutput = {
+  /** Test case identifier */
+  id: string
+  /** Original prompt input (string for single turn, array for multi-turn) */
+  input: string | string[]
+  /** Grader context hint */
+  hint?: string
+  /** Raw output lines from the agent (JSON strings) */
+  rawLines: string[]
+  /** Timing metadata */
+  timing: {
+    start: number
+    end: number
+    total: number
+  }
+  /** Error message if execution failed */
+  error?: string
+}
+
+/**
+ * Extracted result from the `extract` command.
+ *
+ * @remarks
+ * Converts raw output lines into structured trajectory and output.
+ * Ready for grading or formatting.
+ */
+export type ExtractedResult = {
+  /** Test case identifier */
+  id: string
+  /** Original prompt input */
+  input: string | string[]
+  /** Grader context hint */
+  hint?: string
+  /** Final agent output (extracted from trajectory) */
+  output: string
+  /** Parsed trajectory steps */
+  trajectory: TrajectoryStep[]
+  /** Whether tool errors were detected */
+  toolErrors: boolean
+  /** Timing metadata */
+  timing: {
+    start: number
+    end: number
+    total: number
+  }
+  /** Error message if extraction failed */
+  error?: string
+}
+
+/**
+ * Graded result from the `grade` command.
+ *
+ * @remarks
+ * Adds grader score to extracted result.
+ */
+export type GradedResult = ExtractedResult & {
+  /** Grader score */
+  score: GraderResult
+}
+
+/**
+ * Run mode for the pipeline run command.
+ *
+ * @remarks
+ * - `schema`: Use headless adapter with schema file
+ * - `simple`: Use Bun shell with placeholder substitution
+ * - `shell`: Use Bun shell with PROMPT env variable
+ */
+export type RunMode = 'schema' | 'simple' | 'shell'
+
+/**
+ * Configuration for pipeline run command.
+ */
+export type RunConfig = {
+  /** Run mode */
+  mode: RunMode
+  /** Path to schema file (for 'schema' mode) */
+  schemaPath?: string
+  /** Command template (for 'simple' mode) - {} is replaced with prompt */
+  simpleCommand?: string
+  /** Shell template (for 'shell' mode) - $PROMPT env var is available */
+  shellTemplate?: string
+  /** Working directory */
+  cwd?: string
+  /** Timeout per prompt in milliseconds */
+  timeout?: number
+  /** Show progress to stderr */
+  progress?: boolean
+}
+
+/**
+ * Configuration for pipeline extract command.
+ */
+export type ExtractConfig = {
+  /** Path to schema file for output parsing */
+  schemaPath: string
+  /** Show progress to stderr */
+  progress?: boolean
+}
+
+/**
+ * Configuration for pipeline grade command.
+ */
+export type GradeConfig = {
+  /** Path to grader module or executable */
+  graderPath: string
+  /** Show progress to stderr */
+  progress?: boolean
+}
+
+/**
+ * Output format for pipeline format command.
+ */
+export type FormatStyle = 'jsonl' | 'markdown' | 'csv'
+
+/**
+ * Configuration for pipeline format command.
+ */
+export type FormatConfig = {
+  /** Output format style */
+  style: FormatStyle
+  /** Show progress to stderr */
+  progress?: boolean
+}
+
+/**
+ * Labeled run for comparison.
+ *
+ * @remarks
+ * Associates a results file with a human-readable label
+ * for the compare command output.
+ */
+export type LabeledRun = {
+  /** Human-readable label (derived from filename or explicit) */
+  label: string
+  /** Path to results JSONL file */
+  path: string
+}
+
+/**
+ * Input to comparison grader function.
+ *
+ * @remarks
+ * Provides all runs' results for a single prompt ID
+ * so the grader can compare and rank them.
+ */
+export type ComparisonGraderInput = {
+  /** Test case identifier */
+  id: string
+  /** Original prompt input */
+  input: string | string[]
+  /** Grader context hint */
+  hint?: string
+  /** Results keyed by run label */
+  runs: Record<string, { output: string; trajectory?: TrajectoryStep[] }>
+}
+
+/**
+ * Single ranking entry in comparison result.
+ */
+export type ComparisonRanking = {
+  /** Run label */
+  run: string
+  /** Rank position (1 = best) */
+  rank: number
+  /** Numeric score */
+  score: number
+}
+
+/**
+ * Result from comparison grader function.
+ *
+ * @remarks
+ * Rankings should be ordered from best to worst.
+ */
+export type ComparisonGraderResult = {
+  /** Rankings from best to worst */
+  rankings: ComparisonRanking[]
+  /** Optional reasoning for the rankings */
+  reasoning?: string
+}
+
+/**
+ * Comparison grader function type.
+ *
+ * @remarks
+ * User-provided graders implement this interface to compare
+ * multiple runs of the same prompt.
+ */
+export type ComparisonGrader = (params: ComparisonGraderInput) => Promise<ComparisonGraderResult>
+
+/**
+ * Configuration for pipeline compare command.
+ */
+export type CompareConfig = {
+  /** Labeled runs to compare */
+  runs: LabeledRun[]
+  /** Path to comparison grader */
+  graderPath: string
+  /** Output file path */
+  outputPath?: string
+  /** Show progress to stderr */
+  progress?: boolean
+}
+
+/**
+ * Comparison result for a single prompt.
+ */
+export type ComparisonResult = {
+  /** Test case identifier */
+  id: string
+  /** Original prompt input */
+  input: string | string[]
+  /** Grader context hint */
+  hint?: string
+  /** Rankings from comparison grader */
+  rankings: ComparisonRanking[]
+  /** Optional reasoning */
+  reasoning?: string
+}
diff --git a/src/pipeline/run.ts b/src/pipeline/run.ts
new file mode 100644
index 0000000..96eda83
--- /dev/null
+++ b/src/pipeline/run.ts
@@ -0,0 +1,412 @@
+/**
+ * Pipeline run command - execute prompts and output raw results.
+ *
+ * @remarks
+ * Supports three modes:
+ * - `schema`: Use headless adapter with schema file (full trajectory capture)
+ * - `simple`: Use Bun shell with `{}` placeholder for prompt
+ * - `shell`: Use Bun shell with `$PROMPT` environment variable
+ *
+ * Output is RawOutput JSONL suitable for piping to `extract`.
+ *
+ * @packageDocumentation
+ */
+
+import { parseArgs } from 'node:util'
+import { loadPrompts, logProgress, writeOutput } from '../core.ts'
+import { parseHeadlessConfig } from '../headless/headless.schemas.ts'
+import { createSessionManager } from '../headless/headless-session-manager.ts'
+import { DEFAULT_HARNESS_TIMEOUT } from '../schemas/constants.ts'
+import type { RawOutput, RunConfig } from './pipeline.types.ts'
+
+/**
+ * Execute a single prompt in simple mode.
+ *
+ * @remarks
+ * Replaces `{}` placeholder in command with the prompt text.
+ * Uses Bun shell for execution.
+ *
+ * @param prompt - Prompt text to execute
+ * @param command - Command template with `{}` placeholder
+ * @param timeout - Execution timeout in milliseconds
+ * @returns Object with output lines and optional stderr error
+ */
+const runSimple = async (
+  prompt: string,
+  command: string,
+  timeout: number,
+): Promise<{ lines: string[]; error?: string }> => {
+  const escapedPrompt = prompt.replace(/'/g, "'\\''")
+  const finalCmd = command.replace('{}', `'${escapedPrompt}'`)
+
+  const proc = Bun.spawn(['sh', '-c', finalCmd], {
+    stdout: 'pipe',
+    stderr: 'pipe',
+  })
+
+  const timeoutId = setTimeout(() => proc.kill(), timeout)
+
+  try {
+    const [stdout, stderr] = await Promise.all([new Response(proc.stdout).text(), new Response(proc.stderr).text()])
+    clearTimeout(timeoutId)
+    const lines = stdout.trim().split('\n').filter(Boolean)
+    return stderr.trim() ? { lines, error: stderr.trim() } : { lines }
+  } catch (err) {
+    clearTimeout(timeoutId)
+    return { lines: [], error: err instanceof Error ? err.message : String(err) }
+  }
+}
+
+/**
+ * Execute a single prompt in shell mode.
+ *
+ * @remarks
+ * Sets PROMPT environment variable and executes shell template.
+ *
+ * @param prompt - Prompt text to execute
+ * @param template - Shell command template
+ * @param timeout - Execution timeout in milliseconds
+ * @returns Object with output lines and optional stderr error
+ */
+const runShell = async (
+  prompt: string,
+  template: string,
+  timeout: number,
+): Promise<{ lines: string[]; error?: string }> => {
+  const proc = Bun.spawn(['sh', '-c', template], {
+    stdout: 'pipe',
+    stderr: 'pipe',
+    env: { ...process.env, PROMPT: prompt },
+  })
+
+  const timeoutId = setTimeout(() => proc.kill(), timeout)
+
+  try {
+    const [stdout, stderr] = await Promise.all([new Response(proc.stdout).text(), new Response(proc.stderr).text()])
+    clearTimeout(timeoutId)
+    const lines = stdout.trim().split('\n').filter(Boolean)
+    return stderr.trim() ? { lines, error: stderr.trim() } : { lines }
+  } catch (err) {
+    clearTimeout(timeoutId)
+    return { lines: [], error: err instanceof Error ? err.message : String(err) }
+  }
+}
+
+/**
+ * Execute pipeline run with configuration object.
+ *
+ * @remarks
+ * Processes prompts from stdin (if available) or from a file,
+ * executing each and outputting RawOutput JSONL.
+ *
+ * @param config - Run configuration
+ * @param prompts - Array of prompts to execute
+ * @param outputPath - Optional output file path
+ */
+export const runPipeline = async (
+  config: RunConfig,
+  prompts: Array<{ id: string; input: string | string[]; hint?: string }>,
+  outputPath?: string,
+): Promise<void> => {
+  const {
+    mode,
+    schemaPath,
+    simpleCommand,
+    shellTemplate,
+    cwd,
+    timeout = DEFAULT_HARNESS_TIMEOUT,
+    progress = false,
+  } = config
+
+  const workingDir = cwd ?? process.cwd()
+  let isFirstOutput = true
+
+  // Clear output file if specified
+  if (outputPath) {
+    await Bun.write(outputPath, '')
+  }
+
+  if (mode === 'schema') {
+    // Schema mode: use headless adapter
+    if (!schemaPath) {
+      throw new Error('Schema path required for schema mode')
+    }
+
+    const schemaFile = Bun.file(schemaPath)
+    if (!(await schemaFile.exists())) {
+      throw new Error(`Schema file not found: ${schemaPath}`)
+    }
+
+    const rawSchema = await schemaFile.json()
+    const schema = parseHeadlessConfig(rawSchema)
+
+    const sessions = createSessionManager({
+      schema,
+      timeout,
+      verbose: progress,
+    })
+
+    logProgress(`Schema mode: ${schema.name}`, progress)
+
+    for (let i = 0; i < prompts.length; i++) {
+      const promptCase = prompts[i]
+      if (!promptCase) continue
+
+      logProgress(`[${i + 1}/${prompts.length}] ${promptCase.id}`, progress)
+
+      const startTime = Date.now()
+      const rawLines: string[] = []
+      let error: string | undefined
+
+      try {
+        const session = await sessions.create(workingDir)
+        const inputs = Array.isArray(promptCase.input) ? promptCase.input : [promptCase.input]
+
+        for (const turnInput of inputs) {
+          const result = await sessions.prompt(session.id, turnInput)
+          // Collect raw JSON lines from updates
+          for (const update of result.updates) {
+            rawLines.push(JSON.stringify(update.raw))
+          }
+        }
+
+        sessions.destroy(session.id)
+      } catch (err) {
+        error = err instanceof Error ? err.message : String(err)
+      }
+
+      const endTime = Date.now()
+
+      const output: RawOutput = {
+        id: promptCase.id,
+        input: promptCase.input,
+        hint: promptCase.hint,
+        rawLines,
+        timing: {
+          start: startTime,
+          end: endTime,
+          total: endTime - startTime,
+        },
+        ...(error && { error }),
+      }
+
+      await writeOutput(JSON.stringify(output), outputPath, !isFirstOutput)
+      isFirstOutput = false
+    }
+  } else if (mode === 'simple') {
+    // Simple mode: placeholder substitution
+    if (!simpleCommand) {
+      throw new Error('Command required for simple mode')
+    }
+
+    logProgress(`Simple mode: ${simpleCommand}`, progress)
+
+    for (let i = 0; i < prompts.length; i++) {
+      const promptCase = prompts[i]
+      if (!promptCase) continue
+
+      logProgress(`[${i + 1}/${prompts.length}] ${promptCase.id}`, progress)
+
+      const startTime = Date.now()
+      const inputs = Array.isArray(promptCase.input) ? promptCase.input : [promptCase.input]
+      const allLines: string[] = []
+      const errors: string[] = []
+
+      for (const input of inputs) {
+        const result = await runSimple(input, simpleCommand, timeout)
+        allLines.push(...result.lines)
+        if (result.error) errors.push(result.error)
+      }
+
+      const endTime = Date.now()
+
+      const output: RawOutput = {
+        id: promptCase.id,
+        input: promptCase.input,
+        hint: promptCase.hint,
+        rawLines: allLines,
+        timing: {
+          start: startTime,
+          end: endTime,
+          total: endTime - startTime,
+        },
+        ...(errors.length > 0 && { error: errors.join('\n') }),
+      }
+
+      await writeOutput(JSON.stringify(output), outputPath, !isFirstOutput)
+      isFirstOutput = false
+    }
+  } else if (mode === 'shell') {
+    // Shell mode: PROMPT env variable
+    if (!shellTemplate) {
+      throw new Error('Shell template required for shell mode')
+    }
+
+    logProgress(`Shell mode: ${shellTemplate}`, progress)
+
+    for (let i = 0; i < prompts.length; i++) {
+      const promptCase = prompts[i]
+      if (!promptCase) continue
+
+      logProgress(`[${i + 1}/${prompts.length}] ${promptCase.id}`, progress)
+
+      const startTime = Date.now()
+      const inputs = Array.isArray(promptCase.input) ? promptCase.input : [promptCase.input]
+      const allLines: string[] = []
+      const errors: string[] = []
+
+      for (const input of inputs) {
+        const result = await runShell(input, shellTemplate, timeout)
+        allLines.push(...result.lines)
+        if (result.error) errors.push(result.error)
+      }
+
+      const endTime = Date.now()
+
+      const output: RawOutput = {
+        id: promptCase.id,
+        input: promptCase.input,
+        hint: promptCase.hint,
+        rawLines: allLines,
+        timing: {
+          start: startTime,
+          end: endTime,
+          total: endTime - startTime,
+        },
+        ...(errors.length > 0 && { error: errors.join('\n') }),
+      }
+
+      await writeOutput(JSON.stringify(output), outputPath, !isFirstOutput)
+      isFirstOutput = false
+    }
+  }
+
+  logProgress('Done!', progress)
+}
+
+/**
+ * Read prompts from stdin if available.
+ *
+ * @returns Array of parsed prompts or null if stdin is empty
+ */
+const readStdinPrompts = async (): Promise<Array<{ id: string; input: string | string[]; hint?: string }> | null> => {
+  // Check if stdin has data (not a TTY)
+  if (process.stdin.isTTY) {
+    return null
+  }
+
+  const chunks: Buffer[] = []
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk)
+  }
+
+  const content = Buffer.concat(chunks).toString('utf-8').trim()
+  if (!content) return null
+
+  return content
+    .split('\n')
+    .filter(Boolean)
+    .map((line) => JSON.parse(line))
+}
+
+/**
+ * Pipeline run command CLI handler.
+ *
+ * @param args - Command line arguments (after 'run')
+ */
+export const run = async (args: string[]): Promise<void> => {
+  const { values, positionals } = parseArgs({
+    args,
+    options: {
+      schema: { type: 'string', short: 's' },
+      simple: { type: 'string' },
+      shell: { type: 'string' },
+      output: { type: 'string', short: 'o' },
+      cwd: { type: 'string', short: 'c' },
+      timeout: { type: 'string', short: 't' },
+      progress: { type: 'boolean', default: false },
+      help: { type: 'boolean', short: 'h' },
+    },
+    allowPositionals: true,
+  })
+
+  if (values.help) {
+    // biome-ignore lint/suspicious/noConsole: CLI help output
+    console.log(`
+Usage: agent-eval-harness run [prompts.jsonl] [options]
+
+Execute prompts and output raw results for pipeline processing.
+
+Arguments:
+  prompts.jsonl     Input file (or pipe from stdin)
+
+Modes (choose one):
+  -s, --schema      Path to headless adapter schema (recommended)
+  --simple          Command template with {} placeholder
+  --shell           Shell template with $PROMPT env variable
+
+Options:
+  -o, --output      Output file (default: stdout)
+  -c, --cwd         Working directory for agent
+  -t, --timeout     Request timeout in ms (default: ${DEFAULT_HARNESS_TIMEOUT})
+  --progress        Show progress to stderr
+  -h, --help        Show this help message
+
+Examples:
+  # Schema mode (recommended)
+  agent-eval-harness run prompts.jsonl --schema claude.json | agent-eval-harness extract
+
+  # Simple mode with placeholder
+  agent-eval-harness run prompts.jsonl --simple "claude -p {} --output-format stream-json"
+
+  # Shell mode with env variable
+  agent-eval-harness run prompts.jsonl --shell 'claude -p "$PROMPT" --output-format stream-json'
+
+  # Pipe from stdin
+  cat prompts.jsonl | agent-eval-harness run --schema claude.json
+`)
+    return
+  }
+
+  // Determine mode
+  let mode: 'schema' | 'simple' | 'shell'
+  if (values.schema) {
+    mode = 'schema'
+  } else if (values.simple) {
+    mode = 'simple'
+  } else if (values.shell) {
+    mode = 'shell'
+  } else {
+    console.error('Error: Must specify --schema, --simple, or --shell mode')
+    process.exit(1)
+  }
+
+  // Load prompts from file or stdin
+  const promptsPath = positionals[0]
+  let prompts: Array<{ id: string; input: string | string[]; hint?: string }>
+
+  if (promptsPath) {
+    prompts = await loadPrompts(promptsPath)
+  } else {
+    const stdinPrompts = await readStdinPrompts()
+    if (!stdinPrompts || stdinPrompts.length === 0) {
+      console.error('Error: No prompts provided (use file argument or pipe to stdin)')
+      process.exit(1)
+    }
+    prompts = stdinPrompts
+  }
+
+  await runPipeline(
+    {
+      mode,
+      schemaPath: values.schema,
+      simpleCommand: values.simple,
+      shellTemplate: values.shell,
+      cwd: values.cwd,
+      timeout: values.timeout ? Number.parseInt(values.timeout, 10) : undefined,
+      progress: values.progress,
+    },
+    prompts,
+    values.output,
+  )
+}
diff --git a/src/pipeline/tests/pipeline.spec.ts b/src/pipeline/tests/pipeline.spec.ts
new file mode 100644
index 0000000..2a1fb30
--- /dev/null
+++ b/src/pipeline/tests/pipeline.spec.ts
@@ -0,0 +1,356 @@
+/**
+ * Unit tests for pipeline commands.
+ *
+ * @remarks
+ * Tests for the Unix-style pipeline commands:
+ * - format: formatMarkdown, formatCsv helpers
+ * - compare: parseLabeledRun helper
+ * - type validation
+ *
+ * @packageDocumentation
+ */
+
+import { describe, expect, test } from 'bun:test'
+import type {
+  ComparisonGraderInput,
+  ComparisonGraderResult,
+  ExtractedResult,
+  FormatStyle,
+  GradedResult,
+  LabeledRun,
+  RawOutput,
+} from '../pipeline.types.ts'
+
+// ============================================================================
+// Type Validation Tests
+// ============================================================================
+
+describe('RawOutput type', () => {
+  test('accepts valid raw output', () => {
+    const raw: RawOutput = {
+      id: 'test-001',
+      input: 'What is 2+2?',
+      rawLines: ['{"type":"message","content":"4"}'],
+      timing: {
+        start: 1000,
+        end: 2000,
+        total: 1000,
+      },
+    }
+    expect(raw.id).toBe('test-001')
+    expect(raw.timing.total).toBe(1000)
+  })
+
+  test('accepts array input for multi-turn', () => {
+    const raw: RawOutput = {
+      id: 'multi-001',
+      input: ['Hello', 'How are you?'],
+      rawLines: [],
+      timing: { start: 0, end: 100, total: 100 },
+    }
+    expect(Array.isArray(raw.input)).toBe(true)
+    expect((raw.input as string[]).length).toBe(2)
+  })
+
+  test('accepts optional hint', () => {
+    const raw: RawOutput = {
+      id: 'hint-001',
+      input: 'Calculate something',
+      hint: 'Expected: numeric answer',
+      rawLines: [],
+      timing: { start: 0, end: 0, total: 0 },
+    }
+    expect(raw.hint).toBe('Expected: numeric answer')
+  })
+
+  test('accepts optional error', () => {
+    const raw: RawOutput = {
+      id: 'error-001',
+      input: 'fail test',
+      rawLines: [],
+      timing: { start: 0, end: 100, total: 100 },
+      error: 'Timeout exceeded',
+    }
+    expect(raw.error).toBe('Timeout exceeded')
+  })
+})
+
+describe('ExtractedResult type', () => {
+  test('accepts valid extracted result', () => {
+    const extracted: ExtractedResult = {
+      id: 'test-001',
+      input: 'What is 2+2?',
+      output: '4',
+      trajectory: [
+        {
+          type: 'message',
+          content: '4',
+          timestamp: 100,
+        },
+      ],
+      toolErrors: false,
+      timing: { start: 0, end: 100, total: 100 },
+    }
+    expect(extracted.output).toBe('4')
+    expect(extracted.trajectory.length).toBe(1)
+    expect(extracted.toolErrors).toBe(false)
+  })
+
+  test('accepts thought and tool_call steps', () => {
+    const extracted: ExtractedResult = {
+      id: 'complex-001',
+      input: 'Create a file',
+      output: 'Done',
+      trajectory: [
+        { type: 'thought', content: 'I need to create a file', timestamp: 50 },
+        {
+          type: 'tool_call',
+          name: 'Write',
+          input: { path: '/tmp/test.txt', content: 'hello' },
+          status: 'completed',
+          timestamp: 200,
+        },
+        { type: 'message', content: 'Done', timestamp: 250 },
+      ],
+      toolErrors: false,
+      timing: { start: 0, end: 300, total: 300 },
+    }
+    expect(extracted.trajectory.length).toBe(3)
+    expect(extracted.trajectory[1]?.type).toBe('tool_call')
+  })
+})
+
+describe('GradedResult type', () => {
+  test('extends ExtractedResult with score', () => {
+    const graded: GradedResult = {
+      id: 'graded-001',
+      input: 'What is 2+2?',
+      output: '4',
+      trajectory: [],
+      toolErrors: false,
+      timing: { start: 0, end: 100, total: 100 },
+      score: {
+        pass: true,
+        score: 1.0,
+        reasoning: 'Correct answer',
+      },
+    }
+    expect(graded.score.pass).toBe(true)
+    expect(graded.score.score).toBe(1.0)
+    expect(graded.score.reasoning).toBe('Correct answer')
+  })
+
+  test('accepts failing score', () => {
+    const graded: GradedResult = {
+      id: 'fail-001',
+      input: 'What is 2+2?',
+      output: '5',
+      trajectory: [],
+      toolErrors: false,
+      timing: { start: 0, end: 100, total: 100 },
+      score: {
+        pass: false,
+        score: 0.0,
+        reasoning: 'Incorrect answer',
+      },
+    }
+    expect(graded.score.pass).toBe(false)
+    expect(graded.score.score).toBe(0.0)
+  })
+})
+
+describe('FormatStyle type', () => {
+  test('accepts valid format styles', () => {
+    const styles: FormatStyle[] = ['jsonl', 'markdown', 'csv']
+    expect(styles).toContain('jsonl')
+    expect(styles).toContain('markdown')
+    expect(styles).toContain('csv')
+  })
+})
+
+describe('LabeledRun type', () => {
+  test('accepts label and path', () => {
+    const run: LabeledRun = {
+      label: 'baseline',
+      path: './results/baseline.jsonl',
+    }
+    expect(run.label).toBe('baseline')
+    expect(run.path).toBe('./results/baseline.jsonl')
+  })
+})
+
+describe('ComparisonGraderInput type', () => {
+  test('accepts multiple runs', () => {
+    const input: ComparisonGraderInput = {
+      id: 'compare-001',
+      input: 'What is 2+2?',
+      runs: {
+        baseline: { output: '4' },
+        experiment: { output: 'Four', trajectory: [] },
+      },
+    }
+    expect(Object.keys(input.runs).length).toBe(2)
+    expect(input.runs.baseline?.output).toBe('4')
+    expect(input.runs.experiment?.trajectory).toEqual([])
+  })
+})
+
+describe('ComparisonGraderResult type', () => {
+  test('accepts rankings with reasoning', () => {
+    const result: ComparisonGraderResult = {
+      rankings: [
+        { run: 'baseline', rank: 1, score: 0.95 },
+        { run: 'experiment', rank: 2, score: 0.8 },
+      ],
+      reasoning: 'Baseline was more concise',
+    }
+    expect(result.rankings.length).toBe(2)
+    expect(result.rankings[0]?.rank).toBe(1)
+    expect(result.reasoning).toBeDefined()
+  })
+})
+
+// ============================================================================
+// Helper Function Tests (via import)
+// ============================================================================
+
+// Note: Some helper functions are not exported from the modules.
+// These tests verify the type contracts that the helpers must satisfy.
+
+describe('pipeline data flow', () => {
+  test('RawOutput can flow to ExtractedResult', () => {
+    const raw: RawOutput = {
+      id: 'flow-001',
+      input: 'test',
+      hint: 'expected: something',
+      rawLines: ['{"type":"message","content":"result"}'],
+      timing: { start: 0, end: 100, total: 100 },
+    }
+
+    // Simulate extraction
+    const extracted: ExtractedResult = {
+      id: raw.id,
+      input: raw.input,
+      hint: raw.hint,
+      output: 'result',
+      trajectory: [{ type: 'message', content: 'result', timestamp: 100 }],
+      toolErrors: false,
+      timing: raw.timing,
+    }
+
+    expect(extracted.id).toBe(raw.id)
+    expect(extracted.input).toBe(raw.input)
+    expect(extracted.hint).toBe(raw.hint)
+  })
+
+  test('ExtractedResult can flow to GradedResult', () => {
+    const extracted: ExtractedResult = {
+      id: 'grade-flow-001',
+      input: 'test',
+      output: 'result',
+      trajectory: [],
+      toolErrors: false,
+      timing: { start: 0, end: 100, total: 100 },
+    }
+
+    // Simulate grading
+    const graded: GradedResult = {
+      ...extracted,
+      score: { pass: true, score: 1.0 },
+    }
+
+    expect(graded.id).toBe(extracted.id)
+    expect(graded.score.pass).toBe(true)
+  })
+})
+
+describe('comparison data structures', () => {
+  test('LabeledRun derived from filename', () => {
+    // Simulate parseLabeledRun behavior
+    const path = '/path/to/results-baseline.jsonl'
+    const basename = path.split('/').pop() ?? ''
+    const label = basename.replace('.jsonl', '')
+
+    const run: LabeledRun = { label, path }
+    expect(run.label).toBe('results-baseline')
+  })
+
+  test('LabeledRun with explicit label', () => {
+    // Simulate explicit label:path format
+    const arg = 'my-baseline:/path/to/results.jsonl'
+    const colonIdx = arg.indexOf(':')
+    const label = arg.slice(0, colonIdx)
+    const path = arg.slice(colonIdx + 1)
+
+    const run: LabeledRun = { label, path }
+    expect(run.label).toBe('my-baseline')
+    expect(run.path).toBe('/path/to/results.jsonl')
+  })
+
+  test('comparison aggregates results by prompt ID', () => {
+    const results1 = [
+      { id: 'p1', output: 'a' },
+      { id: 'p2', output: 'b' },
+    ]
+    const results2 = [
+      { id: 'p1', output: 'x' },
+      { id: 'p2', output: 'y' },
+    ]
+
+    // Simulate comparison aggregation
+    const promptIds = new Set([...results1.map((r) => r.id), ...results2.map((r) => r.id)])
+    expect(promptIds.size).toBe(2)
+
+    const comparisonInput: ComparisonGraderInput = {
+      id: 'p1',
+      input: 'test prompt',
+      runs: {
+        run1: { output: results1.find((r) => r.id === 'p1')?.output ?? '' },
+        run2: { output: results2.find((r) => r.id === 'p1')?.output ?? '' },
+      },
+    }
+    expect(comparisonInput.runs.run1?.output).toBe('a')
+    expect(comparisonInput.runs.run2?.output).toBe('x')
+  })
+})
+
+describe('format style contracts', () => {
+  test('markdown format includes summary when graded', () => {
+    // Verify the type contract for markdown formatting
+    const gradedResults: GradedResult[] = [
+      {
+        id: 't1',
+        input: 'a',
+        output: 'x',
+        trajectory: [],
+        toolErrors: false,
+        timing: { start: 0, end: 100, total: 100 },
+        score: { pass: true, score: 1.0 },
+      },
+      {
+        id: 't2',
+        input: 'b',
+        output: 'y',
+        trajectory: [],
+        toolErrors: false,
+        timing: { start: 0, end: 100, total: 100 },
+        score: { pass: false, score: 0.5 },
+      },
+    ]
+
+    const passed = gradedResults.filter((r) => r.score.pass).length
+    const total = gradedResults.length
+    const passRate = passed / total
+
+    expect(passRate).toBe(0.5)
+  })
+
+  test('csv format escapes special characters', () => {
+    // Test CSV escaping contract
+    const escapeCsv = (str: string) => `"${str.replace(/"/g, '""').replace(/\n/g, '\\n')}"`
+
+    expect(escapeCsv('hello')).toBe('"hello"')
+    expect(escapeCsv('say "hello"')).toBe('"say ""hello"""')
+    expect(escapeCsv('line1\nline2')).toBe('"line1\\nline2"')
+  })
+})
diff --git a/src/schemas.ts b/src/schemas.ts
index ad114c1..51f0fe5 100644
--- a/src/schemas.ts
+++ b/src/schemas.ts
@@ -1,619 +1,90 @@
 /**
- * Unified Zod schemas and types for the ACP harness.
+ * Schemas and types for agent evaluation harness.
  *
  * @remarks
- * This module follows a schema-first approach where Zod schemas are the
- * single source of truth. TypeScript types are derived using `z.infer<>`.
- *
- * **Exports:**
- * - Harness schemas: PromptCaseSchema, GraderResultSchema, CaptureResultSchema, etc.
- * - JSON-RPC schemas: JsonRpcRequestSchema, JsonRpcResponseSchema, etc.
- * - ACP SDK type schemas: SessionNotificationSchema, RequestPermissionRequestSchema
- * - All inferred types via `z.infer<>`
- *
- * **JSON Schema generation (Zod 4):**
- * ```typescript
- * import { z } from 'zod'
- * import { CaptureResultSchema } from '@plaited/acp-harness/schemas'
- * const jsonSchema = z.toJSONSchema(CaptureResultSchema)
- * ```
+ * Re-exports all Zod schemas and inferred types for capture results,
+ * trajectories, grader results, and CLI data structures.
  *
  * @packageDocumentation
  */
 
-import type { RequestPermissionRequest, SessionId, SessionNotification } from '@agentclientprotocol/sdk'
-import { z } from 'zod'
-
-// ============================================================================
-// Internal Type Utilities
-// ============================================================================
-
-/** Precise type detection beyond typeof operator */
-const trueTypeOf = (obj?: unknown): string => Object.prototype.toString.call(obj).slice(8, -1).toLowerCase()
-
-/** Type guard for precise type checking with TypeScript narrowing */
-const isTypeOf = <T>(obj: unknown, type: string): obj is T => trueTypeOf(obj) === type
-
-/** Type guard for object shape validation */
-const isRecord = (val: unknown): val is Record<string, unknown> => isTypeOf<Record<string, unknown>>(val, 'object')
-
-// ============================================================================
-// Session Types
-// ============================================================================
-
-/**
- * Session schema for session creation responses.
- */
-export const SessionSchema = z.object({
-  id: z.string() as z.ZodType<SessionId>,
-  _meta: z.record(z.string(), z.unknown()).nullish(),
-})
-
-/** Session object returned from session creation */
-export type Session = z.infer<typeof SessionSchema>
-
-// ============================================================================
-// JSON-RPC 2.0 Schemas
-// ============================================================================
-
-/** JSON-RPC version literal */
-const JsonRpcVersionSchema = z.literal('2.0')
-
-/** Request/response identifier */
-const RequestIdSchema = z.union([z.string(), z.number()])
-
-/**
- * JSON-RPC 2.0 error object schema.
- *
- * @remarks
- * Standard error codes:
- * - `-32700`: Parse error
- * - `-32600`: Invalid request
- * - `-32601`: Method not found
- * - `-32602`: Invalid params
- * - `-32603`: Internal error
- * - `-32800`: Request cancelled (ACP extension)
- */
-export const JsonRpcErrorSchema = z.object({
-  code: z.number(),
-  message: z.string(),
-  data: z.unknown().optional(),
-})
-
-/** JSON-RPC 2.0 error object */
-export type JsonRpcError = z.infer<typeof JsonRpcErrorSchema>
-
-/** JSON-RPC 2.0 request schema */
-export const JsonRpcRequestSchema = z.object({
-  jsonrpc: JsonRpcVersionSchema,
-  id: RequestIdSchema,
-  method: z.string(),
-  params: z.unknown().optional(),
-})
-
-/** JSON-RPC 2.0 request structure */
-export type JsonRpcRequest<T = unknown> = Omit<z.infer<typeof JsonRpcRequestSchema>, 'params'> & {
-  params?: T
-}
-
-/** JSON-RPC 2.0 notification schema (no id, no response expected) */
-export const JsonRpcNotificationSchema = z.object({
-  jsonrpc: JsonRpcVersionSchema,
-  method: z.string(),
-  params: z.unknown().optional(),
-})
-
-/** JSON-RPC 2.0 notification structure (no id, no response expected) */
-export type JsonRpcNotification<T = unknown> = Omit<z.infer<typeof JsonRpcNotificationSchema>, 'params'> & {
-  params?: T
-}
-
-/** JSON-RPC 2.0 success response schema */
-export const JsonRpcSuccessResponseSchema = z.object({
-  jsonrpc: JsonRpcVersionSchema,
-  id: RequestIdSchema,
-  result: z.unknown(),
-})
-
-/** JSON-RPC 2.0 success response */
-export type JsonRpcSuccessResponse<T = unknown> = Omit<z.infer<typeof JsonRpcSuccessResponseSchema>, 'result'> & {
-  result: T
-}
-
-/** JSON-RPC 2.0 error response schema */
-export const JsonRpcErrorResponseSchema = z.object({
-  jsonrpc: JsonRpcVersionSchema,
-  id: z.union([RequestIdSchema, z.null()]),
-  error: JsonRpcErrorSchema,
-})
-
-/** JSON-RPC 2.0 error response */
-export type JsonRpcErrorResponse = z.infer<typeof JsonRpcErrorResponseSchema>
-
-/** Union of all JSON-RPC response types */
-export const JsonRpcResponseSchema = z.union([JsonRpcSuccessResponseSchema, JsonRpcErrorResponseSchema])
-
-/** Union of all JSON-RPC response types */
-export type JsonRpcResponse<T = unknown> = JsonRpcSuccessResponse<T> | JsonRpcErrorResponse
-
-/**
- * Union of all JSON-RPC message types.
- *
- * @remarks
- * Use `safeParse` at transport boundaries for runtime validation.
- */
-export const JsonRpcMessageSchema = z.union([JsonRpcRequestSchema, JsonRpcNotificationSchema, JsonRpcResponseSchema])
-
-/** Union of all JSON-RPC message types */
-export type JsonRpcMessage<T = unknown> = JsonRpcRequest<T> | JsonRpcNotification<T> | JsonRpcResponse<T>
-
-// ============================================================================
-// ACP SDK Type Schemas (Custom Validators)
-// ============================================================================
-
-/**
- * Schema for session update notifications.
- *
- * @remarks
- * Validates `sessionId` and `update` fields used in notification handling.
- * Uses z.custom() to validate SDK types at runtime while keeping SDK types
- * as the source of truth.
- */
-export const SessionNotificationSchema = z.custom<SessionNotification>(
-  (val): val is SessionNotification =>
-    isRecord(val) && 'sessionId' in val && typeof val.sessionId === 'string' && 'update' in val && isRecord(val.update),
-)
-
-/**
- * Schema for permission requests from agent.
- *
- * @remarks
- * Validates `options` array used in permission handling.
- */
-export const RequestPermissionRequestSchema = z.custom<RequestPermissionRequest>(
-  (val): val is RequestPermissionRequest => isRecord(val) && 'options' in val && Array.isArray(val.options),
-)
-
-// ============================================================================
-// MCP Server Configuration Schemas
-// ============================================================================
-
-/** Environment variable configuration */
-export const EnvVariableSchema = z.object({
-  name: z.string(),
-  value: z.string(),
-})
-
-/** HTTP header configuration */
-export const HttpHeaderSchema = z.object({
-  name: z.string(),
-  value: z.string(),
-})
-
-/** MCP server stdio transport configuration */
-export const McpServerStdioSchema = z.object({
-  type: z.literal('stdio').optional(),
-  name: z.string(),
-  command: z.string(),
-  args: z.array(z.string()),
-  env: z.array(EnvVariableSchema),
-})
-
-/** MCP server HTTP transport configuration */
-export const McpServerHttpSchema = z.object({
-  type: z.literal('http'),
-  name: z.string(),
-  url: z.string(),
-  headers: z.array(HttpHeaderSchema),
-})
-
-/** MCP server configuration (stdio or HTTP) */
-export const McpServerSchema = z.union([McpServerStdioSchema, McpServerHttpSchema])
-
-/** MCP server configuration type */
-export type McpServerConfig = z.infer<typeof McpServerSchema>
-
-// ============================================================================
-// Harness Input Schemas
-// ============================================================================
-
-/**
- * Prompt case schema for evaluation inputs.
- *
- * @remarks
- * Each line in a prompts.jsonl file should match this schema.
- * - Single turn: `input: "Hello"` - one prompt, one session
- * - Multi-turn: `input: ["Hello", "How are you?", "Goodbye"]` - sequential turns in one session
- */
-export const PromptCaseSchema = z.object({
-  /** Unique identifier for the test case */
-  id: z.string(),
-  /** Prompt text(s) - string for single turn, array for multi-turn conversation */
-  input: z.union([z.string(), z.array(z.string())]),
-  /** Optional grader context hint (not a strict expected match) */
-  hint: z.string().optional(),
-  /** Optional reference solution for validation */
-  reference: z.string().optional(),
-  /** Optional metadata for categorization and analysis */
-  metadata: z.record(z.string(), z.unknown()).optional(),
-  /** Optional per-case timeout override in milliseconds */
-  timeout: z.number().optional(),
-})
-
-/** Prompt case type */
-export type PromptCase = z.infer<typeof PromptCaseSchema>
-
-// ============================================================================
-// Grader Schemas
-// ============================================================================
-
-/**
- * Grader result schema.
- *
- * @remarks
- * Result returned by user-provided grader functions.
- */
-export const GraderResultSchema = z.object({
-  /** Whether the output passes the evaluation criteria */
-  pass: z.boolean(),
-  /** Numeric score from 0.0 to 1.0 */
-  score: z.number().min(0).max(1),
-  /** Optional explanation for the score */
-  reasoning: z.string().optional(),
-})
-
-/** Grader result type */
-export type GraderResult = z.infer<typeof GraderResultSchema>
-
-/**
- * Grader function type.
- *
- * @remarks
- * User-provided graders implement this interface to score agent outputs.
- * - `input` is the original prompt (string or array for multi-turn)
- * - `hint` provides grader context (renamed from `expected`)
- */
-export type Grader = (params: {
-  input: string | string[]
-  output: string
-  hint?: string
-  trajectory?: TrajectoryStep[]
-}) => Promise<GraderResult>
-
-// ============================================================================
-// Trajectory Schemas
-// ============================================================================
-
-/** Tool input schema for extracting file paths and content */
-export const ToolInputSchema = z
-  .object({
-    file_path: z.string().optional(),
-    path: z.string().optional(),
-    content: z.string().optional(),
-    new_string: z.string().optional(),
-  })
-  .passthrough()
-
-/** Tool input type */
-export type ToolInput = z.infer<typeof ToolInputSchema>
-
-/**
- * Token usage schema for adapter-specific usage data.
- *
- * @remarks
- * ACP SDK's SessionNotification doesn't declare a 'usage' field, but adapters
- * like Claude Code extend responses with token counts at runtime. This schema
- * provides runtime validation for that extension.
- */
-export const TokenUsageSchema = z
-  .object({
-    inputTokens: z.number().optional(),
-    outputTokens: z.number().optional(),
-  })
-  .passthrough()
-
-/** Token usage type */
-export type TokenUsage = z.infer<typeof TokenUsageSchema>
-
-/** Thought trajectory step */
-export const ThoughtStepSchema = z.object({
-  type: z.literal('thought'),
-  content: z.string(),
-  timestamp: z.number(),
-  stepId: z.string().optional(),
-})
-
-/** Message trajectory step */
-export const MessageStepSchema = z.object({
-  type: z.literal('message'),
-  content: z.string(),
-  timestamp: z.number(),
-  stepId: z.string().optional(),
-})
-
-/** Tool call trajectory step */
-export const ToolCallStepSchema = z.object({
-  type: z.literal('tool_call'),
-  name: z.string(),
-  status: z.string(),
-  input: z.unknown().optional(),
-  output: z.unknown().optional(),
-  duration: z.number().optional(),
-  timestamp: z.number(),
-  stepId: z.string().optional(),
-})
-
-/** Plan trajectory step */
-export const PlanStepSchema = z.object({
-  type: z.literal('plan'),
-  entries: z.array(z.unknown()),
-  timestamp: z.number(),
-  stepId: z.string().optional(),
-})
-
-/**
- * Trajectory step schema (discriminated union).
- *
- * @remarks
- * Represents a single step in the agent's execution trajectory.
- */
-export const TrajectoryStepSchema = z.discriminatedUnion('type', [
-  ThoughtStepSchema,
+// Constants
+export {
+  DEFAULT_CALIBRATION_SAMPLE_SIZE,
+  DEFAULT_HARNESS_TIMEOUT,
+  DEFAULT_TRIAL_COUNT,
+  HEAD_LINES,
+  MAX_CONTENT_LENGTH,
+  TAIL_LINES,
+} from './schemas/constants.ts'
+// Grader loader
+export { loadGrader } from './schemas/grader-loader.ts'
+// Core session types
+// JSON-RPC types (MCP compatibility)
+// MCP server configuration
+// Prompt and grading
+// Trajectory types
+// Timing and richness
+// Result types
+export {
+  type BalanceAnalysis,
+  BalanceAnalysisSchema,
+  type CalibrationSample,
+  CalibrationSampleSchema,
+  type CaptureResult,
+  CaptureResultSchema,
+  type CategoryDistribution,
+  CategoryDistributionSchema,
+  EnvVariableSchema,
+  type Grader,
+  type GraderResult,
+  GraderResultSchema,
+  HttpHeaderSchema,
+  type IndexedStep,
+  type JsonRpcError,
+  type JsonRpcErrorResponse,
+  JsonRpcErrorResponseSchema,
+  JsonRpcErrorSchema,
+  type JsonRpcMessage,
+  JsonRpcMessageSchema,
+  type JsonRpcNotification,
+  JsonRpcNotificationSchema,
+  type JsonRpcRequest,
+  JsonRpcRequestSchema,
+  type JsonRpcResponse,
+  JsonRpcResponseSchema,
+  type JsonRpcSuccessResponse,
+  JsonRpcSuccessResponseSchema,
+  type McpServerConfig,
+  McpServerHttpSchema,
+  McpServerSchema,
+  McpServerStdioSchema,
   MessageStepSchema,
-  ToolCallStepSchema,
   PlanStepSchema,
-])
-
-/** Trajectory step type */
-export type TrajectoryStep = z.infer<typeof TrajectoryStepSchema>
-
-/** Indexed trajectory step with unique ID for correlation */
-export type IndexedStep = TrajectoryStep & { stepId: string }
-
-// ============================================================================
-// Capture Result Schemas
-// ============================================================================
-
-/**
- * Timing information for a capture result.
- *
- * @remarks
- * Captures both absolute timestamps and derived durations for analysis:
- * - `sessionCreation`: Time to initialize session (agent startup overhead)
- * - `total`: End-to-end duration including all turns
- * - `firstResponse`: Latency to first agent output (optional)
- *
- * Token counts are adapter-dependent and only present if the adapter
- * exposes usage information (e.g., Claude Code includes them, others may not).
- *
- * @public
- */
-export const TimingSchema = z.object({
-  /** Epoch timestamp when capture started */
-  start: z.number(),
-  /** Epoch timestamp when capture ended */
-  end: z.number(),
-  /** Time to first response (ms from start) */
-  firstResponse: z.number().optional(),
-  /** Time to create session (ms) - measures agent initialization overhead */
-  sessionCreation: z.number(),
-  /** Total duration (end - start) in milliseconds */
-  total: z.number(),
-  /** Input tokens consumed (if available from ACP adapter) */
-  inputTokens: z.number().optional(),
-  /** Output tokens generated (if available from ACP adapter) */
-  outputTokens: z.number().optional(),
-})
-
-/**
- * Timing information type inferred from TimingSchema.
- *
- * @public
- */
-export type Timing = z.infer<typeof TimingSchema>
-
-/**
- * Trajectory richness level indicating the depth of captured agent activity.
- *
- * @remarks
- * Different adapters provide varying levels of detail:
- * - `full`: Thoughts, tool calls, plans (e.g., Claude Code adapter)
- * - `minimal`: Basic output only (e.g., Droid adapter)
- * - `messages-only`: Messages without internal reasoning
- */
-export const TrajectoryRichnessSchema = z.enum(['full', 'minimal', 'messages-only'])
-
-/** Trajectory richness type */
-export type TrajectoryRichness = z.infer<typeof TrajectoryRichnessSchema>
-
-/**
- * Capture result schema.
- *
- * @remarks
- * Full trajectory output from the `capture` command.
- * - `input` can be string (single turn) or string[] (multi-turn)
- * - `hint` provides grader context (renamed from `expected`)
- * - `toolErrors` replaces misleading `status: 'passed'|'failed'`
- * Real pass/fail determination comes from your grader.
- */
-export const CaptureResultSchema = z.object({
-  /** Test case identifier */
-  id: z.string(),
-  /** Original prompt input (string for single turn, array for multi-turn) */
-  input: z.union([z.string(), z.array(z.string())]),
-  /** Final agent output */
-  output: z.string(),
-  /** Grader context hint (renamed from expected) */
-  hint: z.string().optional(),
-  /** Full execution trajectory */
-  trajectory: z.array(TrajectoryStepSchema),
-  /** Metadata including category, agent info, trajectoryRichness, turnCount */
-  metadata: z.record(z.string(), z.unknown()),
-  /** Timing information */
-  timing: TimingSchema,
-  /** Whether any tool calls failed */
-  toolErrors: z.boolean(),
-  /** Error messages (if any) */
-  errors: z.array(z.string()).optional(),
-  /** Grader score (if grader was provided) */
-  score: GraderResultSchema.optional(),
-})
-
-/** Capture result type */
-export type CaptureResult = z.infer<typeof CaptureResultSchema>
-
-// ============================================================================
-// Summary Result Schemas
-// ============================================================================
-
-/**
- * Summary result schema.
- *
- * @remarks
- * Compact view derived from full capture results via the `summarize` command.
- */
-export const SummaryResultSchema = z.object({
-  /** Test case identifier */
-  id: z.string(),
-  /** Original prompt input */
-  input: z.string(),
-  /** Final agent output */
-  output: z.string(),
-  /** List of tool names called */
-  toolCalls: z.array(z.string()),
-  /** Duration in milliseconds */
-  duration: z.number(),
-})
-
-/** Summary result type */
-export type SummaryResult = z.infer<typeof SummaryResultSchema>
-
-// ============================================================================
-// Trial Result Schemas
-// ============================================================================
-
-/** Single trial within a trial run */
-export const TrialEntrySchema = z.object({
-  /** Trial number (1-indexed) */
-  trialNum: z.number(),
-  /** Agent output for this trial */
-  output: z.string(),
-  /** Full trajectory for this trial */
-  trajectory: z.array(TrajectoryStepSchema),
-  /** Duration in milliseconds */
-  duration: z.number(),
-  /** Pass/fail (if grader provided) */
-  pass: z.boolean().optional(),
-  /** Numeric score (if grader provided) */
-  score: z.number().optional(),
-  /** Grader reasoning (if grader provided) */
-  reasoning: z.string().optional(),
-})
-
-/** Trial entry type */
-export type TrialEntry = z.infer<typeof TrialEntrySchema>
-
-/**
- * Trial result schema.
- *
- * @remarks
- * Output from the `trials` command for pass@k/pass^k analysis.
- * Metrics (passRate, passAtK, passExpK) are only present when a grader is provided.
- */
-export const TrialResultSchema = z.object({
-  /** Test case identifier */
-  id: z.string(),
-  /** Original prompt input (string for single turn, array for multi-turn) */
-  input: z.union([z.string(), z.array(z.string())]),
-  /** Grader context hint (renamed from expected) */
-  hint: z.string().optional(),
-  /** Number of trials (k) */
-  k: z.number(),
-  /** Simple pass rate: passes / k (with grader only) */
-  passRate: z.number().optional(),
-  /** pass@k: probability of at least one pass in k samples (with grader only) */
-  passAtK: z.number().optional(),
-  /** pass^k: probability of all k samples passing (with grader only) */
-  passExpK: z.number().optional(),
-  /** Individual trial results */
-  trials: z.array(TrialEntrySchema),
-})
-
-/** Trial result type */
-export type TrialResult = z.infer<typeof TrialResultSchema>
-
-// ============================================================================
-// Calibration Schemas
-// ============================================================================
-
-/** Calibration sample for grader review */
-export const CalibrationSampleSchema = z.object({
-  /** Test case identifier */
-  id: z.string(),
-  /** Original prompt input (string for single turn, array for multi-turn) */
-  input: z.union([z.string(), z.array(z.string())]),
-  /** Agent output */
-  output: z.string(),
-  /** Grader context hint (renamed from expected) */
-  hint: z.string().optional(),
-  /** Original grader score */
-  originalScore: GraderResultSchema,
-  /** Re-scored result (if different grader provided) */
-  rescoredResult: GraderResultSchema.optional(),
-  /** Key trajectory snippets */
-  trajectorySnippet: z.array(TrajectoryStepSchema),
-})
-
-/** Calibration sample type */
-export type CalibrationSample = z.infer<typeof CalibrationSampleSchema>
-
-// ============================================================================
-// Balance Analysis Schemas
-// ============================================================================
-
-/** Category distribution in test set */
-export const CategoryDistributionSchema = z.object({
-  /** Category name */
-  name: z.string(),
-  /** Number of test cases */
-  count: z.number(),
-  /** Percentage of total */
-  percentage: z.number(),
-})
-
-/** Category distribution type */
-export type CategoryDistribution = z.infer<typeof CategoryDistributionSchema>
-
-/** Balance analysis result */
-export const BalanceAnalysisSchema = z.object({
-  /** Total number of test cases */
-  totalCases: z.number(),
-  /** Distribution by category */
-  categories: z.array(CategoryDistributionSchema),
-  /** Categories that may need more test cases */
-  underrepresented: z.array(z.string()),
-  /** Suggested improvements */
-  suggestions: z.array(z.string()),
-})
-
-/** Balance analysis type */
-export type BalanceAnalysis = z.infer<typeof BalanceAnalysisSchema>
-
-// ============================================================================
-// Validation Reference Schemas
-// ============================================================================
-
-/** Validation result for a reference solution */
-export const ValidationResultSchema = z.object({
-  /** Test case identifier */
-  id: z.string(),
-  /** Reference solution provided */
-  reference: z.string(),
-  /** Whether reference passes the grader */
-  passes: z.boolean(),
-  /** Grader result */
-  graderResult: GraderResultSchema,
-})
-
-/** Validation result type */
-export type ValidationResult = z.infer<typeof ValidationResultSchema>
+  type PromptCase,
+  PromptCaseSchema,
+  type Session,
+  SessionSchema,
+  type SummaryResult,
+  SummaryResultSchema,
+  ThoughtStepSchema,
+  type Timing,
+  TimingSchema,
+  ToolCallStepSchema,
+  type ToolInput,
+  ToolInputSchema,
+  type TrajectoryRichness,
+  TrajectoryRichnessSchema,
+  type TrajectoryStep,
+  TrajectoryStepSchema,
+  type TrialEntry,
+  TrialEntrySchema,
+  type TrialResult,
+  TrialResultSchema,
+  type ValidationResult,
+  ValidationResultSchema,
+} from './schemas/schemas.ts'
+
+// Schemas CLI
+export type { SchemasConfig } from './schemas/schemas-cli.ts'
+export { runSchemas, schemasCli } from './schemas/schemas-cli.ts'
diff --git a/src/constants.ts b/src/schemas/constants.ts
similarity index 82%
rename from src/constants.ts
rename to src/schemas/constants.ts
index a3cc850..e7dbd2f 100644
--- a/src/constants.ts
+++ b/src/schemas/constants.ts
@@ -1,9 +1,9 @@
 /**
- * Constants for ACP client and harness operations.
+ * Constants for harness and JSON-RPC protocol operations.
  *
  * @remarks
  * Contains all constant values used across the implementation:
- * - ACP protocol method names and version
+ * - JSON-RPC method names and protocol version
  * - JSON-RPC error codes
  * - Harness defaults (timeouts, preview limits)
  *
@@ -11,11 +11,11 @@
  */
 
 // ============================================================================
-// ACP Protocol Methods
+// JSON-RPC Protocol Methods
 // ============================================================================
 
-/** ACP method names */
-export const ACP_METHODS = {
+/** JSON-RPC method names for headless adapter protocol */
+export const PROTOCOL_METHODS = {
   // Lifecycle
   INITIALIZE: 'initialize',
   SHUTDOWN: 'shutdown',
@@ -34,11 +34,11 @@ export const ACP_METHODS = {
 } as const
 
 // ============================================================================
-// ACP Protocol Version
+// Protocol Version
 // ============================================================================
 
-/** Current protocol version - SDK uses number type */
-export const ACP_PROTOCOL_VERSION = 1 as const
+/** Current protocol version */
+export const PROTOCOL_VERSION = 1 as const
 
 // ============================================================================
 // JSON-RPC Error Codes
@@ -55,14 +55,14 @@ export const JSON_RPC_ERRORS = {
 } as const
 
 // ============================================================================
-// ACP Client Defaults
+// Client Defaults
 // ============================================================================
 
-/** Default ACP Client Name */
-export const DEFAULT_ACP_CLIENT_NAME = 'plaited-acp-client'
+/** Default client name for protocol handshake */
+export const DEFAULT_CLIENT_NAME = 'plaited-eval-harness'
 
-/** Default timeout for ACP operations in milliseconds */
-export const DEFAULT_ACP_TIMEOUT = 30000
+/** Default timeout for protocol operations in milliseconds */
+export const DEFAULT_PROTOCOL_TIMEOUT = 30000
 
 /** Default polling interval for streaming updates in milliseconds */
 export const DEFAULT_POLLING_INTERVAL = 50
diff --git a/src/grader-loader.ts b/src/schemas/grader-loader.ts
similarity index 100%
rename from src/grader-loader.ts
rename to src/schemas/grader-loader.ts
diff --git a/src/schemas-cli.ts b/src/schemas/schemas-cli.ts
similarity index 95%
rename from src/schemas-cli.ts
rename to src/schemas/schemas-cli.ts
index c8f2723..e20f0ab 100644
--- a/src/schemas-cli.ts
+++ b/src/schemas/schemas-cli.ts
@@ -195,7 +195,7 @@ export const schemasCli = async (args: string[]): Promise<void> => {
   if (values.help) {
     // biome-ignore lint/suspicious/noConsole: CLI help output
     console.log(`
-Usage: acp-harness schemas [schema-name] [options]
+Usage: agent-eval-harness schemas [schema-name] [options]
 
 Arguments:
   schema-name       Specific schema to export (optional)
@@ -214,17 +214,17 @@ Available Schemas:
 
 Examples:
   # List available schemas
-  acp-harness schemas --list
+  agent-eval-harness schemas --list
 
   # Export all schemas as single JSON file
-  acp-harness schemas --json -o schemas.json
+  agent-eval-harness schemas --json -o schemas.json
 
   # Export specific schema
-  acp-harness schemas CaptureResult --json
-  acp-harness schemas TrialResult --json -o trial-schema.json
+  agent-eval-harness schemas CaptureResult --json
+  agent-eval-harness schemas TrialResult --json -o trial-schema.json
 
   # Export all schemas as separate files
-  acp-harness schemas --json --split -o schemas/
+  agent-eval-harness schemas --json --split -o schemas/
 `)
     return
   }
diff --git a/src/schemas/schemas.ts b/src/schemas/schemas.ts
new file mode 100644
index 0000000..7a81a17
--- /dev/null
+++ b/src/schemas/schemas.ts
@@ -0,0 +1,558 @@
+/**
+ * Unified Zod schemas and types for the agent eval harness.
+ *
+ * @remarks
+ * This module follows a schema-first approach where Zod schemas are the
+ * single source of truth. TypeScript types are derived using `z.infer<>`.
+ *
+ * **Exports:**
+ * - Harness schemas: PromptCaseSchema, GraderResultSchema, CaptureResultSchema, etc.
+ * - JSON-RPC schemas: JsonRpcRequestSchema, JsonRpcResponseSchema, etc. (for headless adapter)
+ * - All inferred types via `z.infer<>`
+ *
+ * **JSON Schema generation (Zod 4):**
+ * ```typescript
+ * import { z } from 'zod'
+ * import { CaptureResultSchema } from '@plaited/agent-eval-harness/schemas'
+ * const jsonSchema = z.toJSONSchema(CaptureResultSchema)
+ * ```
+ *
+ * @packageDocumentation
+ */
+
+import { z } from 'zod'
+
+// ============================================================================
+// Session Types
+// ============================================================================
+
+/**
+ * Session schema for session creation responses.
+ */
+export const SessionSchema = z.object({
+  id: z.string(),
+  _meta: z.record(z.string(), z.unknown()).nullish(),
+})
+
+/** Session object returned from session creation */
+export type Session = z.infer<typeof SessionSchema>
+
+// ============================================================================
+// JSON-RPC 2.0 Schemas (for headless adapter)
+// ============================================================================
+
+/** JSON-RPC version literal */
+const JsonRpcVersionSchema = z.literal('2.0')
+
+/** Request/response identifier */
+const RequestIdSchema = z.union([z.string(), z.number()])
+
+/**
+ * JSON-RPC 2.0 error object schema.
+ *
+ * @remarks
+ * Standard error codes:
+ * - `-32700`: Parse error
+ * - `-32600`: Invalid request
+ * - `-32601`: Method not found
+ * - `-32602`: Invalid params
+ * - `-32603`: Internal error
+ */
+export const JsonRpcErrorSchema = z.object({
+  code: z.number(),
+  message: z.string(),
+  data: z.unknown().optional(),
+})
+
+/** JSON-RPC 2.0 error object */
+export type JsonRpcError = z.infer<typeof JsonRpcErrorSchema>
+
+/** JSON-RPC 2.0 request schema */
+export const JsonRpcRequestSchema = z.object({
+  jsonrpc: JsonRpcVersionSchema,
+  id: RequestIdSchema,
+  method: z.string(),
+  params: z.unknown().optional(),
+})
+
+/** JSON-RPC 2.0 request structure */
+export type JsonRpcRequest<T = unknown> = Omit<z.infer<typeof JsonRpcRequestSchema>, 'params'> & {
+  params?: T
+}
+
+/** JSON-RPC 2.0 notification schema (no id, no response expected) */
+export const JsonRpcNotificationSchema = z.object({
+  jsonrpc: JsonRpcVersionSchema,
+  method: z.string(),
+  params: z.unknown().optional(),
+})
+
+/** JSON-RPC 2.0 notification structure (no id, no response expected) */
+export type JsonRpcNotification<T = unknown> = Omit<z.infer<typeof JsonRpcNotificationSchema>, 'params'> & {
+  params?: T
+}
+
+/** JSON-RPC 2.0 success response schema */
+export const JsonRpcSuccessResponseSchema = z.object({
+  jsonrpc: JsonRpcVersionSchema,
+  id: RequestIdSchema,
+  result: z.unknown(),
+})
+
+/** JSON-RPC 2.0 success response */
+export type JsonRpcSuccessResponse<T = unknown> = Omit<z.infer<typeof JsonRpcSuccessResponseSchema>, 'result'> & {
+  result: T
+}
+
+/** JSON-RPC 2.0 error response schema */
+export const JsonRpcErrorResponseSchema = z.object({
+  jsonrpc: JsonRpcVersionSchema,
+  id: z.union([RequestIdSchema, z.null()]),
+  error: JsonRpcErrorSchema,
+})
+
+/** JSON-RPC 2.0 error response */
+export type JsonRpcErrorResponse = z.infer<typeof JsonRpcErrorResponseSchema>
+
+/** Union of all JSON-RPC response types */
+export const JsonRpcResponseSchema = z.union([JsonRpcSuccessResponseSchema, JsonRpcErrorResponseSchema])
+
+/** Union of all JSON-RPC response types */
+export type JsonRpcResponse<T = unknown> = JsonRpcSuccessResponse<T> | JsonRpcErrorResponse
+
+/**
+ * Union of all JSON-RPC message types.
+ *
+ * @remarks
+ * Use `safeParse` at transport boundaries for runtime validation.
+ */
+export const JsonRpcMessageSchema = z.union([JsonRpcRequestSchema, JsonRpcNotificationSchema, JsonRpcResponseSchema])
+
+/** Union of all JSON-RPC message types */
+export type JsonRpcMessage<T = unknown> = JsonRpcRequest<T> | JsonRpcNotification<T> | JsonRpcResponse<T>
+
+// ============================================================================
+// MCP Server Configuration Schemas
+// ============================================================================
+
+/** Environment variable configuration */
+export const EnvVariableSchema = z.object({
+  name: z.string(),
+  value: z.string(),
+})
+
+/** HTTP header configuration */
+export const HttpHeaderSchema = z.object({
+  name: z.string(),
+  value: z.string(),
+})
+
+/** MCP server stdio transport configuration */
+export const McpServerStdioSchema = z.object({
+  type: z.literal('stdio').optional(),
+  name: z.string(),
+  command: z.string(),
+  args: z.array(z.string()),
+  env: z.array(EnvVariableSchema),
+})
+
+/** MCP server HTTP transport configuration */
+export const McpServerHttpSchema = z.object({
+  type: z.literal('http'),
+  name: z.string(),
+  url: z.string(),
+  headers: z.array(HttpHeaderSchema),
+})
+
+/** MCP server configuration (stdio or HTTP) */
+export const McpServerSchema = z.union([McpServerStdioSchema, McpServerHttpSchema])
+
+/** MCP server configuration type */
+export type McpServerConfig = z.infer<typeof McpServerSchema>
+
+// ============================================================================
+// Harness Input Schemas
+// ============================================================================
+
+/**
+ * Prompt case schema for evaluation inputs.
+ *
+ * @remarks
+ * Each line in a prompts.jsonl file should match this schema.
+ * - Single turn: `input: "Hello"` - one prompt, one session
+ * - Multi-turn: `input: ["Hello", "How are you?", "Goodbye"]` - sequential turns in one session
+ */
+export const PromptCaseSchema = z.object({
+  /** Unique identifier for the test case */
+  id: z.string(),
+  /** Prompt text(s) - string for single turn, array for multi-turn conversation */
+  input: z.union([z.string(), z.array(z.string())]),
+  /** Optional grader context hint (not a strict expected match) */
+  hint: z.string().optional(),
+  /** Optional reference solution for validation */
+  reference: z.string().optional(),
+  /** Optional metadata for categorization and analysis */
+  metadata: z.record(z.string(), z.unknown()).optional(),
+  /** Optional per-case timeout override in milliseconds */
+  timeout: z.number().optional(),
+})
+
+/** Prompt case type */
+export type PromptCase = z.infer<typeof PromptCaseSchema>
+
+// ============================================================================
+// Grader Schemas
+// ============================================================================
+
+/**
+ * Grader result schema.
+ *
+ * @remarks
+ * Result returned by user-provided grader functions.
+ */
+export const GraderResultSchema = z.object({
+  /** Whether the output passes the evaluation criteria */
+  pass: z.boolean(),
+  /** Numeric score from 0.0 to 1.0 */
+  score: z.number().min(0).max(1),
+  /** Optional explanation for the score */
+  reasoning: z.string().optional(),
+})
+
+/** Grader result type */
+export type GraderResult = z.infer<typeof GraderResultSchema>
+
+/**
+ * Grader function type.
+ *
+ * @remarks
+ * User-provided graders implement this interface to score agent outputs.
+ * - `input` is the original prompt (string or array for multi-turn)
+ * - `hint` provides grader context (renamed from `expected`)
+ */
+export type Grader = (params: {
+  input: string | string[]
+  output: string
+  hint?: string
+  trajectory?: TrajectoryStep[]
+}) => Promise<GraderResult>
+
+// ============================================================================
+// Trajectory Schemas
+// ============================================================================
+
+/** Tool input schema for extracting file paths and content */
+export const ToolInputSchema = z
+  .object({
+    file_path: z.string().optional(),
+    path: z.string().optional(),
+    content: z.string().optional(),
+    new_string: z.string().optional(),
+  })
+  .passthrough()
+
+/** Tool input type */
+export type ToolInput = z.infer<typeof ToolInputSchema>
+
+/** Thought trajectory step */
+export const ThoughtStepSchema = z.object({
+  type: z.literal('thought'),
+  content: z.string(),
+  timestamp: z.number(),
+  stepId: z.string().optional(),
+})
+
+/** Message trajectory step */
+export const MessageStepSchema = z.object({
+  type: z.literal('message'),
+  content: z.string(),
+  timestamp: z.number(),
+  stepId: z.string().optional(),
+})
+
+/** Tool call trajectory step */
+export const ToolCallStepSchema = z.object({
+  type: z.literal('tool_call'),
+  name: z.string(),
+  status: z.string(),
+  input: z.unknown().optional(),
+  output: z.unknown().optional(),
+  duration: z.number().optional(),
+  timestamp: z.number(),
+  stepId: z.string().optional(),
+})
+
+/** Plan trajectory step */
+export const PlanStepSchema = z.object({
+  type: z.literal('plan'),
+  entries: z.array(z.unknown()),
+  timestamp: z.number(),
+  stepId: z.string().optional(),
+})
+
+/**
+ * Trajectory step schema (discriminated union).
+ *
+ * @remarks
+ * Represents a single step in the agent's execution trajectory.
+ */
+export const TrajectoryStepSchema = z.discriminatedUnion('type', [
+  ThoughtStepSchema,
+  MessageStepSchema,
+  ToolCallStepSchema,
+  PlanStepSchema,
+])
+
+/** Trajectory step type */
+export type TrajectoryStep = z.infer<typeof TrajectoryStepSchema>
+
+/** Indexed trajectory step with unique ID for correlation */
+export type IndexedStep = TrajectoryStep & { stepId: string }
+
+// ============================================================================
+// Capture Result Schemas
+// ============================================================================
+
+/**
+ * Timing information for a capture result.
+ *
+ * @remarks
+ * Captures both absolute timestamps and derived durations for analysis:
+ * - `sessionCreation`: Time to initialize session (agent startup overhead)
+ * - `total`: End-to-end duration including all turns
+ * - `firstResponse`: Latency to first agent output (optional)
+ *
+ * Token counts are adapter-dependent and only present if the adapter
+ * exposes usage information (e.g., Claude Code includes them, others may not).
+ *
+ * @public
+ */
+export const TimingSchema = z.object({
+  /** Epoch timestamp when capture started */
+  start: z.number(),
+  /** Epoch timestamp when capture ended */
+  end: z.number(),
+  /** Time to first response (ms from start) */
+  firstResponse: z.number().optional(),
+  /** Time to create session (ms) - measures agent initialization overhead */
+  sessionCreation: z.number(),
+  /** Total duration (end - start) in milliseconds */
+  total: z.number(),
+  /** Input tokens consumed (if available from headless adapter) */
+  inputTokens: z.number().optional(),
+  /** Output tokens generated (if available from headless adapter) */
+  outputTokens: z.number().optional(),
+})
+
+/**
+ * Timing information type inferred from TimingSchema.
+ *
+ * @public
+ */
+export type Timing = z.infer<typeof TimingSchema>
+
+/**
+ * Trajectory richness level indicating the depth of captured agent activity.
+ *
+ * @remarks
+ * Different adapters provide varying levels of detail:
+ * - `full`: Thoughts, tool calls, plans (e.g., Claude Code adapter)
+ * - `minimal`: Basic output only (e.g., Droid adapter)
+ * - `messages-only`: Messages without internal reasoning
+ */
+export const TrajectoryRichnessSchema = z.enum(['full', 'minimal', 'messages-only'])
+
+/** Trajectory richness type */
+export type TrajectoryRichness = z.infer<typeof TrajectoryRichnessSchema>
+
+/**
+ * Capture result schema.
+ *
+ * @remarks
+ * Full trajectory output from the `capture` command.
+ * - `input` can be string (single turn) or string[] (multi-turn)
+ * - `hint` provides grader context (renamed from `expected`)
+ * - `toolErrors` replaces misleading `status: 'passed'|'failed'`
+ * Real pass/fail determination comes from your grader.
+ */
+export const CaptureResultSchema = z.object({
+  /** Test case identifier */
+  id: z.string(),
+  /** Original prompt input (string for single turn, array for multi-turn) */
+  input: z.union([z.string(), z.array(z.string())]),
+  /** Final agent output */
+  output: z.string(),
+  /** Grader context hint (renamed from expected) */
+  hint: z.string().optional(),
+  /** Full execution trajectory */
+  trajectory: z.array(TrajectoryStepSchema),
+  /** Metadata including category, agent info, trajectoryRichness, turnCount */
+  metadata: z.record(z.string(), z.unknown()),
+  /** Timing information */
+  timing: TimingSchema,
+  /** Whether any tool calls failed */
+  toolErrors: z.boolean(),
+  /** Error messages (if any) */
+  errors: z.array(z.string()).optional(),
+  /** Grader score (if grader was provided) */
+  score: GraderResultSchema.optional(),
+})
+
+/** Capture result type */
+export type CaptureResult = z.infer<typeof CaptureResultSchema>
+
+// ============================================================================
+// Summary Result Schemas
+// ============================================================================
+
+/**
+ * Summary result schema.
+ *
+ * @remarks
+ * Compact view derived from full capture results via the `summarize` command.
+ */
+export const SummaryResultSchema = z.object({
+  /** Test case identifier */
+  id: z.string(),
+  /** Original prompt input */
+  input: z.string(),
+  /** Final agent output */
+  output: z.string(),
+  /** List of tool names called */
+  toolCalls: z.array(z.string()),
+  /** Duration in milliseconds */
+  duration: z.number(),
+})
+
+/** Summary result type */
+export type SummaryResult = z.infer<typeof SummaryResultSchema>
+
+// ============================================================================
+// Trial Result Schemas
+// ============================================================================
+
+/** Single trial within a trial run */
+export const TrialEntrySchema = z.object({
+  /** Trial number (1-indexed) */
+  trialNum: z.number(),
+  /** Agent output for this trial */
+  output: z.string(),
+  /** Full trajectory for this trial */
+  trajectory: z.array(TrajectoryStepSchema),
+  /** Duration in milliseconds */
+  duration: z.number(),
+  /** Pass/fail (if grader provided) */
+  pass: z.boolean().optional(),
+  /** Numeric score (if grader provided) */
+  score: z.number().optional(),
+  /** Grader reasoning (if grader provided) */
+  reasoning: z.string().optional(),
+})
+
+/** Trial entry type */
+export type TrialEntry = z.infer<typeof TrialEntrySchema>
+
+/**
+ * Trial result schema.
+ *
+ * @remarks
+ * Output from the `trials` command for pass@k/pass^k analysis.
+ * Metrics (passRate, passAtK, passExpK) are only present when a grader is provided.
+ */
+export const TrialResultSchema = z.object({
+  /** Test case identifier */
+  id: z.string(),
+  /** Original prompt input (string for single turn, array for multi-turn) */
+  input: z.union([z.string(), z.array(z.string())]),
+  /** Grader context hint (renamed from expected) */
+  hint: z.string().optional(),
+  /** Number of trials (k) */
+  k: z.number(),
+  /** Simple pass rate: passes / k (with grader only) */
+  passRate: z.number().optional(),
+  /** pass@k: probability of at least one pass in k samples (with grader only) */
+  passAtK: z.number().optional(),
+  /** pass^k: probability of all k samples passing (with grader only) */
+  passExpK: z.number().optional(),
+  /** Individual trial results */
+  trials: z.array(TrialEntrySchema),
+})
+
+/** Trial result type */
+export type TrialResult = z.infer<typeof TrialResultSchema>
+
+// ============================================================================
+// Calibration Schemas
+// ============================================================================
+
+/** Calibration sample for grader review */
+export const CalibrationSampleSchema = z.object({
+  /** Test case identifier */
+  id: z.string(),
+  /** Original prompt input (string for single turn, array for multi-turn) */
+  input: z.union([z.string(), z.array(z.string())]),
+  /** Agent output */
+  output: z.string(),
+  /** Grader context hint (renamed from expected) */
+  hint: z.string().optional(),
+  /** Original grader score */
+  originalScore: GraderResultSchema,
+  /** Re-scored result (if different grader provided) */
+  rescoredResult: GraderResultSchema.optional(),
+  /** Key trajectory snippets */
+  trajectorySnippet: z.array(TrajectoryStepSchema),
+})
+
+/** Calibration sample type */
+export type CalibrationSample = z.infer<typeof CalibrationSampleSchema>
+
+// ============================================================================
+// Balance Analysis Schemas
+// ============================================================================
+
+/** Category distribution in test set */
+export const CategoryDistributionSchema = z.object({
+  /** Category name */
+  name: z.string(),
+  /** Number of test cases */
+  count: z.number(),
+  /** Percentage of total */
+  percentage: z.number(),
+})
+
+/** Category distribution type */
+export type CategoryDistribution = z.infer<typeof CategoryDistributionSchema>
+
+/** Balance analysis result */
+export const BalanceAnalysisSchema = z.object({
+  /** Total number of test cases */
+  totalCases: z.number(),
+  /** Distribution by category */
+  categories: z.array(CategoryDistributionSchema),
+  /** Categories that may need more test cases */
+  underrepresented: z.array(z.string()),
+  /** Suggested improvements */
+  suggestions: z.array(z.string()),
+})
+
+/** Balance analysis type */
+export type BalanceAnalysis = z.infer<typeof BalanceAnalysisSchema>
+
+// ============================================================================
+// Validation Reference Schemas
+// ============================================================================
+
+/** Validation result for a reference solution */
+export const ValidationResultSchema = z.object({
+  /** Test case identifier */
+  id: z.string(),
+  /** Reference solution provided */
+  reference: z.string(),
+  /** Whether reference passes the grader */
+  passes: z.boolean(),
+  /** Grader result */
+  graderResult: GraderResultSchema,
+})
+
+/** Validation result type */
+export type ValidationResult = z.infer<typeof ValidationResultSchema>
diff --git a/src/tests/constants.spec.ts b/src/schemas/tests/constants.spec.ts
similarity index 69%
rename from src/tests/constants.spec.ts
rename to src/schemas/tests/constants.spec.ts
index fe189b8..d140314 100644
--- a/src/tests/constants.spec.ts
+++ b/src/schemas/tests/constants.spec.ts
@@ -1,47 +1,47 @@
 import { describe, expect, test } from 'bun:test'
 import {
-  ACP_METHODS,
-  ACP_PROTOCOL_VERSION,
-  DEFAULT_ACP_CLIENT_NAME,
-  DEFAULT_ACP_TIMEOUT,
   DEFAULT_CALIBRATION_SAMPLE_SIZE,
+  DEFAULT_CLIENT_NAME,
   DEFAULT_HARNESS_TIMEOUT,
   DEFAULT_POLLING_INTERVAL,
+  DEFAULT_PROTOCOL_TIMEOUT,
   DEFAULT_TRIAL_COUNT,
   HEAD_LINES,
   JSON_RPC_ERRORS,
   MAX_CONTENT_LENGTH,
+  PROTOCOL_METHODS,
+  PROTOCOL_VERSION,
   TAIL_LINES,
 } from '../constants.ts'
 
 // ============================================================================
-// ACP Protocol Constants
+// JSON-RPC Protocol Constants
 // ============================================================================
 
-describe('ACP_METHODS', () => {
+describe('PROTOCOL_METHODS', () => {
   test('contains all required lifecycle methods', () => {
-    expect(ACP_METHODS.INITIALIZE).toBe('initialize')
-    expect(ACP_METHODS.SHUTDOWN).toBe('shutdown')
+    expect(PROTOCOL_METHODS.INITIALIZE).toBe('initialize')
+    expect(PROTOCOL_METHODS.SHUTDOWN).toBe('shutdown')
   })
 
   test('contains all required session methods', () => {
-    expect(ACP_METHODS.CREATE_SESSION).toBe('session/new')
-    expect(ACP_METHODS.LOAD_SESSION).toBe('session/load')
-    expect(ACP_METHODS.PROMPT).toBe('session/prompt')
-    expect(ACP_METHODS.CANCEL).toBe('session/cancel')
-    expect(ACP_METHODS.UPDATE).toBe('session/update')
-    expect(ACP_METHODS.REQUEST_PERMISSION).toBe('session/request_permission')
-    expect(ACP_METHODS.SET_MODEL).toBe('session/set_model')
+    expect(PROTOCOL_METHODS.CREATE_SESSION).toBe('session/new')
+    expect(PROTOCOL_METHODS.LOAD_SESSION).toBe('session/load')
+    expect(PROTOCOL_METHODS.PROMPT).toBe('session/prompt')
+    expect(PROTOCOL_METHODS.CANCEL).toBe('session/cancel')
+    expect(PROTOCOL_METHODS.UPDATE).toBe('session/update')
+    expect(PROTOCOL_METHODS.REQUEST_PERMISSION).toBe('session/request_permission')
+    expect(PROTOCOL_METHODS.SET_MODEL).toBe('session/set_model')
   })
 
   test('contains protocol-level methods', () => {
-    expect(ACP_METHODS.CANCEL_REQUEST).toBe('$/cancel_request')
+    expect(PROTOCOL_METHODS.CANCEL_REQUEST).toBe('$/cancel_request')
   })
 })
 
-describe('ACP_PROTOCOL_VERSION', () => {
+describe('PROTOCOL_VERSION', () => {
   test('is version 1', () => {
-    expect(ACP_PROTOCOL_VERSION).toBe(1)
+    expect(PROTOCOL_VERSION).toBe(1)
   })
 })
 
@@ -58,22 +58,22 @@ describe('JSON_RPC_ERRORS', () => {
     expect(JSON_RPC_ERRORS.INTERNAL_ERROR).toBe(-32603)
   })
 
-  test('contains ACP extension error codes', () => {
+  test('contains extension error codes', () => {
     expect(JSON_RPC_ERRORS.REQUEST_CANCELLED).toBe(-32800)
   })
 })
 
 // ============================================================================
-// ACP Client Defaults
+// Client Defaults
 // ============================================================================
 
-describe('ACP Client defaults', () => {
-  test('DEFAULT_ACP_CLIENT_NAME is set', () => {
-    expect(DEFAULT_ACP_CLIENT_NAME).toBe('plaited-acp-client')
+describe('Client defaults', () => {
+  test('DEFAULT_CLIENT_NAME is set', () => {
+    expect(DEFAULT_CLIENT_NAME).toBe('plaited-eval-harness')
   })
 
-  test('DEFAULT_ACP_TIMEOUT is 30 seconds', () => {
-    expect(DEFAULT_ACP_TIMEOUT).toBe(30000)
+  test('DEFAULT_PROTOCOL_TIMEOUT is 30 seconds', () => {
+    expect(DEFAULT_PROTOCOL_TIMEOUT).toBe(30000)
   })
 
   test('DEFAULT_POLLING_INTERVAL is 50ms', () => {
diff --git a/src/tests/fixtures/grader-bad-module.ts b/src/schemas/tests/fixtures/grader-bad-module.ts
similarity index 100%
rename from src/tests/fixtures/grader-bad-module.ts
rename to src/schemas/tests/fixtures/grader-bad-module.ts
diff --git a/src/tests/fixtures/grader-exec-fail.py b/src/schemas/tests/fixtures/grader-exec-fail.py
similarity index 100%
rename from src/tests/fixtures/grader-exec-fail.py
rename to src/schemas/tests/fixtures/grader-exec-fail.py
diff --git a/src/tests/fixtures/grader-exec-invalid.py b/src/schemas/tests/fixtures/grader-exec-invalid.py
similarity index 100%
rename from src/tests/fixtures/grader-exec-invalid.py
rename to src/schemas/tests/fixtures/grader-exec-invalid.py
diff --git a/src/tests/fixtures/grader-exec.py b/src/schemas/tests/fixtures/grader-exec.py
similarity index 100%
rename from src/tests/fixtures/grader-exec.py
rename to src/schemas/tests/fixtures/grader-exec.py
diff --git a/src/tests/fixtures/grader-module.ts b/src/schemas/tests/fixtures/grader-module.ts
similarity index 100%
rename from src/tests/fixtures/grader-module.ts
rename to src/schemas/tests/fixtures/grader-module.ts
diff --git a/src/tests/grader-loader.spec.ts b/src/schemas/tests/grader-loader.spec.ts
similarity index 100%
rename from src/tests/grader-loader.spec.ts
rename to src/schemas/tests/grader-loader.spec.ts
diff --git a/src/tests/schemas-cli.spec.ts b/src/schemas/tests/schemas-cli.spec.ts
similarity index 98%
rename from src/tests/schemas-cli.spec.ts
rename to src/schemas/tests/schemas-cli.spec.ts
index 95be316..2c81480 100644
--- a/src/tests/schemas-cli.spec.ts
+++ b/src/schemas/tests/schemas-cli.spec.ts
@@ -6,7 +6,7 @@ import { runSchemas } from '../schemas-cli.ts'
 // ============================================================================
 
 describe('runSchemas', () => {
-  const testOutputDir = '/tmp/acp-harness-test-schemas'
+  const testOutputDir = '/tmp/agent-eval-harness-test-schemas'
 
   beforeEach(async () => {
     // Clean up test directory
diff --git a/src/tests/schemas.spec.ts b/src/schemas/tests/schemas.spec.ts
similarity index 91%
rename from src/tests/schemas.spec.ts
rename to src/schemas/tests/schemas.spec.ts
index a7b013a..7df25a3 100644
--- a/src/tests/schemas.spec.ts
+++ b/src/schemas/tests/schemas.spec.ts
@@ -17,8 +17,6 @@ import {
   MessageStepSchema,
   PlanStepSchema,
   PromptCaseSchema,
-  RequestPermissionRequestSchema,
-  SessionNotificationSchema,
   SessionSchema,
   ThoughtStepSchema,
   TimingSchema,
@@ -191,55 +189,6 @@ describe('JsonRpcMessageSchema', () => {
   })
 })
 
-// ============================================================================
-// ACP SDK Type Schemas
-// ============================================================================
-
-describe('SessionNotificationSchema', () => {
-  test('validates session notification structure', () => {
-    const result = SessionNotificationSchema.safeParse({
-      sessionId: 'sess_123',
-      update: { type: 'message' },
-    })
-    expect(result.success).toBe(true)
-  })
-
-  test('rejects missing sessionId', () => {
-    const result = SessionNotificationSchema.safeParse({
-      update: { type: 'message' },
-    })
-    expect(result.success).toBe(false)
-  })
-
-  test('rejects missing update', () => {
-    const result = SessionNotificationSchema.safeParse({
-      sessionId: 'sess_123',
-    })
-    expect(result.success).toBe(false)
-  })
-})
-
-describe('RequestPermissionRequestSchema', () => {
-  test('validates permission request with options array', () => {
-    const result = RequestPermissionRequestSchema.safeParse({
-      options: [{ id: 1, label: 'Allow' }],
-    })
-    expect(result.success).toBe(true)
-  })
-
-  test('rejects missing options', () => {
-    const result = RequestPermissionRequestSchema.safeParse({})
-    expect(result.success).toBe(false)
-  })
-
-  test('rejects non-array options', () => {
-    const result = RequestPermissionRequestSchema.safeParse({
-      options: 'not-an-array',
-    })
-    expect(result.success).toBe(false)
-  })
-})
-
 // ============================================================================
 // MCP Server Schemas
 // ============================================================================
diff --git a/src/tests/acp-client.spec.ts b/src/tests/acp-client.spec.ts
deleted file mode 100644
index 20dd306..0000000
--- a/src/tests/acp-client.spec.ts
+++ /dev/null
@@ -1,205 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import { ACPClientError, createACPClient } from '../acp-client.ts'
-
-// ============================================================================
-// ACPClientError Tests
-// ============================================================================
-
-describe('ACPClientError', () => {
-  test('creates error with message only', () => {
-    const error = new ACPClientError('Connection failed')
-    expect(error.message).toBe('Connection failed')
-    expect(error.name).toBe('ACPClientError')
-    expect(error.code).toBeUndefined()
-  })
-
-  test('creates error with code', () => {
-    const error = new ACPClientError('Not connected', 'NOT_CONNECTED')
-    expect(error.code).toBe('NOT_CONNECTED')
-  })
-
-  test('is instance of Error', () => {
-    const error = new ACPClientError('Test')
-    expect(error instanceof Error).toBe(true)
-    expect(error instanceof ACPClientError).toBe(true)
-  })
-})
-
-// ============================================================================
-// Client Factory Tests
-// ============================================================================
-
-describe('createACPClient', () => {
-  test('creates client with minimal config', () => {
-    const client = createACPClient({
-      command: ['echo', 'test'],
-    })
-
-    expect(client).toBeDefined()
-    expect(typeof client.connect).toBe('function')
-    expect(typeof client.disconnect).toBe('function')
-    expect(typeof client.createSession).toBe('function')
-    expect(typeof client.prompt).toBe('function')
-    expect(typeof client.promptSync).toBe('function')
-    expect(typeof client.cancelPrompt).toBe('function')
-    expect(typeof client.getCapabilities).toBe('function')
-    expect(typeof client.getInitializeResult).toBe('function')
-    expect(typeof client.isConnected).toBe('function')
-  })
-
-  test('creates client with full config', () => {
-    const client = createACPClient({
-      command: ['claude', 'code'],
-      cwd: '/tmp',
-      env: { TEST: 'value' },
-      clientInfo: { name: 'test-client', version: '1.0.0' },
-      capabilities: { fs: { readTextFile: true } },
-      timeout: 60000,
-      onPermissionRequest: async () => ({ outcome: { outcome: 'cancelled' } }),
-    })
-
-    expect(client).toBeDefined()
-  })
-})
-
-// ============================================================================
-// State Methods (before connection)
-// ============================================================================
-
-describe('Client state before connection', () => {
-  test('isConnected returns false before connect', () => {
-    const client = createACPClient({
-      command: ['echo', 'test'],
-    })
-
-    expect(client.isConnected()).toBe(false)
-  })
-
-  test('getCapabilities returns undefined before connect', () => {
-    const client = createACPClient({
-      command: ['echo', 'test'],
-    })
-
-    expect(client.getCapabilities()).toBeUndefined()
-  })
-
-  test('getInitializeResult returns undefined before connect', () => {
-    const client = createACPClient({
-      command: ['echo', 'test'],
-    })
-
-    expect(client.getInitializeResult()).toBeUndefined()
-  })
-})
-
-// ============================================================================
-// Operations Before Connection
-// ============================================================================
-
-describe('Operations before connection', () => {
-  test('createSession throws when not connected', async () => {
-    const client = createACPClient({
-      command: ['echo', 'test'],
-    })
-
-    await expect(client.createSession({ cwd: '/tmp' })).rejects.toThrow('Not connected')
-  })
-
-  test('promptSync throws when not connected', async () => {
-    const client = createACPClient({
-      command: ['echo', 'test'],
-    })
-
-    await expect(client.promptSync('session-1', [{ type: 'text', text: 'Hello' }])).rejects.toThrow('Not connected')
-  })
-
-  test('cancelPrompt throws when not connected', async () => {
-    const client = createACPClient({
-      command: ['echo', 'test'],
-    })
-
-    await expect(client.cancelPrompt('session-1')).rejects.toThrow('Not connected')
-  })
-
-  test('prompt generator throws when not connected', async () => {
-    const client = createACPClient({
-      command: ['echo', 'test'],
-    })
-
-    const generator = client.prompt('session-1', [{ type: 'text', text: 'Hello' }])
-
-    await expect(generator.next()).rejects.toThrow('Not connected')
-  })
-})
-
-// ============================================================================
-// Disconnect Safety
-// ============================================================================
-
-describe('Disconnect safety', () => {
-  test('disconnect is safe when not connected', async () => {
-    const client = createACPClient({
-      command: ['echo', 'test'],
-    })
-
-    // Should not throw
-    await client.disconnect()
-    expect(client.isConnected()).toBe(false)
-  })
-
-  test('disconnect with graceful=false is safe when not connected', async () => {
-    const client = createACPClient({
-      command: ['echo', 'test'],
-    })
-
-    // Should not throw
-    await client.disconnect(false)
-    expect(client.isConnected()).toBe(false)
-  })
-})
-
-// ============================================================================
-// Integration Tests with Mock Process
-// ============================================================================
-
-describe('Client with mock process', () => {
-  test('connect starts transport', async () => {
-    const client = createACPClient({
-      command: ['cat'], // cat echoes back input
-      timeout: 1000,
-    })
-
-    // Start connection - cat won't respond with proper JSON-RPC
-    // so this will timeout, but it tests the transport startup
-    try {
-      await client.connect()
-    } catch {
-      // Expected - cat doesn't speak JSON-RPC
-    }
-
-    // Cleanup
-    await client.disconnect(false)
-  })
-
-  test('connect throws when already connected', async () => {
-    const client = createACPClient({
-      command: ['cat'],
-      timeout: 500,
-    })
-
-    // Start first connection
-    const connectPromise = client.connect()
-
-    // Immediately try second connection (before first completes)
-    // This should throw because transport is started
-    await expect(client.connect()).rejects.toThrow('Already connected')
-
-    // Cleanup - wait for first connect to timeout then disconnect
-    try {
-      await connectPromise
-    } catch {
-      // Expected timeout
-    }
-    await client.disconnect(false)
-  })
-})
diff --git a/src/tests/acp-helpers.spec.ts b/src/tests/acp-helpers.spec.ts
deleted file mode 100644
index 0779ee9..0000000
--- a/src/tests/acp-helpers.spec.ts
+++ /dev/null
@@ -1,105 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import type { SessionNotification } from '@agentclientprotocol/sdk'
-import { createPrompt, createPromptWithFiles, createPromptWithImage, summarizeResponse } from '../acp-helpers.ts'
-
-// ============================================================================
-// Prompt Building Utilities
-// ============================================================================
-
-describe('createPrompt', () => {
-  test('creates single text block prompt', () => {
-    const prompt = createPrompt('Hello agent')
-    expect(prompt).toHaveLength(1)
-    expect(prompt[0]).toEqual({ type: 'text', text: 'Hello agent' })
-  })
-})
-
-describe('createPromptWithFiles', () => {
-  test('creates prompt with file context', () => {
-    const prompt = createPromptWithFiles('Analyze this', [
-      { path: '/src/main.ts', content: 'const x = 1;' },
-      { path: '/src/utils.ts', content: 'export const y = 2;' },
-    ])
-    expect(prompt).toHaveLength(3)
-    expect(prompt[0]).toEqual({ type: 'text', text: 'Analyze this' })
-    expect(prompt[1]?.type).toBe('resource')
-    expect(prompt[2]?.type).toBe('resource')
-  })
-})
-
-describe('createPromptWithImage', () => {
-  test('creates prompt with image', () => {
-    const prompt = createPromptWithImage({ text: 'Describe this', imageData: 'base64img', mimeType: 'image/png' })
-    expect(prompt).toHaveLength(2)
-    expect(prompt[0]).toEqual({ type: 'text', text: 'Describe this' })
-    expect(prompt[1]).toEqual({
-      type: 'image',
-      data: 'base64img',
-      mimeType: 'image/png',
-    })
-  })
-})
-
-// ============================================================================
-// Response Analysis
-// ============================================================================
-
-describe('summarizeResponse', () => {
-  test('creates comprehensive summary', () => {
-    const notifications: SessionNotification[] = [
-      {
-        sessionId: 's1',
-        update: { sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: 'Processing...' } },
-      },
-      {
-        sessionId: 's1',
-        update: { sessionUpdate: 'tool_call', toolCallId: 't1', title: 'read', status: 'in_progress' },
-      },
-      {
-        sessionId: 's1',
-        update: {
-          sessionUpdate: 'plan',
-          entries: [{ content: 'Step 1', status: 'in_progress', priority: 'high' }],
-        },
-      },
-      {
-        sessionId: 's1',
-        update: { sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: 'Done!' } },
-      },
-      {
-        sessionId: 's1',
-        update: { sessionUpdate: 'tool_call', toolCallId: 't1', title: 'read', status: 'completed' },
-      },
-      {
-        sessionId: 's1',
-        update: {
-          sessionUpdate: 'plan',
-          entries: [{ content: 'Step 1', status: 'completed', priority: 'high' }],
-        },
-      },
-    ]
-
-    const summary = summarizeResponse(notifications)
-
-    expect(summary.text).toBe('Processing...Done!')
-    expect(summary.toolCallCount).toBe(1)
-    expect(summary.completedToolCalls).toHaveLength(1)
-    expect(summary.failedToolCalls).toHaveLength(0)
-    expect(summary.plan).toHaveLength(1)
-    expect(summary.planProgress).toBe(100)
-    expect(summary.hasErrors).toBe(false)
-  })
-
-  test('detects errors in summary', () => {
-    const notifications: SessionNotification[] = [
-      {
-        sessionId: 's1',
-        update: { sessionUpdate: 'tool_call', toolCallId: 't1', title: 'read', status: 'failed' },
-      },
-    ]
-
-    const summary = summarizeResponse(notifications)
-    expect(summary.hasErrors).toBe(true)
-    expect(summary.failedToolCalls).toHaveLength(1)
-  })
-})
diff --git a/src/tests/acp-transport.spec.ts b/src/tests/acp-transport.spec.ts
deleted file mode 100644
index b99bc28..0000000
--- a/src/tests/acp-transport.spec.ts
+++ /dev/null
@@ -1,153 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import { createACPTransport } from '../acp-transport.ts'
-
-// ============================================================================
-// Transport Creation Tests (without spawning)
-// ============================================================================
-
-describe('createACPTransport', () => {
-  test('throws on empty command', async () => {
-    const transport = createACPTransport({
-      command: [],
-    })
-
-    await expect(transport.start()).rejects.toThrow('Command array is empty')
-  })
-
-  test('isConnected returns false before start', async () => {
-    const transport = createACPTransport({
-      command: ['echo', 'test'],
-    })
-
-    expect(transport.isConnected()).toBe(false)
-  })
-
-  test('request throws when not connected', async () => {
-    const transport = createACPTransport({
-      command: ['echo', 'test'],
-    })
-
-    await expect(transport.request('test/method')).rejects.toThrow('Transport is not connected')
-  })
-
-  test('notify throws when not connected', async () => {
-    const transport = createACPTransport({
-      command: ['echo', 'test'],
-    })
-
-    await expect(transport.notify('test/notification')).rejects.toThrow('Transport is not connected')
-  })
-
-  test('close is safe when not started', async () => {
-    const transport = createACPTransport({
-      command: ['echo', 'test'],
-    })
-
-    // Should not throw
-    await transport.close()
-    expect(transport.isConnected()).toBe(false)
-  })
-})
-
-// ============================================================================
-// Mock Subprocess Integration Tests
-// ============================================================================
-
-describe('Transport with mock subprocess', () => {
-  test('starts transport with valid command', async () => {
-    const transport = createACPTransport({
-      command: ['cat'], // cat echoes back input
-      timeout: 1000,
-    })
-
-    await transport.start()
-    expect(transport.isConnected()).toBe(true)
-
-    // Close immediately since cat doesn't speak JSON-RPC
-    await transport.close(false)
-    expect(transport.isConnected()).toBe(false)
-  })
-
-  test('throws on duplicate start', async () => {
-    const transport = createACPTransport({
-      command: ['cat'],
-      timeout: 1000,
-    })
-
-    await transport.start()
-
-    try {
-      await expect(transport.start()).rejects.toThrow('Transport already started')
-    } finally {
-      await transport.close(false)
-    }
-  })
-
-  test('handles process exit', async () => {
-    const { createACPTransport } = await import('../acp-transport.ts')
-
-    let closeCalled = false
-    let closeCode: number | null = null
-
-    const transport = createACPTransport({
-      command: ['true'], // exits immediately with code 0
-      timeout: 1000,
-      onClose: (code) => {
-        closeCalled = true
-        closeCode = code
-      },
-    })
-
-    await transport.start()
-
-    // Wait for process to exit
-    await new Promise((resolve) => setTimeout(resolve, 100))
-
-    expect(closeCalled).toBe(true)
-    expect(closeCode === 0).toBe(true)
-  })
-
-  test('handles invalid command', async () => {
-    const transport = createACPTransport({
-      command: ['nonexistent-command-that-does-not-exist-12345'],
-      timeout: 1000,
-    })
-
-    // Bun.spawn may throw or exit with error depending on the command
-    try {
-      await transport.start()
-      // If it doesn't throw, wait for process exit
-      await new Promise((resolve) => setTimeout(resolve, 100))
-    } catch {
-      // Expected - command not found
-    }
-  })
-})
-
-// ============================================================================
-// Error Handling Tests
-// ============================================================================
-
-describe('Transport error handling', () => {
-  test('request times out when no response received', async () => {
-    // TODO(human): Implement timeout test
-  })
-
-  test('close rejects pending requests', async () => {
-    const transport = createACPTransport({
-      command: ['cat'],
-      timeout: 5000,
-    })
-
-    await transport.start()
-
-    // Start a request that will never complete (cat doesn't speak JSON-RPC)
-    const requestPromise = transport.request('test/method')
-
-    // Close transport while request is pending
-    await transport.close(false)
-
-    // Request should be rejected with "Transport closed"
-    await expect(requestPromise).rejects.toThrow('Transport closed')
-  })
-})
diff --git a/src/tests/acp-utils.spec.ts b/src/tests/acp-utils.spec.ts
deleted file mode 100644
index 5f869e2..0000000
--- a/src/tests/acp-utils.spec.ts
+++ /dev/null
@@ -1,394 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import type { ContentBlock, PlanEntry, SessionNotification, ToolCall } from '@agentclientprotocol/sdk'
-import {
-  createAudioContent,
-  createBlobResource,
-  createImageContent,
-  createResourceLink,
-  createTextContent,
-  createTextResource,
-  extractLatestToolCalls,
-  extractPlan,
-  extractText,
-  extractTextFromUpdates,
-  extractToolCalls,
-  filterPlanByStatus,
-  filterToolCallsByStatus,
-  filterToolCallsByTitle,
-  getCompletedToolCallsWithContent,
-  getPlanProgress,
-  hasToolCallErrors,
-} from '../acp-utils.ts'
-
-// ============================================================================
-// Content Block Builders
-// ============================================================================
-
-describe('createTextContent', () => {
-  test('creates text content block', () => {
-    const content = createTextContent('Hello world')
-    expect(content.type).toBe('text')
-    // Type narrowing to access text property
-    if (content.type === 'text') {
-      expect(content.text).toBe('Hello world')
-    }
-  })
-})
-
-describe('createImageContent', () => {
-  test('creates image content with required fields', () => {
-    const content = createImageContent('base64data', 'image/png')
-    expect(content.type).toBe('image')
-    if (content.type === 'image') {
-      expect(content.data).toBe('base64data')
-      expect(content.mimeType).toBe('image/png')
-    }
-  })
-})
-
-describe('createAudioContent', () => {
-  test('creates audio content block', () => {
-    const content = createAudioContent('audiodata', 'audio/wav')
-    expect(content.type).toBe('audio')
-    if (content.type === 'audio') {
-      expect(content.data).toBe('audiodata')
-      expect(content.mimeType).toBe('audio/wav')
-    }
-  })
-})
-
-describe('createResourceLink', () => {
-  test('creates resource link with uri and name', () => {
-    const content = createResourceLink({ uri: 'file:///path/to/file.ts', name: 'file.ts' })
-    expect(content.type).toBe('resource_link')
-    if (content.type === 'resource_link') {
-      expect(content.uri).toBe('file:///path/to/file.ts')
-      expect(content.name).toBe('file.ts')
-    }
-  })
-
-  test('includes optional mimeType', () => {
-    const content = createResourceLink({ uri: 'file:///path/to/file.ts', name: 'file.ts', mimeType: 'text/typescript' })
-    if (content.type === 'resource_link') {
-      expect(content.mimeType).toBe('text/typescript')
-    }
-  })
-})
-
-describe('createTextResource', () => {
-  test('creates embedded text resource', () => {
-    const content = createTextResource({ uri: 'file:///src/main.ts', text: 'const x = 1;' })
-    expect(content.type).toBe('resource')
-    if (content.type === 'resource') {
-      expect(content.resource.uri).toBe('file:///src/main.ts')
-      expect('text' in content.resource && content.resource.text).toBe('const x = 1;')
-    }
-  })
-
-  test('includes optional mimeType', () => {
-    const content = createTextResource({
-      uri: 'file:///src/main.ts',
-      text: 'const x = 1;',
-      mimeType: 'text/typescript',
-    })
-    if (content.type === 'resource' && 'text' in content.resource) {
-      expect(content.resource.mimeType).toBe('text/typescript')
-    }
-  })
-})
-
-describe('createBlobResource', () => {
-  test('creates embedded blob resource', () => {
-    const content = createBlobResource({ uri: 'file:///image.png', blob: 'base64blobdata' })
-    expect(content.type).toBe('resource')
-    if (content.type === 'resource' && 'blob' in content.resource) {
-      expect(content.resource.uri).toBe('file:///image.png')
-      expect(content.resource.blob).toBe('base64blobdata')
-    }
-  })
-})
-
-// ============================================================================
-// Content Extraction
-// ============================================================================
-
-describe('extractText', () => {
-  test('extracts text from text content blocks', () => {
-    const content: ContentBlock[] = [
-      { type: 'text', text: 'Hello' },
-      { type: 'text', text: 'World' },
-    ]
-    expect(extractText(content)).toBe('Hello\nWorld')
-  })
-
-  test('ignores non-text content blocks', () => {
-    const content: ContentBlock[] = [
-      { type: 'text', text: 'Hello' },
-      { type: 'image', data: 'base64', mimeType: 'image/png' },
-      { type: 'text', text: 'World' },
-    ]
-    expect(extractText(content)).toBe('Hello\nWorld')
-  })
-
-  test('returns empty string for no text blocks', () => {
-    const content: ContentBlock[] = [{ type: 'image', data: 'base64', mimeType: 'image/png' }]
-    expect(extractText(content)).toBe('')
-  })
-
-  test('handles empty array', () => {
-    expect(extractText([])).toBe('')
-  })
-})
-
-describe('extractTextFromUpdates', () => {
-  test('extracts text from agent message chunks', () => {
-    const notifications: SessionNotification[] = [
-      {
-        sessionId: 's1',
-        update: { sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: 'First' } },
-      },
-      {
-        sessionId: 's1',
-        update: { sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: 'Second' } },
-      },
-    ]
-    expect(extractTextFromUpdates(notifications)).toBe('FirstSecond')
-  })
-
-  test('skips non-text content updates', () => {
-    const notifications: SessionNotification[] = [
-      {
-        sessionId: 's1',
-        update: { sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: 'Hello' } },
-      },
-      {
-        sessionId: 's1',
-        update: { sessionUpdate: 'tool_call', toolCallId: 't1', title: 'read_file', status: 'pending' },
-      },
-      {
-        sessionId: 's1',
-        update: { sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: 'World' } },
-      },
-    ]
-    expect(extractTextFromUpdates(notifications)).toBe('HelloWorld')
-  })
-})
-
-describe('extractToolCalls', () => {
-  test('extracts all tool calls from notifications', () => {
-    const notifications: SessionNotification[] = [
-      {
-        sessionId: 's1',
-        update: { sessionUpdate: 'tool_call', toolCallId: 't1', title: 'read_file', status: 'completed' },
-      },
-      {
-        sessionId: 's1',
-        update: { sessionUpdate: 'tool_call', toolCallId: 't2', title: 'write_file', status: 'in_progress' },
-      },
-    ]
-    const calls = extractToolCalls(notifications)
-    expect(calls).toHaveLength(2)
-    expect(calls[0]?.title).toBe('read_file')
-    expect(calls[1]?.title).toBe('write_file')
-  })
-
-  test('returns empty array when no tool calls', () => {
-    const notifications: SessionNotification[] = [
-      {
-        sessionId: 's1',
-        update: { sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: 'Hello' } },
-      },
-    ]
-    expect(extractToolCalls(notifications)).toEqual([])
-  })
-})
-
-describe('extractLatestToolCalls', () => {
-  test('returns latest state of each tool call', () => {
-    const notifications: SessionNotification[] = [
-      {
-        sessionId: 's1',
-        update: { sessionUpdate: 'tool_call', toolCallId: 't1', title: 'read_file', status: 'pending' },
-      },
-      {
-        sessionId: 's1',
-        update: { sessionUpdate: 'tool_call', toolCallId: 't1', title: 'read_file', status: 'in_progress' },
-      },
-      {
-        sessionId: 's1',
-        update: { sessionUpdate: 'tool_call', toolCallId: 't1', title: 'read_file', status: 'completed' },
-      },
-    ]
-    const latest = extractLatestToolCalls(notifications)
-    expect(latest.size).toBe(1)
-    expect(latest.get('t1')?.status).toBe('completed')
-  })
-
-  test('tracks multiple tool calls independently', () => {
-    const notifications: SessionNotification[] = [
-      {
-        sessionId: 's1',
-        update: { sessionUpdate: 'tool_call', toolCallId: 't1', title: 'read_file', status: 'completed' },
-      },
-      {
-        sessionId: 's1',
-        update: { sessionUpdate: 'tool_call', toolCallId: 't2', title: 'write_file', status: 'in_progress' },
-      },
-    ]
-    const latest = extractLatestToolCalls(notifications)
-    expect(latest.size).toBe(2)
-    expect(latest.get('t1')?.status).toBe('completed')
-    expect(latest.get('t2')?.status).toBe('in_progress')
-  })
-})
-
-describe('extractPlan', () => {
-  test('returns latest plan from notifications', () => {
-    const notifications: SessionNotification[] = [
-      {
-        sessionId: 's1',
-        update: {
-          sessionUpdate: 'plan',
-          entries: [{ content: 'Step 1', status: 'pending', priority: 'medium' }],
-        },
-      },
-      {
-        sessionId: 's1',
-        update: {
-          sessionUpdate: 'plan',
-          entries: [
-            { content: 'Step 1', status: 'completed', priority: 'medium' },
-            { content: 'Step 2', status: 'in_progress', priority: 'medium' },
-          ],
-        },
-      },
-    ]
-    const plan = extractPlan(notifications)
-    expect(plan).toHaveLength(2)
-    expect(plan?.[0]?.status).toBe('completed')
-  })
-
-  test('returns undefined when no plan in updates', () => {
-    const notifications: SessionNotification[] = [
-      {
-        sessionId: 's1',
-        update: { sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: 'Hi' } },
-      },
-    ]
-    expect(extractPlan(notifications)).toBeUndefined()
-  })
-})
-
-// ============================================================================
-// Tool Call Utilities
-// ============================================================================
-
-describe('filterToolCallsByStatus', () => {
-  const toolCalls: ToolCall[] = [
-    { toolCallId: 't1', title: 'a', status: 'completed' },
-    { toolCallId: 't2', title: 'b', status: 'failed' },
-    { toolCallId: 't3', title: 'c', status: 'completed' },
-  ]
-
-  test('filters by completed status', () => {
-    const result = filterToolCallsByStatus(toolCalls, 'completed')
-    expect(result).toHaveLength(2)
-    expect(result.every((c) => c.status === 'completed')).toBe(true)
-  })
-
-  test('filters by failed status', () => {
-    const result = filterToolCallsByStatus(toolCalls, 'failed')
-    expect(result).toHaveLength(1)
-    expect(result[0]?.title).toBe('b')
-  })
-})
-
-describe('filterToolCallsByTitle', () => {
-  const toolCalls: ToolCall[] = [
-    { toolCallId: 't1', title: 'read_file', status: 'completed' },
-    { toolCallId: 't2', title: 'write_file', status: 'completed' },
-    { toolCallId: 't3', title: 'read_file', status: 'completed' },
-  ]
-
-  test('filters by tool title', () => {
-    const result = filterToolCallsByTitle(toolCalls, 'read_file')
-    expect(result).toHaveLength(2)
-  })
-})
-
-describe('hasToolCallErrors', () => {
-  test('returns true when failed tool calls exist', () => {
-    const toolCalls: ToolCall[] = [
-      { toolCallId: 't1', title: 'a', status: 'completed' },
-      { toolCallId: 't2', title: 'b', status: 'failed' },
-    ]
-    expect(hasToolCallErrors(toolCalls)).toBe(true)
-  })
-
-  test('returns false when no failed tool calls', () => {
-    const toolCalls: ToolCall[] = [
-      { toolCallId: 't1', title: 'a', status: 'completed' },
-      { toolCallId: 't2', title: 'b', status: 'completed' },
-    ]
-    expect(hasToolCallErrors(toolCalls)).toBe(false)
-  })
-})
-
-describe('getCompletedToolCallsWithContent', () => {
-  test('returns completed calls with content', () => {
-    const toolCalls: ToolCall[] = [
-      {
-        toolCallId: 't1',
-        title: 'read',
-        status: 'completed',
-        content: [{ type: 'content', content: { type: 'text', text: 'file content' } }],
-      },
-      { toolCallId: 't2', title: 'write', status: 'completed' },
-      { toolCallId: 't3', title: 'fetch', status: 'in_progress' },
-    ]
-    const result = getCompletedToolCallsWithContent(toolCalls)
-    expect(result).toHaveLength(1)
-    expect(result[0]?.title).toBe('read')
-  })
-})
-
-// ============================================================================
-// Plan Utilities
-// ============================================================================
-
-describe('filterPlanByStatus', () => {
-  const plan: PlanEntry[] = [
-    { content: 'Step 1', status: 'completed', priority: 'high' },
-    { content: 'Step 2', status: 'in_progress', priority: 'medium' },
-    { content: 'Step 3', status: 'pending', priority: 'low' },
-  ]
-
-  test('filters by status', () => {
-    expect(filterPlanByStatus(plan, 'completed')).toHaveLength(1)
-    expect(filterPlanByStatus(plan, 'pending')).toHaveLength(1)
-  })
-})
-
-describe('getPlanProgress', () => {
-  test('calculates completion percentage', () => {
-    const plan: PlanEntry[] = [
-      { content: 'Step 1', status: 'completed', priority: 'high' },
-      { content: 'Step 2', status: 'completed', priority: 'high' },
-      { content: 'Step 3', status: 'pending', priority: 'medium' },
-      { content: 'Step 4', status: 'pending', priority: 'low' },
-    ]
-    expect(getPlanProgress(plan)).toBe(50)
-  })
-
-  test('returns 100 for empty plan', () => {
-    expect(getPlanProgress([])).toBe(100)
-  })
-
-  test('returns 100 for all completed', () => {
-    const plan: PlanEntry[] = [
-      { content: 'Step 1', status: 'completed', priority: 'high' },
-      { content: 'Step 2', status: 'completed', priority: 'medium' },
-    ]
-    expect(getPlanProgress(plan)).toBe(100)
-  })
-})
diff --git a/src/tests/adapter-check.spec.ts b/src/tests/adapter-check.spec.ts
deleted file mode 100644
index fa0d558..0000000
--- a/src/tests/adapter-check.spec.ts
+++ /dev/null
@@ -1,70 +0,0 @@
-/**
- * Tests for adapter compliance checking functionality.
- */
-
-import { describe, expect, test } from 'bun:test'
-import { type CheckConfig, runCheck } from '../adapter-check.ts'
-
-describe('runCheck', () => {
-  test('fails spawn check for non-existent command', async () => {
-    const config: CheckConfig = {
-      command: ['nonexistent-command-xyz'],
-      timeout: 1000,
-      verbose: false,
-    }
-
-    const result = await runCheck(config)
-
-    expect(result.passed).toBe(false)
-    expect(result.checks.length).toBeGreaterThanOrEqual(1)
-    expect(result.checks[0]?.name).toBe('spawn')
-    expect(result.checks[0]?.passed).toBe(false)
-  })
-
-  test('fails spawn check for command that exits immediately', async () => {
-    const config: CheckConfig = {
-      command: ['false'], // Unix command that exits with code 1
-      timeout: 1000,
-      verbose: false,
-    }
-
-    const result = await runCheck(config)
-
-    expect(result.passed).toBe(false)
-    expect(result.summary.failed).toBeGreaterThanOrEqual(1)
-  })
-
-  test('returns structured result with summary', async () => {
-    const config: CheckConfig = {
-      command: ['echo', 'test'],
-      timeout: 1000,
-      verbose: false,
-    }
-
-    const result = await runCheck(config)
-
-    expect(result).toHaveProperty('passed')
-    expect(result).toHaveProperty('checks')
-    expect(result).toHaveProperty('summary')
-    expect(result.summary).toHaveProperty('total')
-    expect(result.summary).toHaveProperty('passed')
-    expect(result.summary).toHaveProperty('failed')
-    expect(typeof result.passed).toBe('boolean')
-    expect(Array.isArray(result.checks)).toBe(true)
-  })
-
-  test('includes verbose details when enabled', async () => {
-    const config: CheckConfig = {
-      command: ['echo', 'test'],
-      timeout: 1000,
-      verbose: true,
-    }
-
-    const result = await runCheck(config)
-
-    // At least the spawn check should have details in verbose mode
-    const spawnCheck = result.checks.find((c) => c.name === 'spawn')
-    expect(spawnCheck).toBeDefined()
-    // Note: details may or may not be present depending on check outcome
-  })
-})
diff --git a/src/tests/adapter-scaffold.spec.ts b/src/tests/adapter-scaffold.spec.ts
deleted file mode 100644
index 1a6f92e..0000000
--- a/src/tests/adapter-scaffold.spec.ts
+++ /dev/null
@@ -1,112 +0,0 @@
-/**
- * Tests for adapter scaffolding functionality.
- */
-
-import { afterEach, describe, expect, test } from 'bun:test'
-import { rm } from 'node:fs/promises'
-import { join } from 'node:path'
-import { runScaffold, type ScaffoldConfig } from '../adapter-scaffold.ts'
-
-const testDir = join(import.meta.dir, 'fixtures', 'scaffold-output')
-
-describe('runScaffold', () => {
-  afterEach(async () => {
-    // Clean up test output
-    await rm(testDir, { recursive: true, force: true })
-  })
-
-  test('generates TypeScript adapter structure', async () => {
-    const config: ScaffoldConfig = {
-      name: 'test-agent',
-      outputDir: testDir,
-      lang: 'ts',
-      minimal: false,
-    }
-
-    const result = await runScaffold(config)
-
-    expect(result.outputDir).toBe(testDir)
-    expect(result.lang).toBe('ts')
-    expect(result.files).toContain('package.json')
-    expect(result.files).toContain('tsconfig.json')
-    expect(result.files).toContain('src/main.ts')
-    expect(result.files).toContain('src/types.ts')
-    expect(result.files).toContain('src/session-manager.ts')
-    expect(result.files).toContain('src/handlers/initialize.ts')
-    expect(result.files).toContain('src/handlers/session-new.ts')
-    expect(result.files).toContain('src/handlers/session-prompt.ts')
-    expect(result.files).toContain('src/handlers/session-cancel.ts')
-    expect(result.files).toContain('README.md')
-
-    // Verify files actually exist
-    const packageJson = await Bun.file(join(testDir, 'package.json')).text()
-    expect(packageJson).toContain('"test-agent-acp"')
-
-    const mainTs = await Bun.file(join(testDir, 'src', 'main.ts')).text()
-    expect(mainTs).toContain('#!/usr/bin/env bun')
-    expect(mainTs).toContain('handleInitialize')
-  })
-
-  test('generates minimal TypeScript structure without README', async () => {
-    const config: ScaffoldConfig = {
-      name: 'minimal-agent',
-      outputDir: testDir,
-      lang: 'ts',
-      minimal: true,
-    }
-
-    const result = await runScaffold(config)
-
-    expect(result.files).not.toContain('README.md')
-    expect(result.files).toContain('package.json')
-    expect(result.files).toContain('src/main.ts')
-  })
-
-  test('generates Python adapter structure', async () => {
-    const config: ScaffoldConfig = {
-      name: 'python-agent',
-      outputDir: testDir,
-      lang: 'python',
-      minimal: false,
-    }
-
-    const result = await runScaffold(config)
-
-    expect(result.lang).toBe('python')
-    expect(result.files).toContain('adapter.py')
-    expect(result.files).toContain('README.md')
-
-    const adapterPy = await Bun.file(join(testDir, 'adapter.py')).text()
-    expect(adapterPy).toContain('#!/usr/bin/env python3')
-    expect(adapterPy).toContain('python-agent')
-    expect(adapterPy).toContain('def handle_initialize')
-  })
-
-  test('generates minimal Python structure without README', async () => {
-    const config: ScaffoldConfig = {
-      name: 'minimal-python',
-      outputDir: testDir,
-      lang: 'python',
-      minimal: true,
-    }
-
-    const result = await runScaffold(config)
-
-    expect(result.files).toContain('adapter.py')
-    expect(result.files).not.toContain('README.md')
-  })
-
-  test('package.json contains correct name', async () => {
-    const config: ScaffoldConfig = {
-      name: 'my-special-agent',
-      outputDir: testDir,
-      lang: 'ts',
-      minimal: true,
-    }
-
-    await runScaffold(config)
-
-    const packageJson = JSON.parse(await Bun.file(join(testDir, 'package.json')).text())
-    expect(packageJson.name).toBe('my-special-agent-acp')
-  })
-})
diff --git a/src/tests/fixtures/calculator-mcp.ts b/src/tests/fixtures/calculator-mcp.ts
deleted file mode 100644
index 54bce57..0000000
--- a/src/tests/fixtures/calculator-mcp.ts
+++ /dev/null
@@ -1,215 +0,0 @@
-#!/usr/bin/env bun
-/**
- * Simple calculator MCP server for testing.
- *
- * @remarks
- * A minimal stdio-based MCP server that provides add/subtract/multiply/divide tools.
- * Used to verify ACP client works with MCP servers.
- */
-
-type JsonRpcRequest = {
-  jsonrpc: '2.0'
-  id: string | number
-  method: string
-  params?: unknown
-}
-
-type JsonRpcResponse = {
-  jsonrpc: '2.0'
-  id: string | number
-  result?: unknown
-  error?: { code: number; message: string }
-}
-
-type Tool = {
-  name: string
-  description: string
-  inputSchema: {
-    type: 'object'
-    properties: Record<string, { type: string; description: string }>
-    required: string[]
-  }
-}
-
-const tools: Tool[] = [
-  {
-    name: 'add',
-    description: 'Add two numbers',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        a: { type: 'number', description: 'First number' },
-        b: { type: 'number', description: 'Second number' },
-      },
-      required: ['a', 'b'],
-    },
-  },
-  {
-    name: 'subtract',
-    description: 'Subtract two numbers',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        a: { type: 'number', description: 'First number' },
-        b: { type: 'number', description: 'Second number' },
-      },
-      required: ['a', 'b'],
-    },
-  },
-  {
-    name: 'multiply',
-    description: 'Multiply two numbers',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        a: { type: 'number', description: 'First number' },
-        b: { type: 'number', description: 'Second number' },
-      },
-      required: ['a', 'b'],
-    },
-  },
-  {
-    name: 'divide',
-    description: 'Divide two numbers',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        a: { type: 'number', description: 'Dividend' },
-        b: { type: 'number', description: 'Divisor' },
-      },
-      required: ['a', 'b'],
-    },
-  },
-]
-
-const handleRequest = (request: JsonRpcRequest): JsonRpcResponse => {
-  const { id, method, params } = request
-
-  if (method === 'initialize') {
-    return {
-      jsonrpc: '2.0',
-      id,
-      result: {
-        protocolVersion: '2024-11-05',
-        capabilities: { tools: {} },
-        serverInfo: { name: 'calculator-mcp', version: '1.0.0' },
-      },
-    }
-  }
-
-  if (method === 'tools/list') {
-    return { jsonrpc: '2.0', id, result: { tools } }
-  }
-
-  if (method === 'tools/call') {
-    const { name, arguments: args } = params as { name: string; arguments: { a: number; b: number } }
-    let result: number
-
-    switch (name) {
-      case 'add':
-        result = args.a + args.b
-        break
-      case 'subtract':
-        result = args.a - args.b
-        break
-      case 'multiply':
-        result = args.a * args.b
-        break
-      case 'divide':
-        if (args.b === 0) {
-          return {
-            jsonrpc: '2.0',
-            id,
-            error: { code: -32602, message: 'Division by zero' },
-          }
-        }
-        result = args.a / args.b
-        break
-      default:
-        return {
-          jsonrpc: '2.0',
-          id,
-          error: { code: -32601, message: `Unknown tool: ${name}` },
-        }
-    }
-
-    return {
-      jsonrpc: '2.0',
-      id,
-      result: { content: [{ type: 'text', text: String(result) }] },
-    }
-  }
-
-  return {
-    jsonrpc: '2.0',
-    id,
-    error: { code: -32601, message: `Unknown method: ${method}` },
-  }
-}
-
-// MCP stdio transport with Content-Length framing (like LSP)
-const decoder = new TextDecoder()
-const encoder = new TextEncoder()
-let buffer = ''
-
-/** Send a JSON-RPC response with Content-Length framing */
-const sendResponse = (response: JsonRpcResponse) => {
-  const json = JSON.stringify(response)
-  const message = `Content-Length: ${encoder.encode(json).length}\r\n\r\n${json}`
-  process.stdout.write(message)
-}
-
-/** Parse Content-Length header and extract message */
-const parseMessage = (): JsonRpcRequest | null => {
-  // Look for Content-Length header
-  const headerEnd = buffer.indexOf('\r\n\r\n')
-  if (headerEnd === -1) return null
-
-  const header = buffer.slice(0, headerEnd)
-  const match = header.match(/Content-Length:\s*(\d+)/i)
-  if (!match) {
-    // Invalid header, skip to next potential header
-    buffer = buffer.slice(headerEnd + 4)
-    return null
-  }
-
-  // match[1] is guaranteed to be the captured group from the regex
-  const contentLength = parseInt(match[1] as string, 10)
-  const messageStart = headerEnd + 4
-  const messageEnd = messageStart + contentLength
-
-  // Check if we have the full message
-  if (buffer.length < messageEnd) return null
-
-  const json = buffer.slice(messageStart, messageEnd)
-  buffer = buffer.slice(messageEnd)
-
-  try {
-    return JSON.parse(json) as JsonRpcRequest
-  } catch {
-    return null
-  }
-}
-
-// Read from stdin
-const stdin = Bun.stdin.stream()
-const reader = stdin.getReader()
-
-const read = async () => {
-  while (true) {
-    const { done, value } = await reader.read()
-    if (done) break
-
-    buffer += decoder.decode(value, { stream: true })
-
-    // Process all complete messages in buffer
-    let request = parseMessage()
-    while (request !== null) {
-      const response = handleRequest(request)
-      sendResponse(response)
-      request = parseMessage()
-    }
-  }
-}
-
-read()