feat: version display in TUI header + reasonix update self-upgrade (0.4.22)

Two small quality-of-life additions.

The stats panel now carries the running version (`Reasonix v0.4.22 ·
model …`) so users can tell at a glance whether they're on the latest
build. A 24-hour background check against the npm registry surfaces a
yellow `update: X.Y.Z` nudge on the right side of the same row when a
newer version has been published — 2s timeout, cache at
`~/.reasonix/version-cache.json`, silent on failure.

`reasonix update` is the command form: detects global install vs npx,
spawns `npm install -g reasonix@latest` for the former or prints a
cache-refresh hint for the latter. `--dry-run` prints the plan.

Also fixes a drifted VERSION constant: `src/index.ts` hard-coded
"0.4.20" while package.json was on 0.4.21. Now re-exports from
`src/version.ts`, which walks up from import.meta.url to the
manifest on first access. A regression test pins them together.

New files: `src/version.ts`, `src/cli/commands/update.ts`,
`tests/version.test.ts`, `tests/update-command.test.ts`. +24 tests
(suite 648 → 672). Lint/typecheck/build clean.

.github/workflows/ci.yml

@@ -37,3 +37,13 @@ jobs:
 
       - name: Build (tsup)
         run: npm run build
+
+      # Smoke-test the bench harnesses themselves. --dry skips all LLM
+      # calls, so this catches wiring regressions (task factories, CLI
+      # parsing, file IO, checker determinism) without needing a
+      # DEEPSEEK_API_KEY in CI.
+      - name: τ-bench harness dry-run
+        run: npx tsx benchmarks/tau-bench/runner.ts --dry --out /tmp/tau-dry.json
+
+      - name: Harvest-bench harness dry-run
+        run: npx tsx benchmarks/harvest/runner.ts --dry --out /tmp/harvest-dry.json

.gitignore

@@ -22,3 +22,5 @@ sessions/
 !benchmarks/tau-bench/transcripts/
 !benchmarks/tau-bench/transcripts/*.jsonl
 .turbo/
+# Local-only Claude Code settings — personal overrides, never committed.
+.claude/settings.local.json

README.md

@@ -6,147 +6,514 @@
 [![downloads](https://img.shields.io/npm/dm/reasonix.svg)](https://www.npmjs.com/package/reasonix)
 [![node](https://img.shields.io/node/v/reasonix.svg)](./package.json)
 
-**The DeepSeek-native agent framework.** TypeScript. Ink TUI. No LangChain.
-
-Reasonix is not another generic agent wrapper. Every abstraction is justified
-by a DeepSeek-specific property — dirt-cheap tokens, R1 reasoning traces,
-automatic prefix caching, JSON mode. Generic frameworks treat DeepSeek as
-"OpenAI with a different base URL" and leave these advantages on the table.
-Reasonix leans into them.
-
-```bash
-npx reasonix chat          # first run prompts for your DeepSeek key
-                           # inside the TUI, type /help for everything else
-```
-
-No flag soup. All feature toggles live behind slash commands in the TUI.
+**A DeepSeek-native AI coding agent in your terminal.** Edits files as
+reviewable SEARCH/REPLACE blocks. Ink TUI. MCP first-class. No
+LangChain.
 
 ---
 
-## What you get
+## Quick start (60 seconds)
 
-| Feature | How it works | Opt in |
-|---|---|---|
-| **Cache-First Loop** | Immutable prefix + append-only log = prefix byte-stable across turns → DeepSeek's automatic prefix cache hits at 70–95% | always on |
-| **R1 Thought Harvesting** | Parses `reasoning_content` into typed `{ subgoals, hypotheses, uncertainties, rejectedPaths }` via a cheap V3 call | `--harvest` |
-| **Self-Consistency Branching** | Runs N parallel samples at spread temperatures; picks the one with the fewest flagged uncertainties | `--branch <N>` |
-| **Tool-Call Repair** | Auto-flattens deep/wide schemas, scavenges tool calls leaked into `<think>`, repairs truncated JSON, breaks call-storms | always on |
-| **Retry layer** | Exponential backoff + jitter on 408/429/500/502/503/504 and network errors. 4xx auth errors don't retry | always on |
-| **Ink TUI** | Live cache-hit / cost panel. Streams R1 thinking to a compact preview. Renders Markdown (bold / lists / code / stripped LaTeX) | always on |
+**1. Get a DeepSeek API key.** Free credit on signup:
+<https://platform.deepseek.com/api_keys>
+
+**2. Point it at a project.** No install needed.
+
+```bash
+cd my-project
+npx reasonix code
+```
+
+First run walks you through a 30-second wizard (paste API key → pick
+preset → multi-select MCP servers). Every run after that drops you
+straight in.
+
+**3. Ask it to edit.** The model proposes edits as SEARCH/REPLACE
+blocks — nothing hits disk until you `/apply`.
+
+```
+reasonix code › users.ts 里 findByEmail 对大小写敏感导致登录失败，帮我改
+
+assistant
+  ▸ tool<search_files> → src/users.ts, src/users.test.ts
+  ▸ tool<read_file>    → (src/users.ts, 412 chars)
+  ▸ 找到了。findByEmail 直接用 === 比对。改成小写规范化并补一条测试。
+
+src/users.ts
+<<<<<<< SEARCH
+  return users.find(u => u.email === email);
+=======
+  const needle = email.toLowerCase();
+  return users.find(u => u.email.toLowerCase() === needle);
+>>>>>>> REPLACE
+
+▸ 1 pending edit across 1 file — /apply to write · /discard to drop
+
+reasonix code › /apply
+▸ ✓ applied src/users.ts
+```
+
+Requires Node ≥ 20.10. macOS, Linux, Windows (PowerShell / Git Bash /
+Windows Terminal). Press `Esc` anytime to abort; `/help` for the full
+command list.
 
 ---
 
-## Why not just use LangChain?
+## `reasonix code` — pair programmer in your terminal
 
-Even on the default `fast` preset (no harvest, no branching), Reasonix bakes
-in five DeepSeek-specific defences that generic agent frameworks leave to you:
+Scoped to the directory you launch from. The model has native
+`read_file` / `write_file` / `edit_file` / `list_directory` /
+`search_files` / `directory_tree` / `get_file_info` /
+`create_directory` / `move_file` tools, all sandboxed — any path that
+resolves outside the launch root (including `..` and symlink escapes)
+is refused. Plus `run_command` with a read-only allowlist; anything
+state-mutating (`npm install`, `git commit`, …) is gated behind a
+confirmation picker.
 
-| | Reasonix default | generic frameworks |
-|---|---|---|
-| Prefix-stable loop (→ 85–95% cache hit) | ✅ | ❌ prompts rebuilt each turn |
-| Auto-flatten deep tool schemas | ✅ | ❌ DeepSeek drops args |
-| Retry with jittered backoff (429/503) | ✅ | ❌ custom callbacks |
-| Scavenge tool calls leaked into `<think>` | ✅ | ❌ |
-| Call-storm breaker on identical-arg repeats | ✅ | ❌ |
-| Live cache-hit / cost / vs-Claude panel | ✅ | ❌ |
-| First-run config prompt + Markdown TUI | ✅ | ❌ |
+### Walkthrough: explore before editing
 
-Harvest and self-consistency branching are bonuses on top. The everyday
-win is that **a plain chat with Reasonix already pays for ~40% less tokens
-than the same chat through a naive LangChain setup**, because the prefix
-actually stays byte-stable.
+For "what does this code do?" questions the model uses the read-side
+tools and replies in prose — no SEARCH/REPLACE blocks, no file
+writes. Ask to change something only when you mean it:
 
-## Validated numbers
-
-**τ-bench-lite** — 8 multi-turn tool-use tasks × 3 repeats = 48 runs per
-side. Same tools / same prompt / same client on both sides, sole variable
-is prefix stability. Measured on live DeepSeek `deepseek-chat`:
-
-| metric | baseline (cache-hostile) | Reasonix | delta |
-|---|---:|---:|---:|
-| runs | 24 | 24 | — |
-| **cache hit** | 46.6% | **94.4%** | **+47.7pp** |
-| cost / task | $0.002599 | $0.001579 | **−39% (×0.61)** |
-| vs Claude Sonnet 4.6 (token-count estimate) | — | — | **~96% cheaper** |
-| pass rate | 96% (23/24) | **100% (24/24)** | Reasonix held the guardrail on every run |
-
-**Verify it yourself — no API key, zero cost:**
-
-```bash
-git clone https://github.com/esengine/reasonix.git && cd reasonix && npm install
-npx reasonix replay benchmarks/tau-bench/transcripts/t01_address_happy.reasonix.r1.jsonl
-npx reasonix diff \
-  benchmarks/tau-bench/transcripts/t01_address_happy.baseline.r1.jsonl \
-  benchmarks/tau-bench/transcripts/t01_address_happy.reasonix.r1.jsonl
+```
+reasonix code › 这个项目的路由是怎么组织的？
+assistant
+  ▸ tool<directory_tree> → (src/ tree, 47 entries)
+  ▸ tool<read_file> → (src/router.ts, 1.2 KB)
+  ▸ 路由分三层：顶层 AppRouter 注册 tab，每个 tab 用 React Router 的
+    nested routes 写子路径，最后 …
 ```
 
-The JSONL transcripts committed in `benchmarks/tau-bench/transcripts/`
-carry per-turn `usage`, `cost`, and `prefixHash`. Reasonix's prefix hash
-stays byte-stable across every model call; baseline's prefix churns on
-every turn. The cache delta is *mechanically* attributable to log
-stability, not to a different system prompt.
+If an `edit_file` SEARCH block doesn't match the file byte-for-byte,
+the edit is refused loudly rather than fuzzy-matched. The model sees
+the error and retries — silent wrong edits are worse than visible
+rejections.
 
-Full 48-run report: [`benchmarks/tau-bench/report.md`][r]. Reproduce
-with your own API key: `npx tsx benchmarks/tau-bench/runner.ts --repeats 3`.
+### Plan mode — review before executing
 
-[r]: ./benchmarks/tau-bench/report.md
+For anything bigger than a typo, the model is encouraged to propose a
+markdown plan first. You'll see a picker with **Approve / Refine /
+Cancel**:
+
+```
+reasonix code › 把 auth 从 JWT 迁移到 session cookies
+
+▸ plan submitted — awaiting your review
+────────────────────────────────────────
+## Summary
+Swap JWT middleware for session cookies, keep user table intact.
+
+## Files
+- src/auth/middleware.ts — replace `verifyJwt` with `readSession`
+- src/auth/session.ts — new file, in-memory store + signed cookie
+- src/routes/login.ts — return Set-Cookie instead of a token
+- tests/auth/*.test.ts — update fixtures
+
+## Risks
+- Existing logged-in users get logged out (no migration).
+- Session store is in-memory; restart clears sessions.
+────────────────────────────────────────
+  ▸ Approve and implement
+    Refine — explore more
+    Cancel
+```
+
+**Force it** with `/plan` — enters an explicit read-only phase where
+the model *must* submit a plan before any edit or non-allowlisted
+shell call will execute. Use for high-stakes changes you want to
+audit before the model touches disk. `/plan off` or picker
+Approve/Cancel exits.
+
+### `/commit` — stage + commit in one step
+
+```
+reasonix code › /commit "fix: findByEmail case-insensitive"
+▸ git add -A && git commit -m "fix: findByEmail case-insensitive"
+  [main a1b2c3d] fix: findByEmail case-insensitive
+```
+
+### Things to try
+
+- `/tool 1` — dump the last tool call's full output (when the 400-char
+  inline clip isn't enough).
+- `/think` — see the model's full R1 reasoning for the last turn
+  (reasoner preset only).
+- `/undo` — roll back the last applied edit batch.
+- `/new` — start fresh in the same directory without losing the
+  session file.
+- `npx reasonix code --preset max` — R1 + 3-way self-consistency
+  branching for gnarly refactors.
+- `npx reasonix code src/` — narrower sandbox (only `src/` is
+  writable).
+- `npx reasonix code --no-session` — ephemeral; nothing saved.
+
+### Staying current
+
+The panel header shows the running version next to `Reasonix` (e.g.
+`Reasonix v0.4.22 · model …`). A quiet 24-hour background check against
+the npm registry surfaces a yellow `update: X.Y.Z` on the right side
+of the same row when a newer version has been published. No blocking,
+no nagging — the check runs once per day max and is silent on failure
+(offline, firewall, etc.).
+
+```bash
+reasonix update             # print current vs latest, run `npm i -g reasonix@latest`
+reasonix update --dry-run   # print the plan without running anything
+```
+
+Running via `npx`? The command detects that and prints a
+cache-refresh hint instead — npx picks up the newest version on
+its next invocation automatically.
+
+### Project conventions — `REASONIX.md`
+
+Drop a `REASONIX.md` in the project root and its contents are pinned
+into the system prompt every launch. Committable team memory — house
+conventions, domain glossary, things the model keeps forgetting:
+
+```bash
+cat > REASONIX.md <<'EOF'
+# Notes for Reasonix
+- Use snake_case for new Python modules; legacy camelCase modules keep their style.
+- `cargo check` is in the auto-run allowlist; full `cargo test` needs confirmation.
+- The `api/` dir mirrors `backend/` — keep schemas in sync.
+EOF
+```
+
+Re-launch (or `/new`) to pick it up; the prefix is hashed once per
+session to keep the DeepSeek cache warm. `/memory` prints what's
+currently pinned. `REASONIX_MEMORY=off` disables every memory source
+for CI / offline repro.
+
+### User memory — `~/.reasonix/memory/`
+
+A second, **private per-user** memory layer lives under your home
+directory. Unlike `REASONIX.md` it's never committed, and the model
+can write to it itself via the `remember` tool. Two scopes:
+
+- `~/.reasonix/memory/global/` — cross-project (your preferences,
+  tooling).
+- `~/.reasonix/memory/<project-hash>/` — scoped to one sandbox root
+  in `reasonix code` (decisions, local facts, per-repo shortcuts).
+
+Each scope keeps an always-loaded `MEMORY.md` index of one-liners
+plus zero or more `<name>.md` detail files (loaded on demand via
+`recall_memory`). Writes land immediately; pinning into the system
+prompt takes effect on next `/new` or launch so the cache prefix
+stays stable for the current session.
+
+```
+reasonix code › 我用 bun 而不是 npm，请以后都用 bun 跑构建
+
+assistant
+  ▸ tool<remember> → project/bun_build saved
+    "Build command on this machine is `bun run build`"
+```
+
+**Slash**: `/memory` · `/memory list` · `/memory show <name>` ·
+`/memory forget <name>` · `/memory clear <scope> confirm`.
+**Model tools**: `remember(type, scope, name, description, content)` ·
+`forget(scope, name)` · `recall_memory(scope, name)`.
+
+Project scope is only available inside `reasonix code` (needs a real
+sandbox root to hash); plain `reasonix` gets the global scope only.
+
+### Skills — user-authored prompt packs
+
+Skills are prose instruction blocks you drop on disk. Reasonix pins
+their names + one-line descriptions into the system prompt; the
+model can call `run_skill({name: "..."})` on its own when a match
+fits, or you can type `/skill <name> [args]` to run one manually.
+
+Two scopes, same layout as user memory:
+
+- `<project>/.reasonix/skills/` — per-project skills (commit them to
+  share with your team, or add to `.gitignore` for personal drafts).
+- `~/.reasonix/skills/` — global skills available everywhere.
+
+Either layout works: `<name>/SKILL.md` (preferred — can bundle
+additional assets alongside) or flat `<name>.md`.
+
+```markdown
+---
+name: review
+description: Review uncommitted changes and flag risks
+---
+
+Run `git diff` on staged and unstaged changes. Summarize what each
+hunk does, call out potential regressions, and list files that might
+need additional tests. Don't propose edits unless I ask.
+```
+
+Use it:
+
+```
+reasonix code › /skill review
+▸ running skill: review
+assistant
+  ▸ tool<run_command> → git diff --cached
+  ▸ 3 改动，1 个需要回归测试 …
+```
+
+Or let the model pick autonomously — because the skill's name +
+description are pinned in the prefix, asking "帮我看下未提交的改动有没
+有风险" triggers `run_skill({name: "review"})` without you typing the
+slash command.
+
+**Slash**: `/skill` (list) · `/skill show <name>` · `/skill <name>
+[args]` (inject body as user turn).
+
+**Deliberately not tied** to any other client's directory convention
+(`.claude/skills`, etc.) — Reasonix is model-agnostic at the
+conversation layer. Any SKILL.md you author works; the body is
+prose, so skills authored for other tools usually port over unchanged
+(Reasonix's tool names differ — `filesystem` / `shell` / `web` — but
+the model reads the instructions and picks our equivalents).
 
 ---
 
-## Usage
+## `reasonix` — also works as general chat
 
-### CLI
+Same TUI, no filesystem tools unless you opt in via MCP. Good for
+drafting, Q&A, schema design, architecture discussions, or driving
+your own MCP servers. Sessions persist per name under
+`~/.reasonix/sessions/`.
 
 ```bash
-npx reasonix chat                # auto-saves to session 'default'; resumes next time
-npx reasonix chat --session work # use a different named session
-npx reasonix chat --no-session   # ephemeral — nothing persisted
-npx reasonix run "ask anything"  # one-shot, streams to stdout
-npx reasonix stats session.jsonl # quick summary of a transcript
-npx reasonix replay chat.jsonl   # pretty-print a transcript + rebuild cost/cache offline
-npx reasonix diff a.jsonl b.jsonl --md diff.md   # compare two transcripts: cache/cost delta + first divergence
+npx reasonix                             # uses saved config + wizard-selected MCP
+npx reasonix --preset smart              # reasoner + R1 harvest for this run
+npx reasonix --session design            # named session — resume later with --session design
 ```
 
-Sessions live as JSONL under `~/.reasonix/sessions/<name>.jsonl` — every
-turn's message log is appended atomically, so killing the CLI never loses
-context. Inside the TUI: `/sessions` to list, `/forget` to delete the
-current one.
-
-### Inside the chat — slash commands
-
-A command strip runs under the input box so you don't have to memorize
-anything. Type `/help` for the full list. The biggest shortcut:
-
-```
-/preset fast     deepseek-chat, no harvest, no branch        (default)
-/preset smart    reasoner + harvest                           (~10x cost)
-/preset max      reasoner + harvest + branch 3                (~30x cost, slowest)
-```
-
-One-tap switch between fast daily driver, careful thinker, and max-quality
-self-consistency. Individual knobs are available too:
-
-```
-/status          show current model / harvest / branch / stream
-/model <id>      deepseek-chat or deepseek-reasoner
-/harvest [on|off] Pillar 2 — parse R1 reasoning into typed plan state
-/branch <N|off>  run N parallel samples per turn, pick most confident
-/clear           clear displayed history (log is kept)
-/exit            quit
-```
-
-The top panel shows active flags live: `· harvest · branch3` appear next to
-the model once enabled.
-
-### Flags (for automation / CI)
-
-The same knobs are also available as CLI flags if you're scripting:
+Bridge your own MCP servers on the fly:
 
 ```bash
-npx reasonix chat -m deepseek-reasoner --harvest --branch 3 --transcript session.jsonl
+npx reasonix \
+  --mcp "fs=npx -y @modelcontextprotocol/server-filesystem /tmp/safe" \
+  --mcp "kb=https://mcp.example.com/sse"
 ```
 
-### Library
+MCP tools go through the same Cache-First + repair + context-safety
+plumbing as native tools — 32k result cap, live progress-notification
+rendering, retries.
+
+---
+
+## Commands inside the session
+
+**Core**
+
+| command | what it does |
+|---|---|
+| `/help` · `/?` | full command reference with hints |
+| `/status` | current model · flags · context · session |
+| `/new` · `/reset` | fresh conversation in the same session |
+| `/clear` | clear visible scrollback only (log kept) |
+| `/retry` | truncate and resend your last message (fresh sample) |
+| `/exit` · `/quit` | quit |
+
+**Model**
+
+| command | what it does |
+|---|---|
+| `/preset <fast\|smart\|max>` | one-tap bundle (model + harvest + branch) |
+| `/model <id>` | switch DeepSeek model (`deepseek-chat`, `deepseek-reasoner`) |
+| `/harvest [on\|off]` | toggle R1 plan-state extraction |
+| `/branch <N\|off>` | run N parallel samples per turn, pick best (N ≥ 2) |
+| `/think` | dump the last turn's full R1 reasoning |
+
+**Context & tools**
+
+| command | what it does |
+|---|---|
+| `/mcp` | list attached MCP servers and their tools |
+| `/tool [N]` | dump the Nth tool call's full output (1 = latest) |
+| `/compact [cap]` | shrink oversized tool results in the log |
+
+**Memory & skills**
+
+| command | what it does |
+|---|---|
+| `/memory` | show pinned memory (REASONIX.md + ~/.reasonix/memory) |
+| `/memory list` · `show <name>` · `forget <name>` · `clear <scope> confirm` | manage the store |
+| `/skill` · `/skill list` | list discovered skills (project + global) |
+| `/skill show <name>` | dump one skill's body |
+| `/skill <name> [args]` | run a skill (inject body as user turn) |
+
+**Sessions**
+
+| command | what it does |
+|---|---|
+| `/sessions` | list saved sessions (current marked with `▸`) |
+| `/forget` | delete the current session from disk |
+| `/setup` | reconfigure (exit and run `reasonix setup`) |
+
+**Code mode only** (`reasonix code`)
+
+| command | what it does |
+|---|---|
+| `/apply` | commit the pending SEARCH/REPLACE blocks to disk |
+| `/discard` | drop the pending edit blocks without writing |
+| `/undo` | roll back the last applied edit batch |
+| `/commit "msg"` | `git add -A && git commit -m "msg"` |
+| `/plan [on\|off]` | toggle read-only plan mode |
+| `/apply-plan` | force-approve a pending plan |
+
+**Keyboard**
+
+- `Enter` — submit
+- `Shift+Enter` / `Ctrl+J` — newline (multi-line paste also supported;
+  `\` + Enter as a portable fallback)
+- `↑` / `↓` — walk prompt history while idle; navigate slash-autocomplete
+- `Tab` / `Enter` on a `/foo` prefix — accept the highlighted suggestion
+- `Esc` — abort the current turn (stops the API call, cancels any
+  in-flight tool, rejects pending MCP requests)
+- `y` / `n` on confirm prompts — hotkey accept / reject
+
+---
+
+## Sessions and safety nets
+
+- Sessions live as JSONL under `~/.reasonix/sessions/<name>.jsonl`
+  (per directory for `reasonix code`). Every message appended
+  atomically; `Ctrl+C` never loses context.
+- Tool results are capped at 32k chars per call. Oversized sessions
+  self-heal on load (shrinks + rewrites the file).
+- Malformed `assistant.tool_calls` / `tool` pairing is validated on
+  every outgoing API call so a corrupted session can't keep 400ing.
+- Context gauge turns yellow at 50%, red at 80% with a `/compact`
+  nudge. Approaching the 131k window triggers an automatic
+  compaction attempt before falling back to a forced summary.
+- The `reasonix code` sandbox refuses any path that resolves outside
+  the launch directory, including symlink escape and `..` traversal.
+
+### Troubleshooting: duplicate rows / ghost rendering
+
+Some Windows terminals (Git Bash / MINTTY / winpty-wrapped shells)
+don't fully implement the ANSI cursor-up escapes Ink uses to repaint
+the live spinner region. Symptom: spinners, streaming previews, or
+tool-result rows print multiple copies into scrollback instead of
+overwriting in place.
+
+If you hit this, run with plain mode:
+
+```bash
+REASONIX_UI=plain npx reasonix code
+```
+
+Plain mode suppresses live/animated rows and disables the internal
+tick timer. You lose the streaming preview and spinners but gain
+stable scrollback. Windows Terminal, PowerShell 7 in Windows
+Terminal, and WezTerm don't need this opt-out.
+
+---
+
+## Web search — on by default
+
+The model has two web tools the moment you launch: `web_search` and
+`web_fetch`. No flag, no API key, no signup. When you ask about
+something the model wasn't trained on (new releases, current events,
+obscure APIs), it decides to call `web_search` on its own; if a
+snippet isn't enough it follows up with `web_fetch`.
+
+Backed by **Mojeek**'s public search page — an independent web
+index, bot-friendly, no cookies/sessions. Coverage on niche or very
+recent queries can be thinner than Google/Bing, but it's reliable
+from scripts. (DDG was the original backend but started serving
+anti-bot pages in 2026.)
+
+**Turn it off** (offline mode / privacy / CI):
+
+```json
+// ~/.reasonix/config.json
+{ "apiKey": "sk-…", "search": false }
+```
+
+```bash
+REASONIX_SEARCH=off npx reasonix code
+```
+
+**Bring your own** (Kagi, SearXNG, internal caches): implement the
+`WebSearchProvider` interface and call
+`registerWebTools(registry, { provider })` yourself, or bridge an
+existing MCP search server via `--mcp`.
+
+---
+
+## MCP — bring your own tools
+
+Any [MCP](https://spec.modelcontextprotocol.io/) server works. The
+wizard lets you pick from a catalog, or drive it by flag:
+
+```bash
+# stdio (local subprocess)
+npx reasonix --mcp "fs=npx -y @modelcontextprotocol/server-filesystem /tmp/safe"
+
+# multiple at once
+npx reasonix \
+  --mcp "fs=npx -y @modelcontextprotocol/server-filesystem /tmp/safe" \
+  --mcp "demo=npx tsx examples/mcp-server-demo.ts"
+
+# HTTP+SSE (remote / hosted)
+npx reasonix --mcp "kb=https://mcp.example.com/sse"
+```
+
+`reasonix mcp list` shows the curated catalog. `reasonix mcp inspect
+<spec>` connects once and dumps the server's tools / resources /
+prompts without starting a chat. Progress notifications from
+long-running tools (2025-03-26 spec) render live as a progress bar
+in the spinner.
+
+Supported transports: **stdio** (local command) and **HTTP+SSE**
+(remote, MCP 2024-11-05 spec).
+
+---
+
+## CLI reference
+
+```bash
+npx reasonix code [path]                 # coding mode scoped to path (default: cwd)
+npx reasonix                             # chat (uses saved config)
+npx reasonix setup                       # reconfigure the wizard
+npx reasonix chat --session work         # named session
+npx reasonix chat --no-session           # ephemeral
+npx reasonix run "ask anything"          # one-shot, streams to stdout
+npx reasonix stats session.jsonl         # summarize a transcript
+npx reasonix replay chat.jsonl           # rebuild cost/cache from a transcript
+npx reasonix diff a.jsonl b.jsonl --md   # compare two transcripts
+npx reasonix mcp list                    # curated MCP catalog
+npx reasonix mcp inspect <spec>          # probe a single MCP server
+npx reasonix sessions                    # list saved sessions
+```
+
+Common flags:
+
+```bash
+--preset <fast|smart|max>   # bundle (model + harvest + branch)
+--model <id>                # explicit model id
+--harvest / --no-harvest    # R1 plan-state extraction
+--branch <N>                # self-consistency budget
+--mcp "name=cmd args…"      # attach an MCP server (repeatable)
+--transcript path.jsonl     # write a JSONL transcript on the side
+--session <name>            # named session (default: per-dir for code mode)
+--no-session                # ephemeral
+--no-config                 # ignore ~/.reasonix/config.json (CI-friendly)
+```
+
+Env vars (win over config):
+
+```bash
+export DEEPSEEK_API_KEY=sk-...
+export DEEPSEEK_BASE_URL=https://...   # optional alternate endpoint
+export REASONIX_MEMORY=off              # disable REASONIX.md + user memory
+export REASONIX_SEARCH=off              # disable web_search / web_fetch
+export REASONIX_UI=plain                # disable live rows (ghosting workaround)
+```
+
+---
+
+## Library usage
 
 ```ts
 import {
@@ -178,7 +545,7 @@ const loop = new CacheFirstLoop({
     toolSpecs: tools.specs(),
   }),
   harvest: true,
-  branch: 3, // self-consistency budget
+  branch: 3,
 });
 
 for await (const ev of loop.step("What is 17 + 25?")) {
@@ -187,26 +554,82 @@ for await (const ev of loop.step("What is 17 + 25?")) {
 console.log(loop.stats.summary());
 ```
 
-### Configuration
+`ChatOptions.seedTools` accepts a pre-built `ToolRegistry` for
+callers who want the `reasonix code` loop wiring without the CLI
+wrapper. See [docs/ARCHITECTURE.md](docs/ARCHITECTURE.md) for
+internals.
 
-On first run the CLI prompts for your DeepSeek API key and saves it to
-`~/.reasonix/config.json`. Alternatives:
+---
+
+## Benchmarks — verify the cache-hit claim yourself
+
+Every abstraction here earns its weight against a DeepSeek-specific
+property — dirt-cheap tokens, R1 reasoning traces, automatic prefix
+caching, JSON mode. Generic wrappers leave these on the table.
+
+| | Reasonix default | generic frameworks |
+|---|---|---|
+| Prefix-stable loop (→ 85–95% cache hit) | yes | no (prompts rebuilt each turn) |
+| Auto-flatten deep tool schemas | yes | no (DeepSeek drops args) |
+| Retry with jittered backoff (429/503) | yes | no (custom callbacks) |
+| Scavenge tool calls leaked into `<think>` | yes | no |
+| Call-storm breaker on identical-arg repeats | yes | no |
+| Live cache-hit / cost / vs-Claude panel | yes | no |
+
+On the same τ-bench-lite workload — 8 multi-turn tool-use tasks × 3
+repeats = 48 runs per side, live DeepSeek `deepseek-chat`, sole
+variable prefix stability:
+
+| metric | baseline (cache-hostile) | Reasonix | delta |
+|---|---:|---:|---:|
+| cache hit | 46.6% | **94.4%** | +47.7 pp |
+| cost / task | $0.002599 | $0.001579 | **−39%** |
+| pass rate | 96% (23/24) | **100% (24/24)** | — |
+
+**Reproduce without spending an API credit:**
 
 ```bash
-export DEEPSEEK_API_KEY=sk-...        # env var (wins over config file)
-export DEEPSEEK_BASE_URL=https://...  # optional alternate endpoint
+git clone https://github.com/esengine/reasonix.git && cd reasonix && npm install
+npx reasonix replay benchmarks/tau-bench/transcripts/t01_address_happy.reasonix.r1.jsonl
+npx reasonix diff \
+  benchmarks/tau-bench/transcripts/t01_address_happy.baseline.r1.jsonl \
+  benchmarks/tau-bench/transcripts/t01_address_happy.reasonix.r1.jsonl
 ```
 
-Get a key (free credit on signup): <https://platform.deepseek.com/api_keys>
+The committed JSONL transcripts carry per-turn `usage`, `cost`, and
+`prefixHash`. Reasonix's prefix hash stays byte-stable across every
+model call; baseline's churns on every turn. The cache delta is
+*mechanically* attributable to log stability, not to a different
+system prompt.
+
+Full 48-run report:
+[`benchmarks/tau-bench/report.md`](./benchmarks/tau-bench/report.md).
+Reproduce with your own API key: `npx tsx
+benchmarks/tau-bench/runner.ts --repeats 3`.
+
+MCP reference runs (one single prefix hash across all 5 turns even
+with two concurrent MCP subprocesses):
+
+| server | turns | cache hit | cost | vs Claude |
+|---|---:|---:|---:|---:|
+| bundled demo (`add` / `echo` / `get_time`) | 2 | **96.6%** (turn 2) | $0.000254 | −94.0% |
+| official `server-filesystem` | 5 | **96.7%** | $0.001235 | −97.0% |
+| **both concurrently** | 5 | **81.1%** | $0.001852 | −95.9% |
 
 ---
 
 ## Non-goals
 
-- Multi-agent orchestration (use LangGraph).
-- RAG / vector stores (use LlamaIndex or do it yourself).
-- Multi-provider abstraction (use LiteLLM).
-- Web UI / SaaS.
+- **Multi-agent orchestration / sub-agents** (use LangGraph).
+- **Workflow DSL / DAG scheduler / parallel-branch engine** — skills
+  are prose; the model sequences via the normal tool-use loop.
+  Keeps single-loop + append-only + cache-first invariants intact.
+- **Multi-provider abstraction** (use LiteLLM). Reasonix is
+  DeepSeek-only on purpose — every pillar (cache-first loop, R1
+  harvesting, tool-call repair) is tuned against DeepSeek-specific
+  behavior and economics. Coupling to one backend is the feature.
+- **RAG / vector stores** (use LlamaIndex).
+- **Web UI / SaaS.**
 
 Reasonix does DeepSeek, deeply.
 
@@ -218,15 +641,13 @@ Reasonix does DeepSeek, deeply.
 git clone https://github.com/esengine/reasonix.git
 cd reasonix
 npm install
-npm run dev chat        # run CLI from source via tsx
+npm run dev code        # run CLI from source via tsx
 npm run build           # tsup to dist/
-npm test                # vitest (89 tests)
+npm test                # vitest (648 tests)
 npm run lint            # biome
 npm run typecheck       # tsc --noEmit
 ```
 
-See [docs/ARCHITECTURE.md](docs/ARCHITECTURE.md) for internals.
-
 ---
 
 ## License

benchmarks/harvest/README.md

@@ -0,0 +1,106 @@
+# Harvest eval harness (Pillar 2)
+
+Measures Pillar 2 (R1 Thought Harvesting) the same way `tau-bench/`
+measures Pillar 1 (Cache-First Loop): isolate one variable, produce
+numbers anyone can reproduce.
+
+## What's different from τ-bench-lite?
+
+Deliberately different task shape:
+
+| | τ-bench-lite | harvest-bench |
+|---|---|---|
+| task style | multi-turn tool-use | single-turn reasoning |
+| user simulator | yes (LLM) | no |
+| DB state | yes | no |
+| checker | DB-predicate | regex + set/value compare |
+| target | Pillar 1 | Pillar 2 |
+| model | deepseek-chat (default) | deepseek-reasoner (only R1 has `reasoning_content` for harvest to work on) |
+
+The two harnesses answer different questions:
+
+- **τ-bench-lite**: *"Does Cache-First actually cut cost on real tool-use
+  workflows?"* (yes — 47.7pp cache, −39% cost on 48-run data.)
+- **harvest-bench**: *"Does the extra V3 harvest call add measurable
+  value above plain R1?"* (TBD — run it to find out.)
+
+## Modes
+
+Three modes isolate one variable each:
+
+| mode | model | harvest | what it measures |
+|---|---|---|---|
+| `baseline` | deepseek-chat | off | floor reference — V3 at its best |
+| `reasoner` | deepseek-reasoner | off | raw R1 gain over V3 on reasoning |
+| `reasoner-harvest` | deepseek-reasoner | on | R1 + the extra V3 harvest call |
+
+Deltas:
+
+- `baseline → reasoner` answers "is R1 worth the price on these
+  problems?"
+- `reasoner → reasoner-harvest` answers "is the harvest call worth
+  its incremental cost?"
+
+## Quickstart
+
+```bash
+# Dry-run — no API, smoke-test the wiring
+npx tsx benchmarks/harvest/runner.ts --dry
+
+# Full run (live DeepSeek, costs ~$0.20-0.60 for 6 tasks × 3 modes × 1 repeat)
+export DEEPSEEK_API_KEY=sk-...
+npx tsx benchmarks/harvest/runner.ts
+
+# Tighter run with 3 repeats (~$0.60-2.00)
+npx tsx benchmarks/harvest/runner.ts --repeats 3
+
+# Only the hard tasks (skip the easy floor)
+npx tsx benchmarks/harvest/runner.ts --task pseudoprime_base2
+npx tsx benchmarks/harvest/runner.ts --task derangements_d7
+npx tsx benchmarks/harvest/runner.ts --task euler_quadratic_break
+
+# Bump per-call timeout (reasoner + harvest occasionally blow past the 120s default)
+npx tsx benchmarks/harvest/runner.ts --timeout 600
+
+# Per-run transcripts so you can reasonix replay / diff them
+npx tsx benchmarks/harvest/runner.ts --repeats 3 --transcripts-dir transcripts/
+
+# Render report
+npx tsx benchmarks/harvest/report.ts benchmarks/harvest/results-*.json
+```
+
+## Tasks (v0.3 seed)
+
+Split into two bands:
+
+**Easy band** — V3 chat solves these, so baseline has a real pass rate and the bench has a reference floor.
+
+| id | shape | why |
+|---|---|---|
+| `mod7_list` | number theory, 29-element list | R1 often tries enumeration first, then reaches for modular arithmetic — clean rejectedPaths signal |
+| `flips_until_3heads` | probability, single integer | classic recurrence; R1 either derives or recalls, harvest should see hypotheses diverge |
+| `three_hats` | logic puzzle, one-word answer | pure deduction chain, tests harvest's ability to extract the nested reasoning |
+
+**Hard band** — picked specifically for known V3 failure modes. If R1 systematically beats V3 on these, and harvest further beats R1-only, we have our Pillar 2 story.
+
+| id | shape | why V3 tends to fail |
+|---|---|---|
+| `pseudoprime_base2` | smallest Fermat pseudoprime to base 2 = **341** | V3 often answers 561 (Carmichael) or some other composite it remembers — R1 actually checks 2^n mod n |
+| `derangements_d7` | D_7 = **1854** | V3 approximates via n!/e and rounds wrong, or recalls D_6/D_8; R1 uses the recurrence D_n=(n−1)(D_{n−1}+D_{n−2}) |
+| `euler_quadratic_break` | smallest n where n²+n+41 is composite = **40** | V3 frequently confuses with n²−n+41 (first fails at 41); R1 checks small n systematically |
+
+Adding a new task: see `tasks.ts`. Any checker that's deterministic is
+fair game — extract numeric/list/text with regex, compare with set
+equality or string matching.
+
+## Non-goals
+
+- **No LLM-as-judge.** Brittle and expensive; defeats the point of a
+  reproducible bench. If a checker is too hard to write deterministically,
+  the task doesn't belong here.
+- **No tool-use tasks.** Those live in `tau-bench/`. Different story.
+- **No multi-turn.** v0.3 harness is single-turn Q/A. Multi-turn reasoning
+  eval is separate scope.
+- **No benchmark-data cherry-picking.** When results come in, we publish
+  them whether they validate Pillar 2 or not. "harvest didn't help on
+  these 3 tasks" is still useful information.

benchmarks/harvest/report.md

@@ -0,0 +1,82 @@
+# Reasonix harvest eval (Pillar 2)
+
+**Date:** 2026-04-21T16:44:21.011Z
+**Tasks:** 6 · repeats × 1 · modes: baseline, reasoner, reasoner-harvest
+**Reasonix version:** 0.2.2
+
+## Summary by mode
+
+| mode | runs | pass rate | cache hit | cost / run | harvest turns | subgoals | uncertainties |
+|---|---:|---:|---:|---:|---:|---:|---:|
+| baseline | 6 | 100% | 39.5% | $0.001371 | 0.0 | 0.0 | 0.0 |
+| reasoner | 6 | 100% | 74.2% | $0.004170 | 0.0 | 0.0 | 0.0 |
+| reasoner-harvest | 6 | 83% | 61.6% | $0.003304 | 0.8 | 2.8 | 1.3 |
+
+## Deltas
+
+- **baseline → reasoner**
+  - pass rate: 0pp
+  - cost: ×3.04 (each run costs more)
+  - harvest signal / run: 0.0 subgoals, 0.0 uncertainties
+
+- **baseline → reasoner-harvest**
+  - pass rate: -17pp
+  - cost: ×2.41 (each run costs more)
+  - harvest signal / run: 2.8 subgoals, 1.3 uncertainties
+
+## Per-task breakdown
+
+| task | mode | rep | verdict | cache | cost | sg | un | note |
+|---|---|---:|:---:|---:|---:|---:|---:|---|
+| mod7_list | baseline | 1 | ✅ | 86.5% | $0.001361 | 0 | 0 |  |
+| mod7_list | reasoner | 1 | ✅ | 86.5% | $0.004797 | 0 | 0 |  |
+| mod7_list | reasoner-harvest | 1 | ✅ | 86.5% | $0.003045 | 4 | 2 |  |
+| flips_until_3heads | baseline | 1 | ✅ | 92.8% | $0.001198 | 0 | 0 |  |
+| flips_until_3heads | reasoner | 1 | ✅ | 92.8% | $0.002830 | 0 | 0 |  |
+| flips_until_3heads | reasoner-harvest | 1 | ✅ | 92.8% | $0.001691 | 4 | 0 |  |
+| three_hats | baseline | 1 | ✅ | 57.7% | $0.001514 | 0 | 0 |  |
+| three_hats | reasoner | 1 | ✅ | 57.7% | $0.009340 | 0 | 0 |  |
+| three_hats | reasoner-harvest | 1 | ✅ | 57.7% | $0.009651 | 3 | 2 |  |
+| pseudoprime_base2 | baseline | 1 | ✅ | 0.0% | $0.001894 | 0 | 0 |  |
+| pseudoprime_base2 | reasoner | 1 | ✅ | 75.3% | $0.003128 | 0 | 0 |  |
+| pseudoprime_base2 | reasoner-harvest | 1 | ❌ | 0.0% | $0.000000 | 0 | 0 | This operation was aborted |
+| derangements_d7 | baseline | 1 | ✅ | 0.0% | $0.001273 | 0 | 0 |  |
+| derangements_d7 | reasoner | 1 | ✅ | 71.9% | $0.003492 | 0 | 0 |  |
+| derangements_d7 | reasoner-harvest | 1 | ✅ | 71.9% | $0.002843 | 3 | 2 |  |
+| euler_quadratic_break | baseline | 1 | ✅ | 0.0% | $0.000985 | 0 | 0 |  |
+| euler_quadratic_break | reasoner | 1 | ✅ | 61.0% | $0.001431 | 0 | 0 |  |
+| euler_quadratic_break | reasoner-harvest | 1 | ✅ | 61.0% | $0.002594 | 3 | 2 |  |
+
+## Scope
+
+Unlike τ-bench-lite, these tasks are single-turn reasoning problems (no user simulator, no DB, no tool calls). Checkers are deterministic — regex + set / value compare, never an LLM judge. The point is to isolate whether the Pillar 2 harvest step adds measurable value above plain reasoner usage.
+
+Interpretation: `baseline` (chat / V3) is a floor. `reasoner` shows the raw R1 gain. `reasoner-harvest` isolates the cost + quality delta from the extra V3 harvest call.
+## Findings (v0.3, 18-run set)
+
+Two bands of tasks tried (easy: mod7 / flips / hats; hard: pseudoprime341 / D_7 / Euler quadratic). The hard band was chosen for *known V3 failure modes*. Result:
+
+1. **V3 chat passed all six tasks, including the three "hard" ones.** DeepSeek V3 knew 341 is the smallest base-2 pseudoprime, computed D_7=1854, and identified n=40 as the first Euler-polynomial failure. The tasks are well-known enough to be in training; the trap-answer variants (561, 265, 41) that the checkers specifically reject didn't fire.
+2. **Reasoner cost 3.04× baseline for identical pass rates (6/6 both sides).** On this task set, R1 adds cost and latency without measurable quality. The cache-hit story *does* extend to reasoner (74.2% mean), so Pillar 1 generalizes to R1 — but that's not a Pillar 2 story.
+3. **Harvest produced real signal** (mean 2.8 subgoals, 1.3 uncertainties per run where it fired) but didn't improve outcomes. One run hit the 300s timeout (bumped from 120s), suggesting reasoner-harvest latency is still unpredictable on some problems.
+
+### What this tells us about Pillar 2 positioning
+
+We've now given harvest two shots at showing answer-quality value on pure reasoning tasks. Both times V3 ate its lunch. This isn't a framework bug — it's a positioning signal:
+
+- **On well-known math / logic / counting problems, DeepSeek V3 is strong enough that paying for R1 is not justified by accuracy.** Pillar 2's "smart preset" cost multiplier (10×) quoted in the README is real but for most single-question Q/A it buys nothing.
+- **Harvest's plausible value surfaces are not "better math answers".** More likely: (a) transparency / auditability for developers, (b) planning support when tools are in the mix, (c) driving branch-sampling on cases where uncertainty correlates with wrongness. None of those are tested here.
+
+### Recommendation
+
+Don't ship v0.3 on the "harvest makes answers more correct" claim — the data doesn't support it. Two honest paths forward:
+
+- **Reframe Pillar 2 as a developer-facing introspection feature** (debug visibility into R1's planning). Keep harvest opt-in; stop implying it improves accuracy on end-user tasks.
+- **Move harvest eval to tool-use contexts** where uncertainty matters for *which tool to call next*, not *is this math right*. That's a new task shape — different harness, not a bigger task set here.
+
+In either case, the next Reasonix release is better served by MCP client (Pillar 1 leverage across the ecosystem) than by a bigger harvest-bench data push.
+
+### Notes
+
+- Cache hit on baseline runs surprised me (39.5% mean). That's DeepSeek's *cross-session* prompt cache: the same system prompt ran many times across modes and runs warmed the server-side cache. Real cross-session evidence that Cache-First's value isn't only per-session.
+- 5-subgoals cap still hit uniformly. `HarvestOptions.maxItems` default is 5; harvest is truncating. Moot unless we find a setting where that matters.

benchmarks/harvest/report.ts

@@ -0,0 +1,232 @@
+/**
+ * Render a harvest-bench results.json into a markdown report.
+ *
+ *   npx tsx benchmarks/harvest/report.ts benchmarks/harvest/results-<date>.json
+ *   npx tsx benchmarks/harvest/report.ts <input.json> --out report.md
+ */
+
+import { readFileSync, writeFileSync } from "node:fs";
+import { pathToFileURL } from "node:url";
+import { ALL_MODES, type HarvestBenchReport, type HarvestMode, type HarvestRunResult } from "./types.js";
+
+interface CliArgs {
+  input: string;
+  outPath: string;
+}
+
+function parseArgs(argv: string[]): CliArgs {
+  const out: CliArgs = { input: "", outPath: "benchmarks/harvest/report.md" };
+  const positional: string[] = [];
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--out") out.outPath = argv[++i] ?? out.outPath;
+    else if (a && !a.startsWith("--")) positional.push(a);
+  }
+  out.input = positional[0] ?? "";
+  if (!out.input) {
+    throw new Error("usage: npx tsx benchmarks/harvest/report.ts <results.json> [--out report.md]");
+  }
+  return out;
+}
+
+interface Agg {
+  runs: number;
+  passes: number;
+  avgCache: number;
+  avgCost: number;
+  avgClaudeCost: number;
+  avgHarvestedTurns: number;
+  avgSubgoals: number;
+  avgUncertainties: number;
+}
+
+function aggregate(results: HarvestRunResult[]): Agg {
+  if (results.length === 0) {
+    return {
+      runs: 0,
+      passes: 0,
+      avgCache: 0,
+      avgCost: 0,
+      avgClaudeCost: 0,
+      avgHarvestedTurns: 0,
+      avgSubgoals: 0,
+      avgUncertainties: 0,
+    };
+  }
+  const passes = results.filter((r) => r.verdict === "pass").length;
+  const mean = (fn: (r: HarvestRunResult) => number) =>
+    results.reduce((s, r) => s + fn(r), 0) / results.length;
+  return {
+    runs: results.length,
+    passes,
+    avgCache: mean((r) => r.cacheHitRatio),
+    avgCost: mean((r) => r.costUsd),
+    avgClaudeCost: mean((r) => r.claudeEquivalentUsd),
+    avgHarvestedTurns: mean((r) => r.harvestedTurns),
+    avgSubgoals: mean((r) => r.totalSubgoals),
+    avgUncertainties: mean((r) => r.totalUncertainties),
+  };
+}
+
+export function renderReport(report: HarvestBenchReport): string {
+  const lines: string[] = [];
+  lines.push("# Reasonix harvest eval (Pillar 2)");
+  lines.push("");
+  lines.push(`**Date:** ${report.meta.date}`);
+  lines.push(
+    `**Tasks:** ${report.meta.taskCount} · repeats × ${report.meta.repeatsPerTask} · modes: ${report.meta.modesRun.join(", ")}`,
+  );
+  lines.push(`**Reasonix version:** ${report.meta.reasonixVersion}`);
+  lines.push("");
+
+  // Per-mode summary
+  lines.push("## Summary by mode");
+  lines.push("");
+  lines.push("| mode | runs | pass rate | cache hit | cost / run | harvest turns | subgoals | uncertainties |");
+  lines.push("|---|---:|---:|---:|---:|---:|---:|---:|");
+  for (const mode of ALL_MODES) {
+    const rs = report.results.filter((r) => r.mode === mode);
+    const a = aggregate(rs);
+    if (a.runs === 0) continue;
+    lines.push(
+      `| ${mode} | ${a.runs} | ${pct(a.passes, a.runs)} | ${pct1(a.avgCache)} | $${a.avgCost.toFixed(6)} | ${a.avgHarvestedTurns.toFixed(1)} | ${a.avgSubgoals.toFixed(1)} | ${a.avgUncertainties.toFixed(1)} |`,
+    );
+  }
+  lines.push("");
+
+  // Pairwise deltas that actually answer the question
+  lines.push("## Deltas");
+  lines.push("");
+  const modes = ALL_MODES.filter((m) =>
+    report.results.some((r) => r.mode === m),
+  );
+  if (modes.length >= 2) {
+    const baseline = aggregate(report.results.filter((r) => r.mode === modes[0]));
+    for (let i = 1; i < modes.length; i++) {
+      const mode = modes[i]!;
+      const agg = aggregate(report.results.filter((r) => r.mode === mode));
+      const passDelta = (agg.passes / Math.max(agg.runs, 1)) - (baseline.passes / Math.max(baseline.runs, 1));
+      const costRatio = baseline.avgCost > 0 ? agg.avgCost / baseline.avgCost : 0;
+      lines.push(`- **${modes[0]} → ${mode}**`);
+      lines.push(`  - pass rate: ${(passDelta * 100).toFixed(0)}pp`);
+      lines.push(`  - cost: ×${costRatio.toFixed(2)} (each run costs ${costRatio > 1 ? "more" : "less"})`);
+      lines.push(`  - harvest signal / run: ${agg.avgSubgoals.toFixed(1)} subgoals, ${agg.avgUncertainties.toFixed(1)} uncertainties`);
+      lines.push("");
+    }
+  }
+
+  // Per-task breakdown
+  lines.push("## Per-task breakdown");
+  lines.push("");
+  const byTask = new Map<string, HarvestRunResult[]>();
+  for (const r of report.results) {
+    const list = byTask.get(r.taskId) ?? [];
+    list.push(r);
+    byTask.set(r.taskId, list);
+  }
+  lines.push("| task | mode | rep | verdict | cache | cost | sg | un | note |");
+  lines.push("|---|---|---:|:---:|---:|---:|---:|---:|---|");
+  for (const [taskId, runs] of byTask) {
+    for (const r of runs) {
+      const mark = r.verdict === "pass" ? "✅" : r.verdict === "fail" ? "❌" : "•";
+      lines.push(
+        `| ${taskId} | ${r.mode} | ${r.repeat} | ${mark} | ${pct1(r.cacheHitRatio)} | $${r.costUsd.toFixed(6)} | ${r.totalSubgoals} | ${r.totalUncertainties} | ${truncate(r.checkNote ?? "", 40)} |`,
+      );
+    }
+  }
+  lines.push("");
+
+  lines.push("## Scope");
+  lines.push("");
+  lines.push(
+    "Unlike τ-bench-lite, these tasks are single-turn reasoning problems (no user simulator, no DB, no tool calls). Checkers are deterministic — regex + set / value compare, never an LLM judge. The point is to isolate whether the Pillar 2 harvest step adds measurable value above plain reasoner usage.",
+  );
+  lines.push("");
+  lines.push(
+    "Interpretation: `baseline` (chat / V3) is a floor. `reasoner` shows the raw R1 gain. `reasoner-harvest` isolates the cost + quality delta from the extra V3 harvest call.",
+  );
+
+  return lines.join("\n");
+}
+
+/**
+ * Findings section is hand-written into report.md after rendering — the
+ * numbers don't interpret themselves, and boilerplate sections full of
+ * "TBD — analyse the data" are worse than nothing. Append with append().
+ *
+ * This section has been updated twice: after the first 9-run set (which
+ * bottomed out at V3 on easy tasks) and after this 18-run set (which
+ * bottomed out at V3 on *hard* tasks too).
+ */
+export function renderFindings(_report: HarvestBenchReport): string {
+  return [
+    "",
+    "## Findings (v0.3, 18-run set)",
+    "",
+    "Two bands of tasks tried (easy: mod7 / flips / hats; hard: pseudoprime341 / D_7 / Euler quadratic). The hard band was chosen for *known V3 failure modes*. Result:",
+    "",
+    "1. **V3 chat passed all six tasks, including the three \"hard\" ones.** DeepSeek V3 knew 341 is the smallest base-2 pseudoprime, computed D_7=1854, and identified n=40 as the first Euler-polynomial failure. The tasks are well-known enough to be in training; the trap-answer variants (561, 265, 41) that the checkers specifically reject didn't fire.",
+    "2. **Reasoner cost 3.04× baseline for identical pass rates (6/6 both sides).** On this task set, R1 adds cost and latency without measurable quality. The cache-hit story *does* extend to reasoner (74.2% mean), so Pillar 1 generalizes to R1 — but that's not a Pillar 2 story.",
+    "3. **Harvest produced real signal** (mean 2.8 subgoals, 1.3 uncertainties per run where it fired) but didn't improve outcomes. One run hit the 300s timeout (bumped from 120s), suggesting reasoner-harvest latency is still unpredictable on some problems.",
+    "",
+    "### What this tells us about Pillar 2 positioning",
+    "",
+    "We've now given harvest two shots at showing answer-quality value on pure reasoning tasks. Both times V3 ate its lunch. This isn't a framework bug — it's a positioning signal:",
+    "",
+    "- **On well-known math / logic / counting problems, DeepSeek V3 is strong enough that paying for R1 is not justified by accuracy.** Pillar 2's \"smart preset\" cost multiplier (10×) quoted in the README is real but for most single-question Q/A it buys nothing.",
+    "- **Harvest's plausible value surfaces are not \"better math answers\".** More likely: (a) transparency / auditability for developers, (b) planning support when tools are in the mix, (c) driving branch-sampling on cases where uncertainty correlates with wrongness. None of those are tested here.",
+    "",
+    "### Recommendation",
+    "",
+    "Don't ship v0.3 on the \"harvest makes answers more correct\" claim — the data doesn't support it. Two honest paths forward:",
+    "",
+    "- **Reframe Pillar 2 as a developer-facing introspection feature** (debug visibility into R1's planning). Keep harvest opt-in; stop implying it improves accuracy on end-user tasks.",
+    "- **Move harvest eval to tool-use contexts** where uncertainty matters for *which tool to call next*, not *is this math right*. That's a new task shape — different harness, not a bigger task set here.",
+    "",
+    "In either case, the next Reasonix release is better served by MCP client (Pillar 1 leverage across the ecosystem) than by a bigger harvest-bench data push.",
+    "",
+    "### Notes",
+    "",
+    "- Cache hit on baseline runs surprised me (39.5% mean). That's DeepSeek's *cross-session* prompt cache: the same system prompt ran many times across modes and runs warmed the server-side cache. Real cross-session evidence that Cache-First's value isn't only per-session.",
+    "- 5-subgoals cap still hit uniformly. `HarvestOptions.maxItems` default is 5; harvest is truncating. Moot unless we find a setting where that matters.",
+    "",
+  ].join("\n");
+}
+
+function pct(num: number, denom: number): string {
+  if (denom === 0) return "—";
+  return `${((num / denom) * 100).toFixed(0)}%`;
+}
+
+function pct1(x: number): string {
+  return `${(x * 100).toFixed(1)}%`;
+}
+
+function truncate(s: string, n: number): string {
+  return s.length > n ? `${s.slice(0, n)}…` : s;
+}
+
+async function main(): Promise<void> {
+  const args = parseArgs(process.argv.slice(2));
+  const raw = readFileSync(args.input, "utf8");
+  const report = JSON.parse(raw) as HarvestBenchReport;
+  const md = renderReport(report) + renderFindings(report);
+  writeFileSync(args.outPath, md, "utf8");
+  console.log(`wrote ${args.outPath} (${report.results.length} runs)`);
+}
+
+function isMain(): boolean {
+  const entry = process.argv[1];
+  if (!entry) return false;
+  return import.meta.url === pathToFileURL(entry).href;
+}
+
+if (isMain()) {
+  main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+  });
+}
+
+// Suppress unused import warning — kept in scope so ALL_MODES order matches renderer iteration.
+export type { HarvestMode };

benchmarks/harvest/results.json

@@ -0,0 +1,305 @@
+{
+  "meta": {
+    "date": "2026-04-21T16:44:21.011Z",
+    "repeatsPerTask": 1,
+    "taskCount": 6,
+    "modesRun": [
+      "baseline",
+      "reasoner",
+      "reasoner-harvest"
+    ],
+    "reasonixVersion": "0.2.2"
+  },
+  "results": [
+    {
+      "taskId": "mod7_list",
+      "mode": "baseline",
+      "repeat": 1,
+      "verdict": "pass",
+      "finalAgentMessage": "Alright, let's go step-by-step.\n\n---\n\n## **Step 1: Problem restatement**\nWe want positive integers \\( n \\leq 100 \\) such that  \n\\[\nn^2 + n + 1 \\equiv 0 \\pmod{7}.\n\\]\n\n---\n\n## **Step 2: Try residues modulo 7**\nLet \\( n \\equiv r \\pmod{7} \\), where \\( r \\in \\{0, 1, 2, 3, 4, 5, 6\\} \\).\n\nWe compute \\( r^2 + r + 1 \\mod 7 \\):\n\n- \\( r = 0 \\): \\( 0 + 0 + 1 = 1 \\) → not divisible by 7.\n- \\( r = 1 \\): \\( 1 + 1 + 1 = 3 \\) → no.\n- \\( r = 2 \\): \\( 4 + 2 + 1 = 7 \\equiv 0 \\) → yes.\n- \\( r = 3 \\): \\( 9 + 3 + 1 = 13 \\equiv 6 \\) → no.\n- \\( r = 4 \\): \\( 16 + 4 + 1 = 21 \\equiv 0 \\) → yes.\n- \\( r = 5 \\): \\( 25 + 5 + 1 = 31 \\equiv 3 \\) → no.\n- \\( r = 6 \\): \\( 36 + 6 + 1 = 43 \\equiv 1 \\) → no.\n\nSo \\( n \\equiv 2 \\pmod{7} \\) or \\( n \\equiv 4 \\pmod{7} \\).\n\n---\n\n## **Step 3: General form**\n\\[\nn \\equiv 2 \\pmod{7} \\quad \\text{or} \\quad n \\equiv 4 \\pmod{7}.\n\\]\n\nThat means \\( n = 7k + 2 \\) or \\( n = 7k + 4 \\) for some integer \\( k \\ge 0 \\).\n\n---\n\n## **Step 4: Positive integers \\( n \\leq 100 \\)**\n**Case 1:** \\( n = 7k + 2 \\), \\( n \\leq 100 \\), \\( k \\ge 0 \\).\n\n\\( 7k + 2 \\leq 100 \\) → \\( 7k \\leq 98 \\) → \\( k \\leq 14 \\).\n\nSo \\( k = 0, 1, 2, \\dots, 14 \\) gives \\( n = 2, 9, 16, \\dots, 100 \\).\n\nCheck \\( n=100 \\): \\( 7 \\times 14 + 2 = 98 + 2 = 100 \\) okay.\n\n---\n\n**Case 2:** \\( n = 7k + 4 \\), \\( n \\leq 100 \\), \\( k \\ge 0 \\).\n\n\\( 7k + 4 \\leq 100 \\) → \\( 7k \\leq 96 \\) → \\( k \\leq 13 \\) (since \\( 7 \\times 13 = 91 \\), \\( 91+4=95 \\), \\( 7\\times14=98 \\) → \\( 98+4=102>100 \\)).\n\nSo \\( k = 0, 1, 2, \\dots, 13 \\) gives \\( n = 4, 11, 18, \\dots, 95 \\).\n\n---\n\n## **Step 5: List all such \\( n \\leq 100 \\)**\nFrom case 1: \\( 2, 9, 16, 23, 30, 37, 44, 51, 58, 65, 72, 79, 86, 93, 100 \\).\n\nFrom case 2: \\( 4, 11, 18, 25, 32, 39, 46, 53, 60, 67, 74, 81, 88, 95 \\).\n\nCombine and sort:\n\n\\[\n2, 4, 9, 11, 16, 18, 23, 25, 30, 32, 37, 39, 44, 46, 51, 53, 58, 60, 65, 67, 72, 74, 79, 81, 86, 88, 93, 95, 100.\n\\]\n\n---\n\n## **Step 6: Check count**\nEach sequence has 15 and 14 terms respectively, total \\( 15 + 14 = 29 \\) numbers.\n\nCheck: \\( n=2 \\) works? \\( 4+2+1=7 \\) yes. \\( n=4 \\) works? \\( 16+4+1=21 \\) yes. \\( n=100 \\) works? \\( 10000+100+1=10101 \\), divide by 7: \\( 10101/7 = 1443 \\) yes.\n\n---\n\n**Final answer:**\n\\[\n\\boxed{2, 4, 9, 11, 16, 18, 23, 25, 30, 32, 37, 39, 44, 46, 51, 53, 58, 60, 65, 67, 72, 74, 79, 81, 86, 88, 93, 95, 100}\n\\]\n\n---\n\nAnswer: 2, 4, 9, 11, 16, 18, 23, 25, 30, 32, 37, 39, 44, 46, 51, 53, 58, 60, 65, 67, 72, 74, 79, 81, 86, 88, 93, 95, 100",
+      "turns": 1,
+      "cacheHitRatio": 0.8648648648648649,
+      "costUsd": 0.0013612800000000003,
+      "claudeEquivalentUsd": 0.018687,
+      "harvestedTurns": 0,
+      "totalSubgoals": 0,
+      "totalUncertainties": 0,
+      "totalHypotheses": 0,
+      "totalRejectedPaths": 0
+    },
+    {
+      "taskId": "mod7_list",
+      "mode": "reasoner",
+      "repeat": 1,
+      "verdict": "pass",
+      "finalAgentMessage": "The condition \\(n^2 + n + 1\\) divisible by 7 is equivalent to \\(n^2 + n + 1 \\equiv 0 \\pmod{7}\\). Testing residues modulo 7:\n\n- \\(n \\equiv 0: 0+0+1 \\equiv 1\\)  \n- \\(n \\equiv 1: 1+1+1 \\equiv 3\\)  \n- \\(n \\equiv 2: 4+2+1 \\equiv 7 \\equiv 0\\)  \n- \\(n \\equiv 3: 9+3+1 \\equiv 13 \\equiv 6\\)  \n- \\(n \\equiv 4: 16+4+1 \\equiv 21 \\equiv 0\\)  \n- \\(n \\equiv 5: 25+5+1 \\equiv 31 \\equiv 3\\)  \n- \\(n \\equiv 6: 36+6+1 \\equiv 43 \\equiv 1\\)\n\nThus, \\(n \\equiv 2\\) or \\(n \\equiv 4 \\pmod{7}\\) are the solutions modulo 7. For positive integers \\(n \\leq 100\\), we list all numbers congruent to 2 or 4 modulo 7 in increasing order.\n\nAnswer: 2, 4, 9, 11, 16, 18, 23, 25, 30, 32, 37, 39, 44, 46, 51, 53, 58, 60, 65, 67, 72, 74, 79, 81, 86, 88, 93, 95, 100",
+      "turns": 1,
+      "cacheHitRatio": 0.8648648648648649,
+      "costUsd": 0.00479742,
+      "claudeEquivalentUsd": 0.032982,
+      "harvestedTurns": 0,
+      "totalSubgoals": 0,
+      "totalUncertainties": 0,
+      "totalHypotheses": 0,
+      "totalRejectedPaths": 0
+    },
+    {
+      "taskId": "mod7_list",
+      "mode": "reasoner-harvest",
+      "repeat": 1,
+      "verdict": "pass",
+      "finalAgentMessage": "The congruence \\(n^2 + n + 1 \\equiv 0 \\pmod{7}\\) is solved by testing residues modulo 7. The solutions are \\(n \\equiv 2\\) and \\(n \\equiv 4 \\pmod{7}\\). For positive integers \\(n \\le 100\\), these yield \\(n = 7k + 2\\) with \\(k = 0, 1, \\dots, 14\\) and \\(n = 7k + 4\\) with \\(k = 0, 1, \\dots, 13\\).\n\nAnswer: 2, 4, 9, 11, 16, 18, 23, 25, 30, 32, 37, 39, 44, 46, 51, 53, 58, 60, 65, 67, 72, 74, 79, 81, 86, 88, 93, 95, 100",
+      "turns": 1,
+      "cacheHitRatio": 0.8648648648648649,
+      "costUsd": 0.00304542,
+      "claudeEquivalentUsd": 0.020982,
+      "harvestedTurns": 1,
+      "totalSubgoals": 4,
+      "totalUncertainties": 2,
+      "totalHypotheses": 2,
+      "totalRejectedPaths": 2
+    },
+    {
+      "taskId": "flips_until_3heads",
+      "mode": "baseline",
+      "repeat": 1,
+      "verdict": "pass",
+      "finalAgentMessage": "Alright, let's reason through this step-by-step.\n\n---\n\n## **Step 1: Define states**\nLet’s define states based on how many consecutive heads we have at the moment.\n\n- \\( E_0 \\): Expected flips to reach 3 heads in a row starting from 0 consecutive heads (or just starting, or after a tail).\n- \\( E_1 \\): Expected flips to reach 3 heads in a row starting from 1 consecutive head.\n- \\( E_2 \\): Expected flips to reach 3 heads in a row starting from 2 consecutive heads.\n\nWe want \\( E_0 \\).\n\n---\n\n## **Step 2: Transition equations**\nFrom \\( E_0 \\):\n- Flip H (prob \\( \\frac12 \\)) → go to state \\( E_1 \\), 1 flip used.\n- Flip T (prob \\( \\frac12 \\)) → stay in \\( E_0 \\), 1 flip used.\n\nSo:\n\\[\nE_0 = \\frac12 (1 + E_1) + \\frac12 (1 + E_0)\n\\]\n\n---\n\nFrom \\( E_1 \\) (already have 1 head):\n- Flip H (prob \\( \\frac12 \\)) → go to state \\( E_2 \\), 1 flip used.\n- Flip T (prob \\( \\frac12 \\)) → go to state \\( E_0 \\), 1 flip used.\n\nSo:\n\\[\nE_1 = \\frac12 (1 + E_2) + \\frac12 (1 + E_0)\n\\]\n\n---\n\nFrom \\( E_2 \\) (already have 2 heads):\n- Flip H (prob \\( \\frac12 \\)) → done (3 heads in a row), 1 flip used.\n- Flip T (prob \\( \\frac12 \\)) → go to state \\( E_0 \\), 1 flip used.\n\nSo:\n\\[\nE_2 = \\frac12 (1 + 0) + \\frac12 (1 + E_0)\n\\]\n\\[\nE_2 = \\frac12 \\cdot 1 + \\frac12 (1 + E_0) \\quad\\text{(Wait, careful:)}\n\\]\nActually:  \nIf H: \\( 1 \\) flip and done.  \nIf T: \\( 1 \\) flip and then \\( E_0 \\) more.\n\nSo:\n\\[\nE_2 = \\frac12 \\cdot 1 + \\frac12 (1 + E_0)\n\\]\nCheck:  \nH: 1 flip → total 1, done. Contribution: \\( \\frac12 \\times 1 \\).  \nT: 1 flip + \\( E_0 \\) more → total \\( 1 + E_0 \\). Contribution: \\( \\frac12 \\times (1 + E_0) \\).\n\nYes:\n\\[\nE_2 = \\frac12 \\cdot 1 + \\frac12 (1 + E_0) = \\frac12 + \\frac12 + \\frac12 E_0 = 1 + \\frac{E_0}{2}.\n\\]\n\n---\n\n## **Step 3: Solve system**\nWe have:\n\n(1) \\( E_0 = \\frac12 (1 + E_1) + \\frac12 (1 + E_0) \\)  \nSimplify: \\( E_0 = 1 + \\frac12 E_1 + \\frac12 E_0 \\)  \nMultiply by 2: \\( 2E_0 = 2 + E_1 + E_0 \\)  \nSo \\( E_0 - E_1 = 2 \\) … (Eq A)\n\n---\n\n(2) \\( E_1 = \\frac12 (1 + E_2) + \\frac12 (1 + E_0) \\)  \nSimplify: \\( E_1 = 1 + \\frac12 E_2 + \\frac12 E_0 \\) … (Eq B)\n\n---\n\n(3) \\( E_2 = 1 + \\frac12 E_0 \\) … (Eq C)\n\n---\n\nFrom Eq C into Eq B:\n\\[\nE_1 = 1 + \\frac12 \\left( 1 + \\frac12 E_0 \\right) + \\frac12 E_0\n\\]\n\\[\nE_1 = 1 + \\frac12 + \\frac14 E_0 + \\frac12 E_0\n\\]\n\\[\nE_1 = \\frac32 + \\frac34 E_0\n\\]\n\n---\n\nFrom Eq A: \\( E_0 - E_1 = 2 \\)  \nSubstitute \\( E_1 \\):\n\\[\nE_0 - \\left( \\frac32 + \\frac34 E_0 \\right) = 2\n\\]\n\\[\nE_0 - \\frac32 - \\frac34 E_0 = 2\n\\]\n\\[\n\\frac14 E_0 - \\frac32 = 2\n\\]\n\\[\n\\frac14 E_0 = 2 + \\frac32 = \\frac72\n\\]\n\\[\nE_0 = 14\n\\]\n\n---\n\n## **Step 4: Conclusion**\nThe expected number of flips until we get 3 heads in a row is \\( 14 \\).\n\n---\n\n**Answer:** 14",
+      "turns": 1,
+      "cacheHitRatio": 0.927536231884058,
+      "costUsd": 0.00119823,
+      "claudeEquivalentUsd": 0.016467,
+      "harvestedTurns": 0,
+      "totalSubgoals": 0,
+      "totalUncertainties": 0,
+      "totalHypotheses": 0,
+      "totalRejectedPaths": 0
+    },
+    {
+      "taskId": "flips_until_3heads",
+      "mode": "reasoner",
+      "repeat": 1,
+      "verdict": "pass",
+      "finalAgentMessage": "The expected number of flips required to get three consecutive heads is 14, derived from solving the system of linear equations for the Markov chain states representing the current streak of heads.\n\nAnswer: 14",
+      "turns": 1,
+      "cacheHitRatio": 0.927536231884058,
+      "costUsd": 0.00283024,
+      "claudeEquivalentUsd": 0.019512,
+      "harvestedTurns": 0,
+      "totalSubgoals": 0,
+      "totalUncertainties": 0,
+      "totalHypotheses": 0,
+      "totalRejectedPaths": 0
+    },
+    {
+      "taskId": "flips_until_3heads",
+      "mode": "reasoner-harvest",
+      "repeat": 1,
+      "verdict": "pass",
+      "finalAgentMessage": "The expected number of flips until three consecutive heads appear is 14.\n\nAnswer: 14",
+      "turns": 1,
+      "cacheHitRatio": 0.927536231884058,
+      "costUsd": 0.00169144,
+      "claudeEquivalentUsd": 0.011712,
+      "harvestedTurns": 1,
+      "totalSubgoals": 4,
+      "totalUncertainties": 0,
+      "totalHypotheses": 2,
+      "totalRejectedPaths": 0
+    },
+    {
+      "taskId": "three_hats",
+      "mode": "baseline",
+      "repeat": 1,
+      "verdict": "pass",
+      "finalAgentMessage": "Let's break this down step by step.\n\n---\n\n**Step 1: Understanding the setup**  \nThree people: A (first), B (second), C (third).  \nEach hat is red (R) or blue (B).  \nThey know: at least one hat is red.  \nEach sees the other two hats, not their own.  \nThey are asked in order: \"Do you know your hat color?\"  \nA answers no, B answers no, C answers yes.  \nWe want C’s hat color.\n\n---\n\n**Step 2: From A’s perspective when asked**  \nA sees B and C.  \nIf A had seen two blue hats, then A would know: \"At least one red hat means my hat must be red.\"  \nSo A says \"no\" → A did **not** see two blue hats.  \nThus A sees at least one red hat on {B, C}.\n\nPossible cases for what A sees (B, C):  \n(R, R), (R, B), (B, R) — all have at least one red.\n\n---\n\n**Step 3: B’s reasoning when asked**  \nB hears A say \"no\".  \nB sees A and C.  \n\nLet’s consider B’s possible deductions from A’s \"no\":  \nB knows: If A had seen two blues, A would have said yes. Since A said no, A saw at least one red among B and C.  \nBut B sees A and C.  \n\nFrom B’s viewpoint:  \n- If B saw C with blue and A with blue, then B would know: \"A saw me and C both blue → impossible because A said no.\" But B doesn’t see that because if B saw A blue and C blue, then B would know his own hat must be red (since at least one red total). But then B would answer yes.  \nSo B’s \"no\" means B did **not** see A and C both blue.  \n\nAlso, B considers: Could my hat be blue? Let’s check:  \nSuppose B sees A red, C blue. Then B thinks: \"If my hat were blue, then A would have seen (B blue, C blue) → A would have said yes. But A said no, so my hat cannot be blue.\"  \nSo if B saw (A red, C blue), B would deduce: \"My hat must be red.\" Then B would answer yes.  \nBut B said no → so B did **not** see (A red, C blue).\n\nSimilarly, if B saw (A blue, C red):  \nThen B thinks: \"If my hat were blue, then A would have seen (B blue, C red) → that’s fine (A sees one red on C), so A would still say no. If my hat were red, then A would see (B red, C red) → A would still say no. So I don’t know.\" That’s consistent with B saying no.  \n\nIf B saw (A red, C red):  \nThen B thinks: \"If my hat were blue, A sees (B blue, C red) → A says no. If my hat were red, A sees (B red, C red) → A says no. So I don’t know.\" That’s also consistent with B saying no.\n\nSo B says no in cases:  \nB sees (A blue, C red) or (A red, C red).  \nB would say yes if B saw (A red, C blue) — but that didn’t happen.  \n\n---\n\n**Step 4: C’s reasoning**  \nC hears A says no, B says no.  \nC sees A and B.  \n\nFrom C’s viewpoint:  \nLet’s list all possible (A, B, C) hat colorings with at least one red, consistent with A’s \"no\" (which we already incorporated: A sees at least one red on B/C) and B’s \"no\" (meaning B didn’t see A red, C blue — because that would make B know).\n\nPossible cases for (A, B) that C could see:  \n\n1. C sees (A blue, B red):  \n   Then C thinks:  \n   - If C were blue: (A blue, B red, C blue) → A sees (B red, C blue) → A says no. B sees (A blue, C blue) → B sees two blues? Wait, B sees A blue, C blue → then B knows his own hat is red (since at least one red total) → B would say yes. But B said no → contradiction. So C cannot be blue.  \n   So C must be red.  \n\n2. C sees (A red, B blue):  \n   Then C thinks:  \n   - If C were blue: (A red, B blue, C blue) → A sees (B blue, C blue) → A would say yes (since at least one red total means A’s hat must be red). But A said no → contradiction. So C cannot be blue.  \n   So C must be red.  \n\n3. C sees (A red, B red):  \n   Then C thinks:  \n   - If C were blue: (A red, B red, C blue) → A sees (B red, C blue) → A says no. B sees (A red, C blue) → B sees A red, C blue → earlier we said: If B sees A red, C blue, then B would deduce his own hat is red (reasoning: if B were blue, A would have seen two blues and said yes, but A said no, so B can’t be blue) → so B would say yes. But B actually said no → contradiction. So C cannot be blue.  \n   - If C were red: (A red, B red, C red) → A sees (B red, C red) → A says no. B sees (A red, C red) → B says no. Works fine.  \n\nSo in all cases C sees for (A, B), C can deduce C’s hat is **red** because assuming C is blue leads to contradiction with B’s \"no\" (in cases 1 and 3) or with A’s \"no\" (in case 2).\n\n---\n\n**Step 5: Conclusion**  \nC answers yes, and C’s hat must be red.\n\n---\n\nAnswer: red",
+      "turns": 1,
+      "cacheHitRatio": 0.5765765765765766,
+      "costUsd": 0.0015142700000000003,
+      "claudeEquivalentUsd": 0.020748,
+      "harvestedTurns": 0,
+      "totalSubgoals": 0,
+      "totalUncertainties": 0,
+      "totalHypotheses": 0,
+      "totalRejectedPaths": 0
+    },
+    {
+      "taskId": "three_hats",
+      "mode": "reasoner",
+      "repeat": 1,
+      "verdict": "pass",
+      "finalAgentMessage": "Answer: red",
+      "turns": 1,
+      "cacheHitRatio": 0.5765765765765766,
+      "costUsd": 0.009340119999999999,
+      "claudeEquivalentUsd": 0.064068,
+      "harvestedTurns": 0,
+      "totalSubgoals": 0,
+      "totalUncertainties": 0,
+      "totalHypotheses": 0,
+      "totalRejectedPaths": 0
+    },
+    {
+      "taskId": "three_hats",
+      "mode": "reasoner-harvest",
+      "repeat": 1,
+      "verdict": "pass",
+      "finalAgentMessage": "The third person deduces their hat color based on the previous responses. Since the first two answer \"no,\" it implies they each see at least one red hat and cannot determine their own color. Specifically, the second person's \"no\" indicates they see the third person's hat as red; otherwise, they would have known their own hat color. Therefore, the third person's hat must be red.\n\nAnswer: red",
+      "turns": 1,
+      "cacheHitRatio": 0.5765765765765766,
+      "costUsd": 0.0096511,
+      "claudeEquivalentUsd": 0.066198,
+      "harvestedTurns": 1,
+      "totalSubgoals": 3,
+      "totalUncertainties": 2,
+      "totalHypotheses": 3,
+      "totalRejectedPaths": 3
+    },
+    {
+      "taskId": "pseudoprime_base2",
+      "mode": "baseline",
+      "repeat": 1,
+      "verdict": "pass",
+      "finalAgentMessage": "Alright, let's go step-by-step.\n\n---\n\n**Step 1: Understanding the problem**\n\nWe want the smallest composite integer \\( n > 1 \\) such that\n\n\\[\n2^n \\equiv 2 \\pmod{n}.\n\\]\n\nEquivalently, \\( 2^{n-1} \\equiv 1 \\pmod{n} \\) for composite \\( n \\).\n\nThis means \\( n \\) is a **Fermat pseudoprime to base 2**.\n\nWe check composite numbers starting from the smallest.\n\n---\n\n**Step 2: Check small composites**\n\n- \\( n = 4 \\): composite.  \n\\( 2^4 = 16 \\), \\( 16 \\mod 4 = 0 \\), not \\( 2 \\). So \\( 2^4 \\equiv 0 \\not\\equiv 2 \\pmod{4} \\). Fails.\n\n- \\( n = 6 \\): composite.  \n\\( 2^6 = 64 \\), \\( 64 \\mod 6 = 4 \\), not \\( 2 \\). Fails.\n\n- \\( n = 8 \\): composite.  \n\\( 2^8 = 256 \\), \\( 256 \\mod 8 = 0 \\), not \\( 2 \\). Fails.\n\n- \\( n = 9 \\): composite.  \n\\( 2^9 = 512 \\), \\( 512 \\mod 9 \\):  \n\\( 512 \\div 9 \\), \\( 9 \\times 56 = 504 \\), remainder \\( 8 \\), not \\( 2 \\). Fails.\n\n- \\( n = 10 \\): composite.  \n\\( 2^{10} = 1024 \\), \\( 1024 \\mod 10 = 4 \\), not \\( 2 \\). Fails.\n\n---\n\n**Step 3: Try n = 15**\n\n\\( n = 15 \\): composite.  \n\\( 2^{15} = 32768 \\).  \nCheck mod 15:  \nWe can use mod arithmetic:  \n\\( 2^4 = 16 \\equiv 1 \\pmod{15} \\)?? Wait, check: \\( 16 \\mod 15 = 1 \\), yes.  \nSo \\( 2^{15} = (2^4)^3 \\times 2^3 = 1^3 \\times 8 = 8 \\pmod{15} \\).  \nSo \\( 2^{15} \\equiv 8 \\not\\equiv 2 \\pmod{15} \\). Fails.\n\n---\n\n**Step 4: Try n = 21**\n\n\\( n = 21 \\): composite.  \nMod 21:  \n\\( 2^6 = 64 \\equiv 1 \\pmod{21} \\)? Check: \\( 64 \\div 21 = 3 \\times 21 = 63 \\), remainder 1, yes.  \nSo \\( 2^{21} = (2^6)^3 \\times 2^3 \\equiv 1^3 \\times 8 = 8 \\pmod{21} \\). Not 2. Fails.\n\n---\n\n**Step 5: Try n = 22**\n\n\\( n = 22 \\): composite.  \nUse mod 22:  \nEuler’s totient not needed, just check order:  \n\\( 2^5 = 32 \\equiv 10 \\pmod{22} \\)  \n\\( 2^{10} = (2^5)^2 \\equiv 10^2 = 100 \\equiv 12 \\pmod{22} \\)  \n\\( 2^{11} \\equiv 24 \\equiv 2 \\pmod{22} \\)  \nSo \\( 2^{22} = (2^{11})^2 \\equiv 2^2 = 4 \\pmod{22} \\). Not 2. Fails.\n\n---\n\n**Step 6: Try n = 25**\n\n\\( n = 25 \\): composite.  \nCheck mod 25:  \n\\( 2^{10} = 1024 \\equiv 24 \\pmod{25} \\) (since \\( 1000 \\equiv 0 \\), \\( 24 \\equiv -1 \\))  \nActually check: \\( 1024 - 1000 = 24 \\), yes \\( 24 \\equiv -1 \\).  \nSo \\( 2^{20} \\equiv 1 \\pmod{25} \\).  \nThus \\( 2^{25} = 2^{20} \\times 2^5 \\equiv 1 \\times 32 = 7 \\pmod{25} \\). Not 2. Fails.\n\n---\n\n**Step 7: Known smallest base-2 Fermat pseudoprime**\n\nFrom known number theory facts:  \nThe smallest Fermat pseudoprime to base 2 is \\( n = 341 \\).  \nBut let's check smaller ones just in case I’m skipping one.\n\n---\n\n**Step 8: Try n = 91**\n\n91 = 7 × 13.  \nCheck mod 7: \\( 2^{91} \\equiv (2^6)^{15} \\times 2^1 \\equiv 1^{15} \\times 2 = 2 \\pmod{7} \\).  \nCheck mod 13: \\( 2^{12} \\equiv 1 \\pmod{13} \\),  \n\\( 91 = 12 \\times 7 + 7 \\), so \\( 2^{91} \\equiv 2^7 = 128 \\equiv 11 \\pmod{13} \\).  \nFor \\( 2^{91} \\equiv 2 \\pmod{91} \\), we need \\( 2^{91} \\equiv 2 \\) mod 7 and mod 13.  \nMod 13 we got 11, not 2. So fails.\n\n---\n\n**Step 9: Try n = 341**\n\n341 = 11 × 31.  \nCheck mod 11: \\( 2^{10} \\equiv 1 \\pmod{11} \\),  \n\\( 341 = 10 \\times 34 + 1 \\), so \\( 2^{341} \\equiv 2^1 = 2 \\pmod{11} \\). Good.  \nCheck mod 31: \\( 2^5 = 32 \\equiv 1 \\pmod{31} \\),  \n\\( 341 = 5 \\times 68 + 1 \\), so \\( 2^{341} \\equiv 2^1 = 2 \\pmod{31} \\).  \nSo \\( 2^{341} \\equiv 2 \\) mod 11 and mod 31, hence mod 341.  \nThus \\( 341 \\) works.\n\n---\n\n**Step 10: Check smaller than 341**\n\nKnown list: 341 is smallest. Let’s check a candidate like 121 = 11^2:  \n\\( 2^{121} \\mod 121 \\):  \nMod 11: \\( 2^{10} \\equiv 1 \\), \\( 121 = 10 \\times 12 + 1 \\), so \\( 2^{121} \\equiv 2 \\pmod{11} \\).  \nBut for modulus 121, need more:  \nActually, \\( 2^{110} \\equiv 1 \\pmod{121} \\) by Euler’s theorem? Not exactly, but known: 121 is not a pseudoprime base 2. Quick check:  \n\\( 2^{121} - 2 \\) divisible by 121? Probably not. Let’s skip detailed check; known fact is 341 is smallest.\n\n---\n\n**Step 11: Verify no smaller composite works**\n\nFrom known sequence A001567:  \nFirst few base-2 Fermat pseudoprimes: 341, 561, 645, 1105, …  \nSo smallest is 341.\n\n---\n\n**Step 12: Conclusion**\n\nThe smallest composite \\( n > 1 \\) with \\( 2^n \\equiv 2 \\pmod{n} \\) is \\( n = 341 \\).\n\n---\n\n**Answer:** 341",
+      "turns": 1,
+      "cacheHitRatio": 0,
+      "costUsd": 0.0018940500000000002,
+      "claudeEquivalentUsd": 0.02577,
+      "harvestedTurns": 0,
+      "totalSubgoals": 0,
+      "totalUncertainties": 0,
+      "totalHypotheses": 0,
+      "totalRejectedPaths": 0
+    },
+    {
+      "taskId": "pseudoprime_base2",
+      "mode": "reasoner",
+      "repeat": 1,
+      "verdict": "pass",
+      "finalAgentMessage": "The smallest composite integer \\(n > 1\\) satisfying \\(2^n \\equiv 2 \\pmod{n}\\) is \\(n = 341\\). This is composite (\\(341 = 11 \\times 31\\)), and it satisfies the congruence because \\(2^{341} \\equiv 2 \\pmod{11}\\) and \\(2^{341} \\equiv 2 \\pmod{31}\\) by Fermat's little theorem, implying \\(2^{341} \\equiv 2 \\pmod{341}\\). All smaller composite integers (e.g., 4, 6, 8, 9, 10, 15, 21) fail to satisfy the condition.\n\nAnswer: 341",
+      "turns": 1,
+      "cacheHitRatio": 0.7529411764705882,
+      "costUsd": 0.0031281200000000003,
+      "claudeEquivalentUsd": 0.02154,
+      "harvestedTurns": 0,
+      "totalSubgoals": 0,
+      "totalUncertainties": 0,
+      "totalHypotheses": 0,
+      "totalRejectedPaths": 0
+    },
+    {
+      "taskId": "pseudoprime_base2",
+      "mode": "reasoner-harvest",
+      "repeat": 1,
+      "verdict": "fail",
+      "checkNote": "This operation was aborted",
+      "finalAgentMessage": "",
+      "turns": 0,
+      "cacheHitRatio": 0,
+      "costUsd": 0,
+      "claudeEquivalentUsd": 0,
+      "harvestedTurns": 0,
+      "totalSubgoals": 0,
+      "totalUncertainties": 0,
+      "totalHypotheses": 0,
+      "totalRejectedPaths": 0,
+      "errorMessage": "This operation was aborted"
+    },
+    {
+      "taskId": "derangements_d7",
+      "mode": "baseline",
+      "repeat": 1,
+      "verdict": "pass",
+      "finalAgentMessage": "Alright, let's go step-by-step.\n\n---\n\n**Step 1: Understanding the problem**\n\nWe want the number of permutations of \\(\\{1, 2, 3, 4, 5, 6, 7\\}\\) with **no fixed points**.  \nA fixed point means \\(\\pi(i) = i\\) for some \\(i\\).  \nA permutation with no fixed points is called a **derangement**.  \nThe number of derangements of \\(n\\) elements is denoted \\(D_n\\) or \\(!n\\).\n\n---\n\n**Step 2: Formula for derangements**\n\nThe formula for \\(D_n\\) is:\n\n\\[\nD_n = n! \\sum_{k=0}^{n} \\frac{(-1)^k}{k!}\n\\]\n\nFor \\(n=7\\):\n\n\\[\nD_7 = 7! \\left( \\frac{1}{0!} - \\frac{1}{1!} + \\frac{1}{2!} - \\frac{1}{3!} + \\frac{1}{4!} - \\frac{1}{5!} + \\frac{1}{6!} - \\frac{1}{7!} \\right)\n\\]\n\n---\n\n**Step 3: Compute step-by-step**\n\nFirst, \\(7! = 5040\\).\n\nNow compute the sum:\n\n\\[\n\\sum_{k=0}^{7} \\frac{(-1)^k}{k!} \n= 1 - 1 + \\frac{1}{2} - \\frac{1}{6} + \\frac{1}{24} - \\frac{1}{120} + \\frac{1}{720} - \\frac{1}{5040}\n\\]\n\nLet's compute term-by-term:\n\n- \\(1 - 1 = 0\\)\n- \\(0 + 0.5 = 0.5\\)\n- \\(0.5 - \\frac{1}{6} \\approx 0.5 - 0.1666667 = 0.3333333\\)\n- \\(0.3333333 + \\frac{1}{24} \\approx 0.3333333 + 0.0416667 = 0.375\\)\n- \\(0.375 - \\frac{1}{120} \\approx 0.375 - 0.0083333 = 0.3666667\\)\n- \\(0.3666667 + \\frac{1}{720} \\approx 0.3666667 + 0.0013889 = 0.3680556\\)\n- \\(0.3680556 - \\frac{1}{5040} \\approx 0.3680556 - 0.0001984 = 0.3678572\\)\n\nSo the sum is approximately \\(0.367857142857...\\)\n\n---\n\n**Step 4: Multiply by \\(7!\\)**\n\n\\[\nD_7 = 5040 \\times 0.367857142857\\ldots\n\\]\n\nLet's compute exactly using fractions:\n\n\\[\n\\sum_{k=0}^{7} \\frac{(-1)^k}{k!} \n= \\frac{1}{2!} - \\frac{1}{3!} + \\frac{1}{4!} - \\frac{1}{5!} + \\frac{1}{6!} - \\frac{1}{7!}\n\\]\n\nWrite with common denominator \\(7! = 5040\\):\n\n- \\(\\frac{1}{2!} = \\frac{2520}{5040}\\)\n- \\(\\frac{1}{3!} = \\frac{840}{5040}\\)\n- \\(\\frac{1}{4!} = \\frac{210}{5040}\\)\n- \\(\\frac{1}{5!} = \\frac{42}{5040}\\)\n- \\(\\frac{1}{6!} = \\frac{7}{5040}\\)\n- \\(\\frac{1}{7!} = \\frac{1}{5040}\\)\n\nNow alternate signs:\n\n\\[\n\\left( \\frac{2520}{5040} - \\frac{840}{5040} \\right) \n= \\frac{1680}{5040}\n\\]\n\\[\n\\frac{1680}{5040} + \\frac{210}{5040} = \\frac{1890}{5040}\n\\]\n\\[\n\\frac{1890}{5040} - \\frac{42}{5040} = \\frac{1848}{5040}\n\\]\n\\[\n\\frac{1848}{5040} + \\frac{7}{5040} = \\frac{1855}{5040}\n\\]\n\\[\n\\frac{1855}{5040} - \\frac{1}{5040} = \\frac{1854}{5040}\n\\]\n\nSo the sum is \\(\\frac{1854}{5040}\\).\n\n---\n\n**Step 5: Multiply by \\(7!\\)**\n\n\\[\nD_7 = 5040 \\times \\frac{1854}{5040} = 1854\n\\]\n\n---\n\n**Step 6: Quick check with known derangement numbers**\n\nKnown small derangements:  \n\\(D_1 = 0, D_2 = 1, D_3 = 2, D_4 = 9, D_5 = 44, D_6 = 265, D_7 = 1854\\).  \nYes, matches known sequence.\n\n---\n\n**Final answer:**\n\nAnswer: 1854",
+      "turns": 1,
+      "cacheHitRatio": 0,
+      "costUsd": 0.00127253,
+      "claudeEquivalentUsd": 0.017292,
+      "harvestedTurns": 0,
+      "totalSubgoals": 0,
+      "totalUncertainties": 0,
+      "totalHypotheses": 0,
+      "totalRejectedPaths": 0
+    },
+    {
+      "taskId": "derangements_d7",
+      "mode": "reasoner",
+      "repeat": 1,
+      "verdict": "pass",
+      "finalAgentMessage": "The number of derangements of \\(n\\) distinct objects, denoted \\(D_n\\), counts permutations with no fixed points. For \\(n = 7\\), this can be computed using the recurrence \\(D_n = (n-1)(D_{n-1} + D_{n-2})\\) with initial values \\(D_1 = 0\\) and \\(D_2 = 1\\).  \nThus:  \n\\(D_3 = 2(1+0) = 2\\),  \n\\(D_4 = 3(2+1) = 9\\),  \n\\(D_5 = 4(9+2) = 44\\),  \n\\(D_6 = 5(44+9) = 265\\),  \n\\(D_7 = 6(265+44) = 1854\\).\n\nAnswer: 1854",
+      "turns": 1,
+      "cacheHitRatio": 0.7191011235955056,
+      "costUsd": 0.00349167,
+      "claudeEquivalentUsd": 0.024027,
+      "harvestedTurns": 0,
+      "totalSubgoals": 0,
+      "totalUncertainties": 0,
+      "totalHypotheses": 0,
+      "totalRejectedPaths": 0
+    },
+    {
+      "taskId": "derangements_d7",
+      "mode": "reasoner-harvest",
+      "repeat": 1,
+      "verdict": "pass",
+      "finalAgentMessage": "The number of derangements of \\(n\\) elements, denoted \\(D_n\\), counts permutations with no fixed points. For \\(n=7\\), this can be computed using the recurrence \\(D_n = (n-1)(D_{n-1} + D_{n-2})\\) with initial values \\(D_0 = 1\\) and \\(D_1 = 0\\). Applying the recurrence yields \\(D_2 = 1\\), \\(D_3 = 2\\), \\(D_4 = 9\\), \\(D_5 = 44\\), \\(D_6 = 265\\), and finally \\(D_7 = 6 \\times (265 + 44) = 1854\\).\n\nAnswer: 1854",
+      "turns": 1,
+      "cacheHitRatio": 0.7191011235955056,
+      "costUsd": 0.0028434299999999997,
+      "claudeEquivalentUsd": 0.019587,
+      "harvestedTurns": 1,
+      "totalSubgoals": 3,
+      "totalUncertainties": 2,
+      "totalHypotheses": 2,
+      "totalRejectedPaths": 2
+    },
+    {
+      "taskId": "euler_quadratic_break",
+      "mode": "baseline",
+      "repeat": 1,
+      "verdict": "pass",
+      "finalAgentMessage": "Let’s check \\( f(n) = n^2 + n + 41 \\) for small \\( n \\):\n\n- \\( n = 0 \\): \\( f(0) = 41 \\) (prime)  \n- \\( n = 1 \\): \\( f(1) = 1 + 1 + 41 = 43 \\) (prime)  \n- \\( n = 2 \\): \\( f(2) = 4 + 2 + 41 = 47 \\) (prime)  \n- \\( n = 3 \\): \\( f(3) = 9 + 3 + 41 = 53 \\) (prime)  \n- \\( n = 4 \\): \\( f(4) = 16 + 4 + 41 = 61 \\) (prime)  \n- \\( n = 5 \\): \\( f(5) = 25 + 5 + 41 = 71 \\) (prime)  \n- \\( n = 6 \\): \\( f(6) = 36 + 6 + 41 = 83 \\) (prime)  \n- \\( n = 7 \\): \\( f(7) = 49 + 7 + 41 = 97 \\) (prime)  \n- \\( n = 8 \\): \\( f(8) = 64 + 8 + 41 = 113 \\) (prime)  \n- \\( n = 9 \\): \\( f(9) = 81 + 9 + 41 = 131 \\) (prime)  \n- \\( n = 10 \\): \\( f(10) = 100 + 10 + 41 = 151 \\) (prime)  \n\nWe can keep going, but the first known counterexample for this famous Euler polynomial is \\( n = 40 \\), because  \n\\[\nf(40) = 40^2 + 40 + 41 = 1600 + 40 + 41 = 1681.\n\\]  \nCheck if \\( 1681 \\) is prime:  \n\\( 1681 = 41^2 \\) (since \\( 41 \\times 41 = 1681 \\)), so it’s composite.\n\nBut wait — let’s check if there’s a smaller \\( n \\) where \\( f(n) \\) is composite.  \nWe can test \\( n = 41 \\):  \n\\( f(41) = 41^2 + 41 + 41 = 1681 + 82 = 1763 \\), which is \\( 41 \\times 43 \\) (since \\( 1763/41 = 43 \\)), so composite. But \\( n = 41 \\) is larger than \\( n = 40 \\).\n\nCheck \\( n = 39 \\): \\( f(39) = 1521 + 39 + 41 = 1601 \\). Test divisibility: not divisible by primes up to \\( \\sqrt{1601} \\approx 40 \\), seems prime.  \n\nCheck \\( n = 40 \\) is indeed the first composite? Let’s check \\( n = 1 \\) to \\( 39 \\) quickly for a smaller counterexample:  \nWe can note \\( f(n) = n(n+1) + 41 \\). If \\( 41 \\mid f(n) \\), then \\( 41 \\mid n(n+1) \\).  \nThat happens when \\( n \\equiv 0 \\pmod{41} \\) or \\( n \\equiv 40 \\pmod{41} \\).  \nThe smallest positive such \\( n \\) is \\( n = 40 \\) (since \\( n=41 \\) is larger).  \nSo for \\( n = 40 \\), \\( f(40) = 40 \\times 41 + 41 = 41 \\times 41 \\) is composite.  \n\nCheck \\( n = 0 \\) to \\( 39 \\): no multiple of 41 except \\( n=0 \\) (which gives 41, prime). So \\( n=40 \\) is indeed the first nonnegative integer where \\( f(n) \\) is composite.\n\nThus smallest \\( n \\) is \\( 40 \\), \\( f(40) = 1681 = 41^2 \\).\n\n**Answer:** 40",
+      "turns": 1,
+      "cacheHitRatio": 0,
+      "costUsd": 0.00098535,
+      "claudeEquivalentUsd": 0.013365,
+      "harvestedTurns": 0,
+      "totalSubgoals": 0,
+      "totalUncertainties": 0,
+      "totalHypotheses": 0,
+      "totalRejectedPaths": 0
+    },
+    {
+      "taskId": "euler_quadratic_break",
+      "mode": "reasoner",
+      "repeat": 1,
+      "verdict": "pass",
+      "finalAgentMessage": "The smallest nonnegative integer \\(n\\) for which \\(f(n) = n^2 + n + 41\\) is composite is \\(n = 40\\). At this value, \\(f(40) = 40^2 + 40 + 41 = 1681 = 41^2\\), which is not prime.\n\nAnswer: 40",
+      "turns": 1,
+      "cacheHitRatio": 0.6095238095238096,
+      "costUsd": 0.0014309199999999998,
+      "claudeEquivalentUsd": 0.0099,
+      "harvestedTurns": 0,
+      "totalSubgoals": 0,
+      "totalUncertainties": 0,
+      "totalHypotheses": 0,
+      "totalRejectedPaths": 0
+    },
+    {
+      "taskId": "euler_quadratic_break",
+      "mode": "reasoner-harvest",
+      "repeat": 1,
+      "verdict": "pass",
+      "finalAgentMessage": "The polynomial \\(f(n) = n^2 + n + 41\\) is known to produce primes for \\(n = 0, 1, 2, \\dots, 39\\). At \\(n = 40\\), we have \\(f(40) = 40^2 + 40 + 41 = 1681\\), and \\(1681 = 41^2\\), which is composite. Therefore, \\(n = 40\\) is the smallest nonnegative integer where \\(f(n)\\) fails to be prime.\n\nAnswer: 40",
+      "turns": 1,
+      "cacheHitRatio": 0.6095238095238096,
+      "costUsd": 0.0025938099999999998,
+      "claudeEquivalentUsd": 0.017865,
+      "harvestedTurns": 1,
+      "totalSubgoals": 3,
+      "totalUncertainties": 2,
+      "totalHypotheses": 3,
+      "totalRejectedPaths": 2
+    }
+  ]
+}

benchmarks/harvest/runner.ts

@@ -0,0 +1,312 @@
+/**
+ * Harvest-bench runner.
+ *
+ * Usage:
+ *   npx tsx benchmarks/harvest/runner.ts                      # all tasks, all modes, 1 repeat
+ *   npx tsx benchmarks/harvest/runner.ts --task mod7_list
+ *   npx tsx benchmarks/harvest/runner.ts --mode reasoner-harvest --repeats 3
+ *   npx tsx benchmarks/harvest/runner.ts --transcripts-dir transcripts/
+ *   npx tsx benchmarks/harvest/runner.ts --dry                # smoke test wiring, no API
+ *
+ * Writes results.json. Render report.md with `report.ts`.
+ */
+
+import { type WriteStream, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+import {
+  CacheFirstLoop,
+  DeepSeekClient,
+  ImmutablePrefix,
+  claudeEquivalentCost,
+  loadDotenv,
+} from "../../src/index.js";
+import { openTranscriptFile, recordFromLoopEvent, writeRecord } from "../../src/transcript.js";
+import { TASKS } from "./tasks.js";
+import type {
+  HarvestBenchMeta,
+  HarvestBenchReport,
+  HarvestMode,
+  HarvestRunResult,
+  HarvestTask,
+} from "./types.js";
+import { ALL_MODES } from "./types.js";
+
+loadDotenv();
+
+interface CliArgs {
+  taskFilter: string | null;
+  modes: HarvestMode[];
+  repeats: number;
+  outPath: string | null;
+  transcriptsDir: string | null;
+  /** Per-HTTP-call timeout in ms. Default 300_000 (5 min) — reasoner + harvest runs legitimately need this. */
+  timeoutMs: number;
+  dry: boolean;
+  verbose: boolean;
+}
+
+function parseArgs(argv: string[]): CliArgs {
+  const out: CliArgs = {
+    taskFilter: null,
+    modes: [...ALL_MODES],
+    repeats: 1,
+    outPath: null,
+    transcriptsDir: null,
+    timeoutMs: 300_000,
+    dry: false,
+    verbose: false,
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--task") out.taskFilter = argv[++i] ?? null;
+    else if (a === "--mode") {
+      const v = (argv[++i] ?? "").toLowerCase() as HarvestMode;
+      if ((ALL_MODES as string[]).includes(v)) out.modes = [v];
+    } else if (a === "--repeats") out.repeats = Number.parseInt(argv[++i] ?? "1", 10);
+    else if (a === "--out") out.outPath = argv[++i] ?? null;
+    else if (a === "--transcripts-dir") out.transcriptsDir = argv[++i] ?? null;
+    else if (a === "--timeout") {
+      // Accept seconds for humans, convert to ms internally.
+      const secs = Number.parseInt(argv[++i] ?? "300", 10);
+      if (Number.isFinite(secs) && secs > 0) out.timeoutMs = secs * 1000;
+    } else if (a === "--dry") out.dry = true;
+    else if (a === "--verbose" || a === "-v") out.verbose = true;
+  }
+  return out;
+}
+
+// ---------- model resolution ----------
+
+function modelForMode(mode: HarvestMode): string {
+  if (mode === "baseline") return "deepseek-chat";
+  return "deepseek-reasoner";
+}
+
+function harvestForMode(mode: HarvestMode): boolean {
+  return mode === "reasoner-harvest";
+}
+
+// ---------- run one task in one mode ----------
+
+async function runOnce(
+  task: HarvestTask,
+  mode: HarvestMode,
+  rep: number,
+  client: DeepSeekClient,
+  transcriptStream: WriteStream | null,
+): Promise<HarvestRunResult> {
+  const model = modelForMode(mode);
+  const harvest = harvestForMode(mode);
+
+  const prefix = new ImmutablePrefix({ system: task.systemPrompt });
+  const loop = new CacheFirstLoop({
+    client,
+    prefix,
+    model,
+    harvest,
+    stream: false,
+  });
+  const prefixHash = prefix.fingerprint;
+
+  let harvestedTurns = 0;
+  let totalSubgoals = 0;
+  let totalUncertainties = 0;
+  let totalHypotheses = 0;
+  let totalRejectedPaths = 0;
+  let finalText = "";
+  let errorMessage: string | undefined;
+
+  if (transcriptStream) {
+    writeRecord(transcriptStream, {
+      ts: new Date().toISOString(),
+      turn: 1,
+      role: "user",
+      content: task.prompt,
+    });
+  }
+
+  try {
+    for await (const ev of loop.step(task.prompt)) {
+      if (transcriptStream && ev.role !== "assistant_delta") {
+        writeRecord(transcriptStream, recordFromLoopEvent(ev, { model, prefixHash }));
+      }
+      if (ev.role === "assistant_final") {
+        finalText = ev.content;
+        if (ev.planState) {
+          if (
+            ev.planState.subgoals.length +
+              ev.planState.hypotheses.length +
+              ev.planState.uncertainties.length +
+              ev.planState.rejectedPaths.length >
+            0
+          ) {
+            harvestedTurns++;
+            totalSubgoals += ev.planState.subgoals.length;
+            totalHypotheses += ev.planState.hypotheses.length;
+            totalUncertainties += ev.planState.uncertainties.length;
+            totalRejectedPaths += ev.planState.rejectedPaths.length;
+          }
+        }
+      } else if (ev.role === "done") {
+        finalText = ev.content || finalText;
+        break;
+      } else if (ev.role === "error") {
+        throw new Error(ev.error ?? "loop error");
+      }
+    }
+  } catch (err) {
+    errorMessage = (err as Error).message;
+  }
+
+  const verdict = errorMessage ? { verdict: "fail" as const, note: errorMessage } : task.check(finalText);
+
+  return {
+    taskId: task.id,
+    mode,
+    repeat: rep + 1,
+    verdict: verdict.verdict,
+    checkNote: verdict.note,
+    finalAgentMessage: finalText,
+    turns: loop.stats.turns.length,
+    cacheHitRatio: loop.stats.aggregateCacheHitRatio,
+    costUsd: loop.stats.totalCost,
+    claudeEquivalentUsd: loop.stats.turns.reduce((s, t) => s + claudeEquivalentCost(t.usage), 0),
+    harvestedTurns,
+    totalSubgoals,
+    totalUncertainties,
+    totalHypotheses,
+    totalRejectedPaths,
+    errorMessage,
+  };
+}
+
+// ---------- dry mode ----------
+
+function runDry(args: CliArgs): HarvestBenchReport {
+  const tasks = filterTasks(args.taskFilter);
+  const results: HarvestRunResult[] = [];
+  for (const task of tasks) {
+    // Exercise each checker with a deliberately wrong reply so we know
+    // the wiring is live — not a pass on empty.
+    const sanity = task.check("Answer: this is not the right answer at all");
+    console.log(`[${task.id}] checker exercises ok (sanity verdict=${sanity.verdict})`);
+    for (const mode of args.modes) {
+      results.push({
+        taskId: task.id,
+        mode,
+        repeat: 1,
+        verdict: "inconclusive",
+        checkNote: "dry-run (no model call)",
+        finalAgentMessage: "[dry-run]",
+        turns: 0,
+        cacheHitRatio: 0,
+        costUsd: 0,
+        claudeEquivalentUsd: 0,
+        harvestedTurns: 0,
+        totalSubgoals: 0,
+        totalUncertainties: 0,
+        totalHypotheses: 0,
+        totalRejectedPaths: 0,
+      });
+    }
+  }
+  return { meta: buildMeta(args, tasks.length), results };
+}
+
+// ---------- main ----------
+
+function filterTasks(filter: string | null): HarvestTask[] {
+  if (!filter) return TASKS;
+  const t = TASKS.find((x) => x.id === filter);
+  if (!t) throw new Error(`unknown task: ${filter}`);
+  return [t];
+}
+
+function buildMeta(args: CliArgs, taskCount: number): HarvestBenchMeta {
+  return {
+    date: new Date().toISOString(),
+    repeatsPerTask: args.repeats,
+    taskCount,
+    modesRun: args.modes,
+    reasonixVersion: "0.2.2",
+  };
+}
+
+async function main(): Promise<void> {
+  const args = parseArgs(process.argv.slice(2));
+
+  if (args.dry) {
+    const report = runDry(args);
+    writeReport(report, args.outPath);
+    return;
+  }
+
+  const client = new DeepSeekClient({ timeoutMs: args.timeoutMs });
+  const tasks = filterTasks(args.taskFilter);
+
+  if (args.transcriptsDir) mkdirSync(args.transcriptsDir, { recursive: true });
+
+  const results: HarvestRunResult[] = [];
+  for (const task of tasks) {
+    for (let rep = 0; rep < args.repeats; rep++) {
+      for (const mode of args.modes) {
+        let stream: WriteStream | null = null;
+        if (args.transcriptsDir) {
+          const fname = `${task.id}.${mode}.r${rep + 1}.jsonl`;
+          stream = openTranscriptFile(join(args.transcriptsDir, fname), {
+            version: 1,
+            source: `harvest-bench/${mode}`,
+            model: modelForMode(mode),
+            task: task.id,
+            mode,
+            repeat: rep + 1,
+            startedAt: new Date().toISOString(),
+          });
+        }
+        const started = Date.now();
+        let result: HarvestRunResult;
+        try {
+          result = await runOnce(task, mode, rep, client, stream);
+        } finally {
+          stream?.end();
+        }
+        const elapsed = ((Date.now() - started) / 1000).toFixed(1);
+        console.log(
+          `[${task.id}/${mode}/r${rep + 1}] verdict=${result.verdict}` +
+            ` cache=${(result.cacheHitRatio * 100).toFixed(1)}%` +
+            ` cost=$${result.costUsd.toFixed(6)}` +
+            ` harvest=${result.harvestedTurns}:${result.totalSubgoals}s/${result.totalUncertainties}u` +
+            ` (${elapsed}s)` +
+            (result.checkNote ? `  ${result.checkNote}` : ""),
+        );
+        results.push(result);
+      }
+    }
+  }
+
+  const report: HarvestBenchReport = { meta: buildMeta(args, tasks.length), results };
+  writeReport(report, args.outPath);
+}
+
+function writeReport(report: HarvestBenchReport, outPath: string | null): void {
+  const path =
+    outPath ?? `benchmarks/harvest/results-${new Date().toISOString().replace(/[:.]/g, "-")}.json`;
+  writeFileSync(path, `${JSON.stringify(report, null, 2)}\n`, "utf8");
+  console.log(`wrote ${path}`);
+}
+
+function isMain(): boolean {
+  const entry = process.argv[1];
+  if (!entry) return false;
+  return import.meta.url === pathToFileURL(entry).href;
+}
+
+if (isMain()) {
+  main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+  });
+}
+
+export { main as runHarvestBench };

benchmarks/harvest/tasks.ts

@@ -0,0 +1,171 @@
+/**
+ * Seed reasoning tasks for the harvest eval harness.
+ *
+ * Each task has:
+ *   - a minimal system prompt (so the comparison is about the model, not
+ *     the prompt)
+ *   - a single user question
+ *   - a deterministic checker (regex + set/value compare)
+ *
+ * When adding a new task, prefer problems where:
+ *   - the answer has a clean shape (a number, a small set, a yes/no +
+ *     explanation) — easier to check
+ *   - reasoning actually matters (so harvest has signal to extract);
+ *     trivia questions are out of scope
+ *   - there's a known-good answer; judgment calls are out of scope
+ */
+
+import type { HarvestTask } from "./types.js";
+
+const CONCISE_SYSTEM = `You are a precise reasoner. Think carefully, then state your final answer on a clearly-labeled line starting with "Answer:".`;
+
+/**
+ * Parse all non-negative integers out of a string. Handles commas,
+ * ranges written as "2-4" (expands to 2,3,4), and ignores numbers that
+ * look like formula references (e.g. "n^2", "mod 7") by only accepting
+ * integers after we strip common LaTeX decorations.
+ */
+function extractIntegers(text: string): number[] {
+  // Strip LaTeX delimiters so n_1 / n^2 / \{ ... \} don't confuse us.
+  const cleaned = text
+    .replace(/\\[a-zA-Z]+/g, " ") // \frac, \mod etc.
+    .replace(/[{}\\]/g, " ")
+    .replace(/[_^]\d+/g, " "); // subscript/superscript numbers
+  // Expand ranges: "2-4" → "2,3,4" (only for small gaps)
+  const rangeExpanded = cleaned.replace(/(\d+)\s*[-–]\s*(\d+)/g, (_, a, b) => {
+    const lo = Number.parseInt(a, 10);
+    const hi = Number.parseInt(b, 10);
+    if (!Number.isFinite(lo) || !Number.isFinite(hi) || hi - lo > 50) return `${a} ${b}`;
+    const out: number[] = [];
+    for (let i = Math.min(lo, hi); i <= Math.max(lo, hi); i++) out.push(i);
+    return out.join(" ");
+  });
+  const matches = rangeExpanded.match(/-?\d+/g) ?? [];
+  return matches.map((m) => Number.parseInt(m, 10)).filter((n) => Number.isFinite(n));
+}
+
+/** Extract content after the last "Answer:" label (case-insensitive). */
+function extractAnswerLine(text: string): string {
+  const matches = [...text.matchAll(/answer\s*[:：]\s*([^\n]+)/gi)];
+  if (matches.length === 0) return text;
+  return matches[matches.length - 1]![1]!.trim();
+}
+
+// ---------- expected answers ----------
+
+/** Positive n ≤ 100 such that n^2 + n + 1 ≡ 0 (mod 7). */
+const MOD7_EXPECTED: number[] = (() => {
+  const out: number[] = [];
+  for (let n = 1; n <= 100; n++) {
+    if ((n * n + n + 1) % 7 === 0) out.push(n);
+  }
+  return out;
+})();
+
+/**
+ * Single-integer checker. Pulls the first plausible integer from the last
+ * "Answer:" line; compares for exact equality.
+ */
+function checkSingleInt(expected: number) {
+  return (reply: string) => {
+    const answerLine = extractAnswerLine(reply);
+    const nums = extractIntegers(answerLine);
+    if (nums.length === 0) return { verdict: "fail" as const, note: "no number in Answer line" };
+    const n = nums[0]!;
+    if (n === expected) return { verdict: "pass" as const };
+    return { verdict: "fail" as const, note: `got ${n}, expected ${expected}` };
+  };
+}
+
+// ---------- tasks ----------
+
+export const TASKS: HarvestTask[] = [
+  {
+    id: "mod7_list",
+    description:
+      "Number theory — find all positive n ≤ 100 with n^2+n+1 ≡ 0 (mod 7). 29-element set. Classic R1 scratch-work territory.",
+    systemPrompt: CONCISE_SYSTEM,
+    prompt:
+      "Find all positive integers n with n ≤ 100 such that n^2 + n + 1 is divisible by 7. Briefly justify, then end with the full list on a line starting with \"Answer:\".",
+    check: (reply) => {
+      const answerLine = extractAnswerLine(reply);
+      const found = new Set(extractIntegers(answerLine).filter((n) => n >= 1 && n <= 100));
+      const expected = new Set(MOD7_EXPECTED);
+      if (found.size === 0) {
+        return { verdict: "fail", note: "no integers extracted from Answer line" };
+      }
+      // Exact set equality — both containment directions.
+      for (const n of expected) if (!found.has(n)) return { verdict: "fail", note: `missing n=${n}` };
+      for (const n of found) if (!expected.has(n)) return { verdict: "fail", note: `extra n=${n}` };
+      return { verdict: "pass" };
+    },
+  },
+
+  {
+    id: "flips_until_3heads",
+    description:
+      "Probability — expected coin flips until 3 consecutive heads. Answer: 14. Tests whether R1 derives via recurrence or via memorized result.",
+    systemPrompt: CONCISE_SYSTEM,
+    prompt:
+      "A fair coin is flipped repeatedly until you see 3 heads in a row. What is the expected number of total flips? Give a single integer on a line starting with \"Answer:\".",
+    check: (reply) => {
+      const answerLine = extractAnswerLine(reply);
+      const nums = extractIntegers(answerLine);
+      if (nums.length === 0) return { verdict: "fail", note: "no number in Answer line" };
+      // Accept the first sensible number — sometimes agents write "Answer: 14 flips".
+      const n = nums[0]!;
+      if (n === 14) return { verdict: "pass" };
+      return { verdict: "fail", note: `got ${n}, expected 14` };
+    },
+  },
+
+  {
+    id: "three_hats",
+    description:
+      "Logic — three people wear red/blue hats, at least one red, they're asked in order. First two say no, third says yes. What color? Answer: red (deducible because if third were blue, the first two could see one red + one unknown and wouldn't have said no on their full first round, for most configurations the third can only be certain if red).",
+    systemPrompt: CONCISE_SYSTEM,
+    prompt:
+      'Three people wear hats that are each red or blue. They are told at least one hat is red. Each can see the other two hats but not their own. They are asked in order: "Do you know your hat color?" The first two answer no. The third answers yes. What color is the third person\'s hat? Give a one-word answer on a line starting with "Answer:".',
+    check: (reply) => {
+      const answerLine = extractAnswerLine(reply).toLowerCase();
+      // Accept "red" as a standalone word (not "redirected" etc).
+      if (/\bred\b/.test(answerLine) && !/\bblue\b/.test(answerLine)) {
+        return { verdict: "pass" };
+      }
+      if (/\bblue\b/.test(answerLine)) return { verdict: "fail", note: "answered blue" };
+      return { verdict: "fail", note: "no clear color in Answer line" };
+    },
+  },
+
+  // ---------- hard tasks (picked for known V3 failure modes) ----------
+
+  {
+    id: "pseudoprime_base2",
+    description:
+      "Number theory — smallest composite n > 1 such that 2^n ≡ 2 (mod n). This is the smallest Fermat pseudoprime to base 2. Answer: 341 (= 11·31). V3 frequently answers 561 (Carmichael / wrong base-2 property) or 9 (not actually a pseudoprime to base 2, verifying the model isn't computing). R1 usually gets this right.",
+    systemPrompt: CONCISE_SYSTEM,
+    prompt:
+      'Find the smallest composite integer n > 1 such that 2^n is congruent to 2 modulo n (i.e., n is a Fermat pseudoprime to base 2). Briefly justify, then give a single integer on a line starting with "Answer:".',
+    check: checkSingleInt(341),
+  },
+
+  {
+    id: "derangements_d7",
+    description:
+      "Combinatorics — number of derangements of 7 elements. Answer: 1854 (D_7 = 7! · (1 − 1/1! + 1/2! − 1/3! + … ± 1/7!) = 5040 · 0.367857… = 1854). V3 sometimes approximates via n!/e and rounds wrong, or confuses with D_6=265 or D_8=14833. R1's explicit recurrence D_n = (n-1)(D_{n-1}+D_{n-2}) avoids the mistake.",
+    systemPrompt: CONCISE_SYSTEM,
+    prompt:
+      'How many permutations of {1, 2, 3, 4, 5, 6, 7} have no fixed points? (This is D_7, the derangement number.) Briefly justify, then give a single integer on a line starting with "Answer:".',
+    check: checkSingleInt(1854),
+  },
+
+  {
+    id: "euler_quadratic_break",
+    description:
+      "Number theory — smallest nonneg integer n where n^2 + n + 41 is NOT prime. Euler's prime-generating polynomial famously produces primes for n = 0..39 and first fails at n = 40 (40²+40+41 = 1681 = 41²). V3 often confuses this with the related n²-n+41 (first fails at 41) or cites the wrong threshold. R1 checks small n systematically.",
+    systemPrompt: CONCISE_SYSTEM,
+    prompt:
+      'Consider the polynomial f(n) = n^2 + n + 41 for n = 0, 1, 2, …. What is the smallest nonneg integer n at which f(n) fails to be prime? Briefly justify (including the value of f(n) at that point), then give just the integer n on a line starting with "Answer:".',
+    check: checkSingleInt(40),
+  },
+];

benchmarks/harvest/types.ts

@@ -0,0 +1,82 @@
+/**
+ * Types for the harvest eval harness.
+ *
+ * Scope: this is deliberately NOT τ-bench-lite. These tasks:
+ *   - are single-turn Q/A (no user simulator, no DB)
+ *   - target reasoning-heavy problems (math, logic, planning)
+ *   - use deterministic checkers (regex extraction + set/value compare),
+ *     never an LLM judge
+ *
+ * The point is to measure Pillar 2 (harvest) the same way τ-bench-lite
+ * measures Pillar 1 (cache-first): isolate one variable, produce numbers
+ * anyone can reproduce.
+ */
+
+export type HarvestMode =
+  /** deepseek-chat, no Reasonix tricks. Floor reference for answer quality on reasoning tasks (V3 at its best). */
+  | "baseline"
+  /** deepseek-reasoner, no harvest. Isolates "does reasoner help over chat on these problems?" */
+  | "reasoner"
+  /** deepseek-reasoner + harvest. Isolates "does the extra V3 harvest call add quality / change behavior?" */
+  | "reasoner-harvest";
+
+export const ALL_MODES: HarvestMode[] = ["baseline", "reasoner", "reasoner-harvest"];
+
+/**
+ * Checker verdict. We don't use boolean directly because "maybe" is real
+ * — e.g. "answer in the right shape but can't verify without running the
+ * program". For v0.3 we only use {pass, fail}, but the shape leaves room.
+ */
+export type CheckVerdict = "pass" | "fail" | "inconclusive";
+
+export interface HarvestTask {
+  id: string;
+  /** One-line human description, not shown to the model. */
+  description: string;
+  /** System prompt. Kept minimal so harvest signal can be attributed to the model, not to prompt engineering. */
+  systemPrompt: string;
+  /** The single question. */
+  prompt: string;
+  /**
+   * Check the agent's final reply. Returns pass/fail/inconclusive plus an
+   * optional one-line explanation the report can surface.
+   *
+   * IMPORTANT: must be pure and deterministic. No LLM calls, no file I/O.
+   */
+  check: (agentReply: string) => { verdict: CheckVerdict; note?: string };
+}
+
+export interface HarvestRunResult {
+  taskId: string;
+  mode: HarvestMode;
+  repeat: number;
+  verdict: CheckVerdict;
+  checkNote?: string;
+  finalAgentMessage: string;
+  /** Turns the loop completed (usually 1 for a single-shot Q/A, > 1 if tool-calls happen). */
+  turns: number;
+  cacheHitRatio: number;
+  costUsd: number;
+  claudeEquivalentUsd: number;
+  /** Harvest-specific — only non-zero on reasoner-harvest mode. */
+  harvestedTurns: number;
+  totalSubgoals: number;
+  totalUncertainties: number;
+  totalHypotheses: number;
+  totalRejectedPaths: number;
+  /** Optional error message if the run crashed (model down, timeout, etc). */
+  errorMessage?: string;
+}
+
+export interface HarvestBenchMeta {
+  date: string;
+  repeatsPerTask: number;
+  taskCount: number;
+  modesRun: HarvestMode[];
+  reasonixVersion: string;
+}
+
+export interface HarvestBenchReport {
+  meta: HarvestBenchMeta;
+  results: HarvestRunResult[];
+}

benchmarks/tau-bench/transcripts/README.md

@@ -11,6 +11,9 @@ verify the cache-hit / cost claims *without running the bench*.
 | `t01_address_happy.baseline.r1.jsonl` | Naive cache-hostile agent's record of the run |
 | `t01_address_happy.reasonix.r1.jsonl` | Reasonix's record of the same task |
 | `t01_address_happy.diff.md` | Output of `reasonix diff` on the two above |
+| `mcp-demo.add.jsonl` | End-to-end run through the bundled demo MCP server. DeepSeek called the `add` tool; the second turn hit 96.6% cache, 94% cheaper than Claude at same token counts |
+| `mcp-filesystem.jsonl` | End-to-end run through the **official external** `@modelcontextprotocol/server-filesystem`. 5 turns, 4 tool calls including a permission-denied recovery. Overall cache 96.7%, 97% cheaper than Claude. Proof that Cache-First generalizes to third-party MCP servers without any code change on our side |
+| `mcp-multi-server.jsonl` | End-to-end run with **two MCP servers concurrently** — bundled demo (`demo_add`) + official `@modelcontextprotocol/server-filesystem` (`fs_write_file`). Model computed 17+25 on one server, wrote the result to a real file via the other. 5 turns, 4 tool calls across two subprocesses. **1 distinct prefix hash** held across all turns — Cache-First byte-stability survives running two MCP servers at once. Cache 81.1%, cost $0.00185, 95.9% cheaper than Claude |
 
 ## Verify for yourself
 

benchmarks/tau-bench/transcripts/mcp-demo.add.jsonl

@@ -0,0 +1,6 @@
+{"role":"_meta","meta":{"version":1,"source":"reasonix run","model":"deepseek-chat","startedAt":"2026-04-22T00:50:25.468Z"}}
+{"ts":"2026-04-22T00:50:25.469Z","turn":1,"role":"user","content":"Use the add tool to compute 17+25, then briefly confirm the result."}
+{"ts":"2026-04-22T00:50:28.556Z","turn":1,"role":"assistant_final","content":"I'll compute 17 + 25 using the add tool.","usage":{"prompt_tokens":442,"completion_tokens":70,"total_tokens":512,"prompt_cache_hit_tokens":0,"prompt_cache_miss_tokens":442},"cost":0.00019634,"model":"deepseek-chat","prefixHash":"585d4a0a16fe84b7"}
+{"ts":"2026-04-22T00:50:28.557Z","turn":1,"role":"tool","content":"42","tool":"add","args":"{\"a\": 17, \"b\": 25}"}
+{"ts":"2026-04-22T00:50:29.858Z","turn":1,"role":"assistant_final","content":"The result is 42. 17 + 25 = 42.","usage":{"prompt_tokens":530,"completion_tokens":15,"total_tokens":545,"prompt_cache_hit_tokens":512,"prompt_cache_miss_tokens":18},"cost":0.0000572,"model":"deepseek-chat","prefixHash":"585d4a0a16fe84b7"}
+{"ts":"2026-04-22T00:50:29.858Z","turn":1,"role":"done","content":"The result is 42. 17 + 25 = 42."}

benchmarks/tau-bench/transcripts/mcp-filesystem.jsonl

@@ -0,0 +1,24 @@
+{"role":"_meta","meta":{"version":1,"source":"reasonix run","model":"deepseek-chat","startedAt":"2026-04-22T00:57:35.368Z"}}
+{"ts":"2026-04-22T00:57:35.369Z","turn":1,"role":"user","content":"List the files here, then read README.md and summarize it in one sentence."}
+{"ts":"2026-04-22T00:57:38.133Z","turn":1,"role":"assistant_final","content":"I'll start by listing the files in the current directory, then read the README.md file and summarize it.","usage":{"prompt_tokens":2218,"completion_tokens":64,"total_tokens":2282,"prompt_cache_hit_tokens":256,"prompt_cache_miss_tokens":1962},"cost":0.0006180599999999999,"model":"deepseek-chat","prefixHash":"6a7fff6a15fd5def"}
+{"ts":"2026-04-22T00:57:38.136Z","turn":1,"role":"tool","content":"ERROR: Access denied - path outside allowed directories: F:\\Reasonix not in C:\\Users\\yuhuahui\\AppData\\Local\\Temp\\mcp-fs-demo","tool":"list_directory","args":"{\"path\": \".\"}"}
+{"ts":"2026-04-22T00:57:40.282Z","turn":1,"role":"assistant_final","content":"Let me first check what directories are allowed:","usage":{"prompt_tokens":2337,"completion_tokens":39,"total_tokens":2376,"prompt_cache_hit_tokens":2240,"prompt_cache_miss_tokens":97},"cost":0.00022589000000000002,"model":"deepseek-chat","prefixHash":"6a7fff6a15fd5def"}
+{"ts":"2026-04-22T00:57:40.285Z","turn":1,"role":"tool","content":"Allowed directories:\nC:\\Users\\yuhuahui\\AppData\\Local\\Temp\\mcp-fs-demo","tool":"list_allowed_directories","args":"{}"}
+{"ts":"2026-04-22T00:57:43.982Z","turn":1,"role":"assistant_final","content":"Now let me list the files in the allowed directory:","usage":{"prompt_tokens":2418,"completion_tokens":74,"total_tokens":2492,"prompt_cache_hit_tokens":2304,"prompt_cache_miss_tokens":114},"cost":0.00027346000000000006,"model":"deepseek-chat","prefixHash":"6a7fff6a15fd5def"}
+{"ts":"2026-04-22T00:57:43.983Z","turn":1,"role":"tool","content":"[FILE] a.txt\n[FILE] b.txt\n[FILE] README.md","tool":"list_directory","args":"{\"path\": \"C:\\\\Users\\\\yuhuahui\\\\AppData\\\\Local\\\\Temp\\\\mcp-fs-demo\"}"}
+{"ts":"2026-04-22T00:57:47.317Z","turn":1,"role":"assistant_final","content":"Now let me read the README.md file:","usage":{"prompt_tokens":2526,"completion_tokens":77,"total_tokens":2603,"prompt_cache_hit_tokens":2432,"prompt_cache_miss_tokens":94},"cost":0.00028031999999999997,"model":"deepseek-chat","prefixHash":"6a7fff6a15fd5def"}
+{"ts":"2026-04-22T00:57:47.322Z","turn":1,"role":"tool","content":"# Sample","tool":"read_text_file","args":"{\"path\": \"C:\\\\Users\\\\yuhuahui\\\\AppData\\\\Local\\\\Temp\\\\mcp-fs-demo\\\\README.md\"}"}
+{"ts":"2026-04-22T00:57:49.096Z","turn":1,"role":"assistant_final","content":"**Summary:** The directory contains three files (a.txt, b.txt, and README.md), and the README.md file simply contains the word \"Sample\".","usage":{"prompt_tokens":2622,"completion_tokens":33,"total_tokens":2655,"prompt_cache_hit_tokens":2560,"prompt_cache_miss_tokens":62},"cost":0.00023224000000000004,"model":"deepseek-chat","prefixHash":"6a7fff6a15fd5def"}
+{"ts":"2026-04-22T00:57:49.096Z","turn":1,"role":"done","content":"**Summary:** The directory contains three files (a.txt, b.txt, and README.md), and the README.md file simply contains the word \"Sample\"."}
+{"role":"_meta","meta":{"version":1,"source":"reasonix run","model":"deepseek-chat","startedAt":"2026-04-22T01:00:29.520Z"}}
+{"ts":"2026-04-22T01:00:29.521Z","turn":1,"role":"user","content":"List the files here, then read README.md and summarize it in one sentence."}
+{"ts":"2026-04-22T01:00:32.502Z","turn":1,"role":"assistant_final","content":"I'll start by listing the files in the current directory and then read the README.md file.","usage":{"prompt_tokens":2218,"completion_tokens":61,"total_tokens":2279,"prompt_cache_hit_tokens":2176,"prompt_cache_miss_tokens":42},"cost":0.00023076000000000005,"model":"deepseek-chat","prefixHash":"6a7fff6a15fd5def"}
+{"ts":"2026-04-22T01:00:32.505Z","turn":1,"role":"tool","content":"ERROR: Access denied - path outside allowed directories: F:\\Reasonix not in C:\\Users\\yuhuahui\\AppData\\Local\\Temp\\mcp-fs-demo","tool":"list_directory","args":"{\"path\": \".\"}"}
+{"ts":"2026-04-22T01:00:34.833Z","turn":1,"role":"assistant_final","content":"Let me first check what directories are allowed:","usage":{"prompt_tokens":2334,"completion_tokens":39,"total_tokens":2373,"prompt_cache_hit_tokens":2240,"prompt_cache_miss_tokens":94},"cost":0.00022508,"model":"deepseek-chat","prefixHash":"6a7fff6a15fd5def"}
+{"ts":"2026-04-22T01:00:34.834Z","turn":1,"role":"tool","content":"Allowed directories:\nC:\\Users\\yuhuahui\\AppData\\Local\\Temp\\mcp-fs-demo","tool":"list_allowed_directories","args":"{}"}
+{"ts":"2026-04-22T01:00:38.039Z","turn":1,"role":"assistant_final","content":"Now let me list the files in the allowed directory:","usage":{"prompt_tokens":2415,"completion_tokens":74,"total_tokens":2489,"prompt_cache_hit_tokens":2304,"prompt_cache_miss_tokens":111},"cost":0.00027265000000000004,"model":"deepseek-chat","prefixHash":"6a7fff6a15fd5def"}
+{"ts":"2026-04-22T01:00:38.042Z","turn":1,"role":"tool","content":"[FILE] a.txt\n[FILE] b.txt\n[FILE] README.md","tool":"list_directory","args":"{\"path\": \"C:\\\\Users\\\\yuhuahui\\\\AppData\\\\Local\\\\Temp\\\\mcp-fs-demo\"}"}
+{"ts":"2026-04-22T01:00:41.597Z","turn":1,"role":"assistant_final","content":"Now I'll read the README.md file:","usage":{"prompt_tokens":2523,"completion_tokens":77,"total_tokens":2600,"prompt_cache_hit_tokens":2432,"prompt_cache_miss_tokens":91},"cost":0.00027951,"model":"deepseek-chat","prefixHash":"6a7fff6a15fd5def"}
+{"ts":"2026-04-22T01:00:41.601Z","turn":1,"role":"tool","content":"# Sample","tool":"read_text_file","args":"{\"path\": \"C:\\\\Users\\\\yuhuahui\\\\AppData\\\\Local\\\\Temp\\\\mcp-fs-demo\\\\README.md\"}"}
+{"ts":"2026-04-22T01:00:43.759Z","turn":1,"role":"assistant_final","content":"**Files in the directory:** a.txt, b.txt, README.md\n\n**README.md summary:** This is a sample README file.","usage":{"prompt_tokens":2619,"completion_tokens":29,"total_tokens":2648,"prompt_cache_hit_tokens":2560,"prompt_cache_miss_tokens":59},"cost":0.00022703000000000003,"model":"deepseek-chat","prefixHash":"6a7fff6a15fd5def"}
+{"ts":"2026-04-22T01:00:43.759Z","turn":1,"role":"done","content":"**Files in the directory:** a.txt, b.txt, README.md\n\n**README.md summary:** This is a sample README file."}

benchmarks/tau-bench/transcripts/mcp-multi-server.jsonl

@@ -0,0 +1,12 @@
+{"role":"_meta","meta":{"version":1,"source":"reasonix run","model":"deepseek-chat","startedAt":"2026-04-22T01:39:54.789Z"}}
+{"ts":"2026-04-22T01:39:54.790Z","turn":1,"role":"user","content":"First use the add tool to compute 17+25, then use write_file to save the result to a file called answer.txt in the current working directory."}
+{"ts":"2026-04-22T01:39:58.843Z","turn":1,"role":"assistant_final","content":"I'll help you with that. First, I'll compute 17+25 using the add tool, then write the result to answer.txt.","usage":{"prompt_tokens":2404,"completion_tokens":87,"total_tokens":2491,"prompt_cache_hit_tokens":256,"prompt_cache_miss_tokens":2148},"cost":0.0006935800000000001,"model":"deepseek-chat","prefixHash":"ea71560eab18d572"}
+{"ts":"2026-04-22T01:39:58.844Z","turn":1,"role":"tool","content":"42","tool":"demo_add","args":"{\"a\": 17, \"b\": 25}"}
+{"ts":"2026-04-22T01:40:02.898Z","turn":1,"role":"assistant_final","content":"Now I'll write the result (42) to a file called answer.txt in the current working directory:","usage":{"prompt_tokens":2509,"completion_tokens":81,"total_tokens":2590,"prompt_cache_hit_tokens":2432,"prompt_cache_miss_tokens":77},"cost":0.00028013,"model":"deepseek-chat","prefixHash":"ea71560eab18d572"}
+{"ts":"2026-04-22T01:40:02.900Z","turn":1,"role":"tool","content":"ERROR: Access denied - path outside allowed directories: F:\\Reasonix\\answer.txt not in C:\\Users\\yuhuahui\\AppData\\Local\\Temp\\mcp-fs-demo","tool":"fs_write_file","args":"{\"path\": \"answer.txt\", \"content\": \"42\"}"}
+{"ts":"2026-04-22T01:40:05.263Z","turn":1,"role":"assistant_final","content":"I need to check which directories are allowed first. Let me check the allowed directories:","usage":{"prompt_tokens":2648,"completion_tokens":48,"total_tokens":2696,"prompt_cache_hit_tokens":2560,"prompt_cache_miss_tokens":88},"cost":0.00025576,"model":"deepseek-chat","prefixHash":"ea71560eab18d572"}
+{"ts":"2026-04-22T01:40:05.270Z","turn":1,"role":"tool","content":"Allowed directories:\nC:\\Users\\yuhuahui\\AppData\\Local\\Temp\\mcp-fs-demo","tool":"fs_list_allowed_directories","args":"{}"}
+{"ts":"2026-04-22T01:40:09.422Z","turn":1,"role":"assistant_final","content":"Now I'll write the file to the allowed directory:","usage":{"prompt_tokens":2738,"completion_tokens":94,"total_tokens":2832,"prompt_cache_hit_tokens":2624,"prompt_cache_miss_tokens":114},"cost":0.00031786,"model":"deepseek-chat","prefixHash":"ea71560eab18d572"}
+{"ts":"2026-04-22T01:40:09.426Z","turn":1,"role":"tool","content":"Successfully wrote to C:\\Users\\yuhuahui\\AppData\\Local\\Temp\\mcp-fs-demo\\answer.txt","tool":"fs_write_file","args":"{\"path\": \"C:\\\\Users\\\\yuhuahui\\\\AppData\\\\Local\\\\Temp\\\\mcp-fs-demo\\\\answer.txt\", \"content\": \"42\"}"}
+{"ts":"2026-04-22T01:40:13.689Z","turn":1,"role":"assistant_final","content":"Perfect! I've completed both tasks:\n\n1. **Computed 17+25**: The result is 42\n2. **Saved to answer.txt**: Created the file `answer.txt` in the allowed directory with the content \"42\"\n\nThe file has been successfully written to `C:\\Users\\yuhuahui\\AppData\\Local\\Temp\\mcp-fs-demo\\answer.txt`.","usage":{"prompt_tokens":2878,"completion_tokens":83,"total_tokens":2961,"prompt_cache_hit_tokens":2816,"prompt_cache_miss_tokens":62},"cost":0.00030516,"model":"deepseek-chat","prefixHash":"ea71560eab18d572"}
+{"ts":"2026-04-22T01:40:13.689Z","turn":1,"role":"done","content":"Perfect! I've completed both tasks:\n\n1. **Computed 17+25**: The result is 42\n2. **Saved to answer.txt**: Created the file `answer.txt` in the allowed directory with the content \"42\"\n\nThe file has been successfully written to `C:\\Users\\yuhuahui\\AppData\\Local\\Temp\\mcp-fs-demo\\answer.txt`."}

examples/mcp-server-demo.ts

@@ -0,0 +1,238 @@
+/**
+ * Bundled demo MCP server.
+ *
+ * A minimal stdio MCP server that exposes three tools: echo, add, get_time.
+ * Useful for:
+ *   - running the MCP integration end-to-end without installing
+ *     an external server
+ *   - giving the integration tests a real subprocess to spawn
+ *   - showing the minimal shape of a server for folks writing their own
+ *
+ * Usage:
+ *   npx tsx examples/mcp-server-demo.ts          # speaks MCP on stdin/stdout
+ *   reasonix chat --mcp "npx tsx examples/mcp-server-demo.ts"
+ *
+ * Spec reference: https://spec.modelcontextprotocol.io/ (2024-11-05)
+ * Only the subset this demo needs is implemented — initialize, tools/list,
+ * tools/call, notifications/initialized (no-op).
+ */
+
+import { createInterface } from "node:readline";
+
+const PROTOCOL_VERSION = "2024-11-05";
+
+interface JsonRpcRequest {
+  jsonrpc: "2.0";
+  id?: string | number;
+  method: string;
+  params?: unknown;
+}
+
+interface JsonRpcSuccess {
+  jsonrpc: "2.0";
+  id: string | number;
+  result: unknown;
+}
+
+interface JsonRpcError {
+  jsonrpc: "2.0";
+  id: string | number | null;
+  error: { code: number; message: string; data?: unknown };
+}
+
+const TOOLS = [
+  {
+    name: "echo",
+    description: "Echoes the provided message back.",
+    inputSchema: {
+      type: "object",
+      properties: { msg: { type: "string", description: "What to echo" } },
+      required: ["msg"],
+    },
+  },
+  {
+    name: "add",
+    description: "Adds two integers and returns the sum.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        a: { type: "integer" },
+        b: { type: "integer" },
+      },
+      required: ["a", "b"],
+    },
+  },
+  {
+    name: "get_time",
+    description: "Returns the server's current ISO-8601 timestamp.",
+    inputSchema: { type: "object", properties: {} },
+  },
+  {
+    name: "slow_count",
+    description:
+      "Counts from 1 to n with a ~300 ms pause between steps, emitting notifications/progress frames along the way. Useful for demonstrating Reasonix's progress-bar UI.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        n: { type: "integer", description: "Final number to count to (default 5, max 20)" },
+      },
+    },
+  },
+];
+
+interface JsonRpcNotification {
+  jsonrpc: "2.0";
+  method: string;
+  params?: unknown;
+}
+
+function send(msg: JsonRpcSuccess | JsonRpcError | JsonRpcNotification): void {
+  // Stdio MCP framing: one JSON per line.
+  process.stdout.write(`${JSON.stringify(msg)}\n`);
+}
+
+async function handleRequest(
+  req: JsonRpcRequest,
+): Promise<JsonRpcSuccess | JsonRpcError | null> {
+  const id = req.id ?? null;
+
+  switch (req.method) {
+    case "initialize": {
+      return {
+        jsonrpc: "2.0",
+        id: id ?? 0,
+        result: {
+          protocolVersion: PROTOCOL_VERSION,
+          serverInfo: { name: "reasonix-demo-mcp", version: "0.0.1" },
+          capabilities: { tools: { listChanged: false } },
+        },
+      };
+    }
+
+    case "notifications/initialized":
+      // No response for notifications.
+      return null;
+
+    case "tools/list": {
+      return { jsonrpc: "2.0", id: id ?? 0, result: { tools: TOOLS } };
+    }
+
+    case "tools/call": {
+      const params = (req.params ?? {}) as {
+        name?: string;
+        arguments?: Record<string, unknown>;
+        _meta?: { progressToken?: string | number };
+      };
+      const name = params.name ?? "";
+      const args = params.arguments ?? {};
+      const progressToken = params._meta?.progressToken;
+      const out = await callTool(name, args, progressToken);
+      if (out.error) {
+        return {
+          jsonrpc: "2.0",
+          id: id ?? 0,
+          result: {
+            content: [{ type: "text", text: out.error }],
+            isError: true,
+          },
+        };
+      }
+      return {
+        jsonrpc: "2.0",
+        id: id ?? 0,
+        result: { content: [{ type: "text", text: out.text }] },
+      };
+    }
+
+    default:
+      return {
+        jsonrpc: "2.0",
+        id,
+        error: { code: -32601, message: `method not found: ${req.method}` },
+      };
+  }
+}
+
+async function callTool(
+  name: string,
+  args: Record<string, unknown>,
+  progressToken: string | number | undefined,
+): Promise<{ text: string; error?: string }> {
+  if (name === "echo") {
+    const msg = typeof args.msg === "string" ? args.msg : "";
+    return { text: `echo: ${msg}` };
+  }
+  if (name === "add") {
+    const a = typeof args.a === "number" ? args.a : Number(args.a);
+    const b = typeof args.b === "number" ? args.b : Number(args.b);
+    if (!Number.isFinite(a) || !Number.isFinite(b)) {
+      return { text: "", error: "add: both a and b must be numbers" };
+    }
+    return { text: String(a + b) };
+  }
+  if (name === "get_time") {
+    return { text: new Date().toISOString() };
+  }
+  if (name === "slow_count") {
+    // Cap at 20 so an over-eager model can't make the demo run for
+    // minutes. Default 5 gives ~1.5s which is plenty to see the bar.
+    const raw = typeof args.n === "number" ? args.n : Number(args.n);
+    const n = Number.isFinite(raw) && raw >= 1 ? Math.min(Math.floor(raw), 20) : 5;
+    for (let i = 1; i <= n; i++) {
+      await new Promise((r) => setTimeout(r, 300));
+      if (progressToken !== undefined) {
+        send({
+          jsonrpc: "2.0",
+          method: "notifications/progress",
+          params: {
+            progressToken,
+            progress: i,
+            total: n,
+            message: `counting ${i} of ${n}`,
+          },
+        });
+      }
+    }
+    return { text: `counted to ${n}` };
+  }
+  return { text: "", error: `unknown tool: ${name}` };
+}
+
+function main(): void {
+  const rl = createInterface({ input: process.stdin, crlfDelay: Number.POSITIVE_INFINITY });
+  rl.on("line", (line) => {
+    const trimmed = line.trim();
+    if (!trimmed) return;
+    let req: JsonRpcRequest;
+    try {
+      req = JSON.parse(trimmed) as JsonRpcRequest;
+    } catch {
+      // malformed input — respond with parse error
+      send({
+        jsonrpc: "2.0",
+        id: null,
+        error: { code: -32700, message: "parse error" },
+      });
+      return;
+    }
+    // Fire-and-forget: handleRequest is async so slow tools (slow_count
+    // and any future streamed-progress tools) can emit notifications
+    // between in-flight requests without blocking the reader loop. Any
+    // unexpected throw lands as an internal-error response so malformed
+    // tool logic doesn't silently hang the client.
+    handleRequest(req)
+      .then((resp) => {
+        if (resp) send(resp);
+      })
+      .catch((err) => {
+        send({
+          jsonrpc: "2.0",
+          id: req.id ?? null,
+          error: { code: -32603, message: `internal: ${(err as Error).message}` },
+        });
+      });
+  });
+  rl.on("close", () => process.exit(0));
+}
+
+main();

examples/replay-and-diff.ts

@@ -0,0 +1,70 @@
+/**
+ * Library example: programmatic replay + diff.
+ *
+ * This example runs with no API key and no DeepSeek calls — it reads the
+ * reference transcripts committed at benchmarks/tau-bench/transcripts/ and
+ * reconstructs the v0.1 cache-hit / cost numbers offline.
+ *
+ * Run from the repo root:
+ *   npx tsx examples/replay-and-diff.ts
+ *
+ * Anything you can do with `reasonix replay` / `reasonix diff` is available
+ * here as a function you can drive from your own scripts (CI gates, eval
+ * dashboards, blog post generation, etc.).
+ */
+
+import {
+  computeReplayStats,
+  diffTranscripts,
+  readTranscript,
+  renderDiffSummary,
+} from "../src/index.js";
+
+const BASELINE = "benchmarks/tau-bench/transcripts/t01_address_happy.baseline.r1.jsonl";
+const REASONIX = "benchmarks/tau-bench/transcripts/t01_address_happy.reasonix.r1.jsonl";
+
+// ---------- 1. Replay a single transcript as pure data ----------
+
+const parsed = readTranscript(REASONIX);
+const stats = computeReplayStats(parsed.records);
+
+console.log("=== Reasonix side, computed from transcript alone ===");
+console.log(`  model calls:        ${stats.turns}`);
+console.log(`  cache hit:          ${(stats.cacheHitRatio * 100).toFixed(1)}%`);
+console.log(`  total cost:         $${stats.totalCostUsd.toFixed(6)}`);
+console.log(`  vs claude estimate: $${stats.claudeEquivalentUsd.toFixed(6)}`);
+console.log(`  savings:            ${stats.savingsVsClaudePct.toFixed(1)}%`);
+console.log(`  prefix hashes:      ${stats.prefixHashes.length} distinct`);
+if (stats.prefixHashes.length === 1) {
+  console.log(`    → byte-stable: ${stats.prefixHashes[0]?.slice(0, 16)}…`);
+}
+console.log();
+
+// ---------- 2. Diff two transcripts ----------
+
+const aParsed = readTranscript(BASELINE);
+const bParsed = readTranscript(REASONIX);
+
+const report = diffTranscripts(
+  { label: "baseline", parsed: aParsed },
+  { label: "reasonix", parsed: bParsed },
+);
+
+// renderDiffSummary returns a monochrome stdout-ready string. Equivalent to
+// what `reasonix diff --print` outputs.
+console.log(renderDiffSummary(report));
+
+// ---------- 3. Direct programmatic access to pairs ----------
+//
+// You can also inspect report.pairs directly — useful for writing custom
+// filters like "show me only the turns where tool calls differed".
+
+console.log("\n=== Turns where A and B took different paths ===");
+const divergent = report.pairs.filter((p) => p.kind !== "match");
+if (divergent.length === 0) {
+  console.log("  (none — both agents followed the same path on every turn)");
+} else {
+  for (const p of divergent) {
+    console.log(`  turn ${p.turn}: ${p.kind}${p.divergenceNote ? ` — ${p.divergenceNote}` : ""}`);
+  }
+}

package.json

@@ -1,6 +1,6 @@
 {
   "name": "reasonix",
-  "version": "0.2.2",
+  "version": "0.4.22",
   "description": "DeepSeek-native agent framework: cache-first loop, R1 thought harvesting, tool-call repair.",
   "type": "module",
   "bin": {

scripts/smoke-memory.mts

@@ -0,0 +1,192 @@
+/**
+ * End-to-end smoke test for the memory layer. Runs against a temp
+ * homeDir so the developer's real ~/.reasonix/memory/ is never touched.
+ * Exercises: write → index regeneration → prefix assembly →
+ * recall → delete → REASONIX_MEMORY=off short-circuit.
+ *
+ * Run: npx tsx scripts/smoke-memory.mts
+ * Exit code 0 on success, 1 on any assertion failure.
+ */
+
+import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { ToolRegistry } from "../src/tools.js";
+import { registerMemoryTools } from "../src/tools/memory.js";
+import {
+  MemoryStore,
+  applyMemoryStack,
+  applyUserMemory,
+  projectHash,
+} from "../src/user-memory.js";
+
+let failures = 0;
+function check(label: string, cond: unknown, detail?: string) {
+  if (cond) {
+    process.stdout.write(`  ✓ ${label}\n`);
+  } else {
+    failures++;
+    process.stdout.write(`  ✗ ${label}${detail ? `  — ${detail}` : ""}\n`);
+  }
+}
+
+async function main() {
+  const home = mkdtempSync(join(tmpdir(), "reasonix-smoke-home-"));
+  const projectRoot = mkdtempSync(join(tmpdir(), "reasonix-smoke-proj-"));
+  process.stdout.write(`home:    ${home}\nproject: ${projectRoot}\n\n`);
+
+  try {
+    // ── 1. MemoryStore write + index regeneration ────────────────────
+    process.stdout.write("1. MemoryStore write → index regen\n");
+    const store = new MemoryStore({ homeDir: home, projectRoot });
+    store.write({
+      name: "bun_build",
+      type: "project",
+      scope: "project",
+      description: "Build command on this machine is `bun run build`",
+      body: "On this machine, no npm — always `bun run build` / `bun run test`.",
+    });
+    store.write({
+      name: "tabs_not_spaces",
+      type: "user",
+      scope: "global",
+      description: "Use tabs for indentation across all projects",
+      body: "Rule.\n\n**Why:** muscle memory, editor config across machines.\n\n**How to apply:** always tabs.",
+    });
+
+    const hash = projectHash(projectRoot);
+    const projectFile = join(home, "memory", hash, "bun_build.md");
+    const globalFile = join(home, "memory", "global", "tabs_not_spaces.md");
+    check("project-scoped file landed in <hash>/ dir", existsSync(projectFile));
+    check("global-scoped file landed in global/ dir", existsSync(globalFile));
+    check("no cross-contamination project ⇒ global", !existsSync(join(home, "memory", "global", "bun_build.md")));
+
+    const projectIndex = readFileSync(join(home, "memory", hash, "MEMORY.md"), "utf8");
+    check("project MEMORY.md points at bun_build.md", projectIndex.includes("[bun_build](bun_build.md)"));
+    const globalIndex = readFileSync(join(home, "memory", "global", "MEMORY.md"), "utf8");
+    check("global MEMORY.md points at tabs_not_spaces.md", globalIndex.includes("[tabs_not_spaces](tabs_not_spaces.md)"));
+
+    const raw = readFileSync(projectFile, "utf8");
+    check("frontmatter has name/type/scope/created", /^---\nname: bun_build\n/.test(raw) && /type: project/.test(raw) && /scope: project/.test(raw) && /created: \d{4}-\d{2}-\d{2}/.test(raw));
+
+    // ── 2. Prefix assembly via applyMemoryStack (+ REASONIX.md) ────────
+    process.stdout.write("\n2. Prefix assembly (REASONIX.md + user memory)\n");
+    writeFileSync(join(projectRoot, "REASONIX.md"), "# Project notes\nPrefer explicit types over inference.\n", "utf8");
+    const BASE = "You are a test assistant.";
+    const withProjOnly = applyUserMemory(BASE, { homeDir: home, projectRoot });
+    check("applyUserMemory contains global block", withProjOnly.includes("# User memory — global"));
+    check("applyUserMemory contains project block", withProjOnly.includes("# User memory — this project"));
+    check("bun_build description present in prefix", withProjOnly.includes("bun run build"));
+    check("tabs_not_spaces description present in prefix", withProjOnly.includes("Use tabs for indentation"));
+
+    // Order: base → (REASONIX.md would go first via applyMemoryStack) → global → project
+    const ordered = applyUserMemory(BASE, { homeDir: home, projectRoot });
+    const iGlobalBlock = ordered.indexOf("# User memory — global");
+    const iProjBlock = ordered.indexOf("# User memory — this project");
+    check("global block precedes project block (stable for cache)", iGlobalBlock > 0 && iGlobalBlock < iProjBlock);
+
+    // Determinism — two calls with same state produce byte-identical prompts.
+    const a = applyUserMemory(BASE, { homeDir: home, projectRoot });
+    const b = applyUserMemory(BASE, { homeDir: home, projectRoot });
+    check("applyUserMemory is deterministic (byte-stable)", a === b);
+
+    // ── 3. The `remember` / `recall_memory` / `forget` tools ───────────
+    process.stdout.write("\n3. Tool dispatch (remember / recall / forget)\n");
+    const reg = new ToolRegistry();
+    registerMemoryTools(reg, { homeDir: home, projectRoot });
+    check("remember tool registered", reg.has("remember"));
+    check("forget tool registered", reg.has("forget"));
+    check("recall_memory tool registered", reg.has("recall_memory"));
+    check("recall_memory is readOnly (plan-mode safe)", reg.get("recall_memory")?.readOnly === true);
+    check("remember is NOT readOnly (plan-mode blocked)", reg.get("remember")?.readOnly !== true);
+
+    const remOut = await reg.dispatch("remember", {
+      type: "feedback",
+      scope: "global",
+      name: "prefers_short_replies",
+      description: "User wants terse answers, no trailing summaries",
+      content: "Default to terse. If the user wants detail they'll ask.",
+    });
+    check("remember returns a confirmation (not an error)", remOut.includes("REMEMBERED (global/prefers_short_replies)"), remOut);
+
+    const recallOut = await reg.dispatch("recall_memory", {
+      scope: "global",
+      name: "prefers_short_replies",
+    });
+    check("recall_memory returns the body", recallOut.includes("Default to terse"));
+
+    const forgetOut = await reg.dispatch("forget", {
+      scope: "global",
+      name: "prefers_short_replies",
+    });
+    check("forget returns a confirmation", forgetOut.includes("forgot (global/prefers_short_replies)"));
+    check("recall_memory after forget returns an error", (await reg.dispatch("recall_memory", { scope: "global", name: "prefers_short_replies" })).includes("error"));
+
+    // ── 4. Project scope refused when projectRoot is absent ────────────
+    process.stdout.write("\n4. Chat-mode (no projectRoot) refuses project scope\n");
+    const chatReg = new ToolRegistry();
+    registerMemoryTools(chatReg, { homeDir: home });
+    const projInChat = await chatReg.dispatch("remember", {
+      type: "project",
+      scope: "project",
+      name: "should_fail",
+      description: "d",
+      content: "c",
+    });
+    check("scope='project' in chat mode → error payload", projInChat.includes("error") && projInChat.includes("project"));
+    const globalInChat = await chatReg.dispatch("remember", {
+      type: "user",
+      scope: "global",
+      name: "global_from_chat",
+      description: "works across projects",
+      content: "body",
+    });
+    check("scope='global' in chat mode → writes successfully", globalInChat.includes("REMEMBERED (global/"));
+
+    // ── 5. REASONIX_MEMORY=off short-circuit ───────────────────────────
+    process.stdout.write("\n5. REASONIX_MEMORY=off opt-out\n");
+    process.env.REASONIX_MEMORY = "off";
+    try {
+      const silenced = applyUserMemory(BASE, { homeDir: home, projectRoot });
+      check("applyUserMemory returns BASE unchanged when off", silenced === BASE);
+      const fullStack = applyMemoryStack(BASE, projectRoot);
+      check("applyMemoryStack returns BASE unchanged when off (REASONIX.md also skipped)", fullStack === BASE);
+    } finally {
+      delete process.env.REASONIX_MEMORY;
+    }
+
+    // ── 6. Delete regeneration: MEMORY.md matches current file set ─────
+    process.stdout.write("\n6. Delete + index regeneration\n");
+    store.delete("global", "tabs_not_spaces");
+    store.delete("global", "global_from_chat");
+    const globalIdxAfter = join(home, "memory", "global", "MEMORY.md");
+    check("global MEMORY.md removed when last file deleted", !existsSync(globalIdxAfter));
+    const projectIdxStill = readFileSync(join(home, "memory", hash, "MEMORY.md"), "utf8");
+    check("project MEMORY.md untouched (different scope)", projectIdxStill.includes("bun_build"));
+
+    // ── 7. Name-sanitization boundary ──────────────────────────────────
+    process.stdout.write("\n7. Name sanitization (path-traversal refused)\n");
+    const badOut = await reg.dispatch("remember", {
+      type: "user",
+      scope: "global",
+      name: "../../etc/passwd",
+      description: "d",
+      content: "c",
+    });
+    check("remember refuses path-traversal name", badOut.includes("invalid memory name"));
+    const outsideFile = join(home, "etc", "passwd.md");
+    check("no file written outside the memory dir", !existsSync(outsideFile));
+
+    process.stdout.write(`\n${failures === 0 ? "✅ all smoke checks passed" : `❌ ${failures} failure(s)`}\n`);
+  } finally {
+    rmSync(home, { recursive: true, force: true });
+    rmSync(projectRoot, { recursive: true, force: true });
+  }
+
+  process.exit(failures === 0 ? 0 : 1);
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

src/cli/commands/chat.tsx

@@ -1,9 +1,34 @@
+import { existsSync, statSync } from "node:fs";
 import { render } from "ink";
 import React, { useState } from "react";
-import { loadApiKey } from "../../config.js";
+import { loadApiKey, searchEnabled } from "../../config.js";
 import { loadDotenv } from "../../env.js";
+import { McpClient } from "../../mcp/client.js";
+import { type InspectionReport, inspectMcpServer } from "../../mcp/inspect.js";
+import { bridgeMcpTools } from "../../mcp/registry.js";
+import { parseMcpSpec } from "../../mcp/spec.js";
+import { SseTransport } from "../../mcp/sse.js";
+import { type McpTransport, StdioTransport } from "../../mcp/stdio.js";
+import {
+  loadSessionMessages,
+  rewriteSession,
+  sessionPath as sessionPathOf,
+} from "../../session.js";
+import { ToolRegistry } from "../../tools.js";
+import { registerMemoryTools } from "../../tools/memory.js";
+import { registerSkillTools } from "../../tools/skills.js";
+import { registerWebTools } from "../../tools/web.js";
 import { App } from "../ui/App.js";
+import { SessionPicker } from "../ui/SessionPicker.js";
 import { Setup } from "../ui/Setup.js";
+import type { McpServerSummary } from "../ui/slash.js";
+
+export interface ProgressInfo {
+  toolName: string;
+  progress: number;
+  total?: number;
+  message?: string;
+}
 
 export interface ChatOptions {
   model: string;
@@ -12,14 +37,59 @@ export interface ChatOptions {
   harvest?: boolean;
   branch?: number;
   session?: string;
+  /** Zero or more MCP server specs. Each: `"name=cmd args..."` or `"cmd args..."`. */
+  mcp?: string[];
+  /** Global prefix — only used when a single anonymous server is given. */
+  mcpPrefix?: string;
+  /**
+   * Pre-built ToolRegistry used as a seed. MCP bridges (if any) are
+   * layered on top of whatever's already registered. Used by
+   * `reasonix code` to register native filesystem tools in place of
+   * the old `npx -y @modelcontextprotocol/server-filesystem` subprocess.
+   */
+  seedTools?: ToolRegistry;
+  /**
+   * Enable SEARCH/REPLACE edit-block processing after each assistant turn.
+   * Set by `reasonix code`; plain `reasonix chat` leaves this off.
+   */
+  codeMode?: { rootDir: string };
+  /** Skip the session picker — assume "Resume" (backwards-compatible auto-continue). */
+  forceResume?: boolean;
+  /** Skip the session picker — assume "New" (wipe the session file and start fresh). */
+  forceNew?: boolean;
 }
 
 interface RootProps extends ChatOptions {
   initialKey: string | undefined;
+  tools: ToolRegistry | undefined;
+  mcpSpecs: string[];
+  mcpServers: McpServerSummary[];
+  /**
+   * Shared ref the bridge's `onProgress` callback writes through.
+   * App sets `.current` to its own handler on mount so every
+   * progress frame from any bridged tool lands in the UI's
+   * `OngoingToolRow`. Ref keeps the wire-up synchronous with
+   * React reconciliation (no effect-timing surprises).
+   */
+  progressSink: { current: ((info: ProgressInfo) => void) | null };
+  /** Present when the session has prior messages; drives the picker. */
+  sessionPreview?: { messageCount: number; lastActive: Date };
 }
 
-function Root({ initialKey, ...appProps }: RootProps) {
+function Root({
+  initialKey,
+  tools,
+  mcpSpecs,
+  mcpServers,
+  progressSink,
+  sessionPreview,
+  ...appProps
+}: RootProps) {
   const [key, setKey] = useState<string | undefined>(initialKey);
+  // `null` once the picker is resolved (or was never needed). Starts as
+  // the preview so we can render the picker once before mounting App.
+  const [pending, setPending] = useState<typeof sessionPreview>(sessionPreview);
+
   if (!key) {
     return (
       <Setup
@@ -30,8 +100,27 @@ function Root({ initialKey, ...appProps }: RootProps) {
       />
     );
   }
-  // Ensure the loop's DeepSeekClient picks up the key when it lazy-instantiates.
   process.env.DEEPSEEK_API_KEY = key;
+
+  if (pending && appProps.session) {
+    return (
+      <SessionPicker
+        sessionName={appProps.session}
+        messageCount={pending.messageCount}
+        lastActive={pending.lastActive}
+        onChoose={(choice) => {
+          if (choice === "new" || choice === "delete") {
+            // Wipe the session file. "new" and "delete" do the same thing
+            // at this step — the distinction is only in the picker's
+            // wording. A future enhancement could archive on "new".
+            rewriteSession(appProps.session!, []);
+          }
+          setPending(undefined);
+        }}
+      />
+    );
+  }
+
   return (
     <App
       model={appProps.model}
@@ -40,6 +129,11 @@ function Root({ initialKey, ...appProps }: RootProps) {
       harvest={appProps.harvest}
       branch={appProps.branch}
       session={appProps.session}
+      tools={tools}
+      mcpSpecs={mcpSpecs}
+      mcpServers={mcpServers}
+      progressSink={progressSink}
+      codeMode={appProps.codeMode}
     />
   );
 }
@@ -47,8 +141,157 @@ function Root({ initialKey, ...appProps }: RootProps) {
 export async function chatCommand(opts: ChatOptions): Promise<void> {
   loadDotenv();
   const initialKey = loadApiKey();
-  const { waitUntilExit } = render(<Root initialKey={initialKey} {...opts} />, {
-    exitOnCtrlC: true,
-  });
-  await waitUntilExit();
+
+  const requestedSpecs = opts.mcp ?? [];
+  const clients: McpClient[] = [];
+  const successfulSpecs: string[] = [];
+  const failedSpecs: Array<{ spec: string; reason: string }> = [];
+  const mcpServers: McpServerSummary[] = [];
+  // Shared progress sink: the bridge's onProgress callback writes
+  // through `progressSink.current`, which App.tsx sets to its UI
+  // updater on mount. Started null so early progress frames (before
+  // the App has mounted) are dropped rather than buffered.
+  const progressSink: { current: ((info: ProgressInfo) => void) | null } = { current: null };
+  // Seed registry from the caller (e.g. reasonix code's native
+  // filesystem tools) — MCP bridges layer on top rather than
+  // replacing. When no seed AND no MCP, tools stays undefined and
+  // the loop runs as a bare chat.
+  let tools: ToolRegistry | undefined = opts.seedTools;
+
+  if (requestedSpecs.length > 0) {
+    if (!tools) tools = new ToolRegistry();
+    for (const raw of requestedSpecs) {
+      try {
+        const spec = parseMcpSpec(raw);
+        const prefix = spec.name
+          ? `${spec.name}_`
+          : requestedSpecs.length === 1 && opts.mcpPrefix
+            ? opts.mcpPrefix
+            : "";
+        const transport: McpTransport =
+          spec.transport === "sse"
+            ? new SseTransport({ url: spec.url })
+            : new StdioTransport({ command: spec.command, args: spec.args });
+        const mcp = new McpClient({ transport });
+        await mcp.initialize();
+        const bridge = await bridgeMcpTools(mcp, {
+          registry: tools,
+          namePrefix: prefix,
+          onProgress: (info) => progressSink.current?.(info),
+        });
+        // Collect resources + prompts once at startup so the /mcp
+        // slash can render them synchronously. Servers that don't
+        // support these fall through as `{supported: false}` instead
+        // of throwing — see inspectMcpServer.
+        let report: InspectionReport;
+        try {
+          report = await inspectMcpServer(mcp);
+        } catch {
+          // If the inspect call itself fails (rare — shouldn't happen
+          // since inspectMcpServer swallows -32601), synthesize a
+          // minimal report so `/mcp` still has something to render.
+          report = {
+            protocolVersion: mcp.protocolVersion,
+            serverInfo: mcp.serverInfo,
+            capabilities: mcp.serverCapabilities ?? {},
+            tools: { supported: true, items: [] },
+            resources: { supported: false, reason: "inspect failed" },
+            prompts: { supported: false, reason: "inspect failed" },
+          };
+        }
+        const label = spec.name ?? "anon";
+        const source =
+          spec.transport === "sse" ? spec.url : `${spec.command} ${spec.args.join(" ")}`;
+        process.stderr.write(
+          `▸ MCP[${label}]: ${bridge.registeredNames.length} tool(s) from ${source}\n`,
+        );
+        clients.push(mcp);
+        successfulSpecs.push(raw);
+        mcpServers.push({
+          label,
+          spec: raw,
+          toolCount: bridge.registeredNames.length,
+          report,
+        });
+      } catch (err) {
+        // Per-server failure is non-fatal: one broken server shouldn't
+        // kill a chat that has working servers configured. We record
+        // the failure, show a visible warning, and keep going. User
+        // can fix via `reasonix setup` (unchecks the broken entry)
+        // without losing their other servers.
+        const reason = (err as Error).message;
+        failedSpecs.push({ spec: raw, reason });
+        process.stderr.write(
+          `▸ MCP setup SKIPPED for "${raw}": ${reason}\n  → this server will not be available this session. Run \`reasonix setup\` to remove it, or fix the underlying issue (missing npm package, network, etc.).\n`,
+        );
+      }
+    }
+    // If every requested server failed AND no seed registry was
+    // provided, drop the empty registry so the loop still runs as a
+    // bare chat instead of advertising zero tools. If the caller
+    // passed seedTools we keep the registry — the seed tools are
+    // still there and usable.
+    if (successfulSpecs.length === 0 && !opts.seedTools) {
+      tools = undefined;
+    }
+  }
+  const mcpSpecs = successfulSpecs;
+
+  // Register web search/fetch tools unless explicitly disabled. DDG
+  // backs them with no key required; the model invokes them whenever
+  // a question needs info fresher than its training data.
+  if (searchEnabled()) {
+    if (!tools) tools = new ToolRegistry();
+    registerWebTools(tools);
+  }
+
+  // Memory tools — available in every session, not just code mode.
+  // Chat-mode callers get global scope only; project scope requires
+  // the seedTools path from `reasonix code` (which registers its own
+  // MemoryStore bound to rootDir before chatCommand runs).
+  if (!opts.seedTools) {
+    if (!tools) tools = new ToolRegistry();
+    registerMemoryTools(tools, {});
+    // Skills are a chat-mode concept too — load them here so plain
+    // `reasonix chat` users can invoke user-defined skills. Code mode
+    // registers its own copy alongside its other seed tools.
+    registerSkillTools(tools);
+  }
+
+  // Decide whether to show the session picker. It's gated on: session
+  // persistence is on, the session file already has prior messages, and
+  // the caller didn't pre-commit to one of the choices via --resume /
+  // --new flags. `--new` wipes the file now (before the loop opens),
+  // so the App mounts against a fresh log.
+  let sessionPreview: { messageCount: number; lastActive: Date } | undefined;
+  if (opts.session && !opts.forceResume && !opts.forceNew) {
+    const prior = loadSessionMessages(opts.session);
+    if (prior.length > 0) {
+      const p = sessionPathOf(opts.session);
+      const mtime = existsSync(p) ? statSync(p).mtime : new Date();
+      sessionPreview = { messageCount: prior.length, lastActive: mtime };
+    }
+  } else if (opts.session && opts.forceNew) {
+    rewriteSession(opts.session, []);
+  }
+
+  const { waitUntilExit } = render(
+    <Root
+      initialKey={initialKey}
+      tools={tools}
+      mcpSpecs={mcpSpecs}
+      mcpServers={mcpServers}
+      progressSink={progressSink}
+      sessionPreview={sessionPreview}
+      {...opts}
+    />,
+    // patchConsole:false — we never log to console during the TUI, and the
+    // patch is a known redraw-glitch source on winpty/MINTTY terminals.
+    { exitOnCtrlC: true, patchConsole: false },
+  );
+  try {
+    await waitUntilExit();
+  } finally {
+    for (const c of clients) await c.close();
+  }
 }

src/cli/commands/code.tsx

@@ -0,0 +1,101 @@
+/**
+ * `reasonix code [dir]` — opinionated wrapper around `reasonix chat` for
+ * code-editing workflows.
+ *
+ * What it does differently from plain chat:
+ *   - Registers native filesystem tools rooted at the given directory
+ *     (CWD by default). No subprocess, no `npx install` step, R1-
+ *     friendly schemas. Replaced the old `@modelcontextprotocol/server-filesystem`
+ *     subprocess in 0.4.9 because its `edit_file` argv shape was the
+ *     biggest driver of R1 DSML hallucinations.
+ *   - Uses a coding-focused system prompt (src/code/prompt.ts) that
+ *     teaches the model to propose edits as SEARCH/REPLACE blocks.
+ *   - Defaults to the `smart` preset (reasoner + harvest) because
+ *     coding tasks pay back R1 thinking.
+ *   - Scopes its session to the directory so projects don't share
+ *     conversation history.
+ *   - Hooks `codeMode` into the TUI so assistant replies get parsed
+ *     for SEARCH/REPLACE blocks and applied on disk after each turn.
+ */
+
+import { basename, resolve } from "node:path";
+import { loadProjectShellAllowed } from "../../config.js";
+import { sanitizeName } from "../../session.js";
+import { ToolRegistry } from "../../tools.js";
+import { registerFilesystemTools } from "../../tools/filesystem.js";
+import { registerMemoryTools } from "../../tools/memory.js";
+import { registerPlanTool } from "../../tools/plan.js";
+import { registerShellTools } from "../../tools/shell.js";
+import { registerSkillTools } from "../../tools/skills.js";
+import { chatCommand } from "./chat.js";
+
+export interface CodeOptions {
+  /** Directory to root the filesystem tools at. Defaults to process.cwd(). */
+  dir?: string;
+  /** Override the default `smart` model. */
+  model?: string;
+  /** Disable session persistence. */
+  noSession?: boolean;
+  /** Transcript file for replay/diff. */
+  transcript?: string;
+  /** Skip the session picker — always resume prior messages. */
+  forceResume?: boolean;
+  /** Skip the session picker — always wipe prior messages and start fresh. */
+  forceNew?: boolean;
+}
+
+export async function codeCommand(opts: CodeOptions = {}): Promise<void> {
+  const { codeSystemPrompt } = await import("../../code/prompt.js");
+  const rootDir = resolve(opts.dir ?? process.cwd());
+  // Per-directory session so switching projects doesn't mix histories.
+  // `code-<sanitized-basename>` fits the session name rules without
+  // truncating most project names.
+  const session = opts.noSession ? undefined : `code-${sanitizeName(basename(rootDir))}`;
+
+  // Native filesystem tools. No subprocess, ~50-200 ms faster per call
+  // than the MCP server was, and `edit_file` takes a flat SEARCH/REPLACE
+  // shape instead of the `string="false"` JSON-in-string array that
+  // triggered R1's DSML hallucinations all through 0.4.x.
+  const tools = new ToolRegistry();
+  registerFilesystemTools(tools, { rootDir });
+  registerShellTools(tools, {
+    rootDir,
+    // Per-project "always allow" list persisted from prior ShellConfirm
+    // choices; merged on top of the built-in allowlist in shell.ts.
+    // GETTER form — re-read every dispatch so a prefix the user adds
+    // via ShellConfirm mid-session takes effect on the next shell call
+    // instead of waiting for `/new` or a relaunch.
+    extraAllowed: () => loadProjectShellAllowed(rootDir),
+  });
+  // `submit_plan` is always in the spec list so the prefix cache stays
+  // stable across plan-mode toggles (Pillar 1). The tool itself is a
+  // no-op outside plan mode and throws `PlanProposedError` when the
+  // user has `/plan`-enabled the session.
+  registerPlanTool(tools);
+  // `remember` / `forget` / `recall_memory` — cross-session user memory.
+  // Project scope hashes off rootDir so switching projects gets a fresh
+  // per-project memory store; the global scope is shared across runs.
+  registerMemoryTools(tools, { projectRoot: rootDir });
+  // `run_skill` — loads user-authored prompt packs on demand. The
+  // index itself (names + descriptions) is already pinned into the
+  // system prompt by `applyMemoryStack`; this tool serves the bodies.
+  // Passing projectRoot surfaces `<rootDir>/.reasonix/skills/` alongside
+  // the global scope.
+  registerSkillTools(tools, { projectRoot: rootDir });
+
+  process.stderr.write(
+    `▸ reasonix code: rooted at ${rootDir}, session "${session ?? "(ephemeral)"}" · ${tools.size} native tool(s)\n`,
+  );
+
+  await chatCommand({
+    model: opts.model ?? "deepseek-reasoner",
+    harvest: true, // smart preset's harvest setting, always on for code
+    system: codeSystemPrompt(rootDir),
+    transcript: opts.transcript,
+    session,
+    seedTools: tools,
+    codeMode: { rootDir },
+    forceResume: opts.forceResume,
+    forceNew: opts.forceNew,
+  });
+}

src/cli/commands/diff.ts

@@ -51,6 +51,7 @@ export async function diffCommand(opts: DiffOptions): Promise<void> {
   if (wantTui) {
     const { waitUntilExit } = render(React.createElement(DiffApp, { report }), {
       exitOnCtrlC: true,
+      patchConsole: false,
     });
     await waitUntilExit();
     return;

src/cli/commands/mcp-inspect.ts

@@ -0,0 +1,107 @@
+/**
+ * `reasonix mcp inspect <spec>` — connect to one MCP server, list
+ * everything it exposes (tools, resources, prompts), print a
+ * human-readable summary. Useful as:
+ *   - a diagnostic tool for "does my MCP server even work?"
+ *   - a discovery tool for "what can this server do?"
+ *   - the only CLI surface for the resources+prompts methods added
+ *     in 0.4.5 (chat mode consumes tools but hasn't wired up the
+ *     other two families yet).
+ */
+
+import { McpClient } from "../../mcp/client.js";
+import { inspectMcpServer } from "../../mcp/inspect.js";
+import type { InspectionReport } from "../../mcp/inspect.js";
+import { parseMcpSpec } from "../../mcp/spec.js";
+import { SseTransport } from "../../mcp/sse.js";
+import { type McpTransport, StdioTransport } from "../../mcp/stdio.js";
+
+export interface McpInspectOptions {
+  /** The raw --mcp spec string (e.g. `fs=npx -y @modelcontextprotocol/server-filesystem .`). */
+  spec: string;
+  /** Emit JSON on stdout instead of the human-readable table. */
+  json?: boolean;
+}
+
+export async function mcpInspectCommand(opts: McpInspectOptions): Promise<void> {
+  const spec = parseMcpSpec(opts.spec);
+  const transport: McpTransport =
+    spec.transport === "sse"
+      ? new SseTransport({ url: spec.url })
+      : new StdioTransport({ command: spec.command, args: spec.args });
+  const client = new McpClient({ transport });
+  try {
+    await client.initialize();
+    const report = await inspectMcpServer(client);
+    if (opts.json) {
+      console.log(JSON.stringify(report, null, 2));
+    } else {
+      console.log(formatReport(spec.name ?? "(anon)", report));
+    }
+  } finally {
+    await client.close();
+  }
+}
+
+function formatReport(nsName: string, r: InspectionReport): string {
+  const lines: string[] = [];
+  lines.push(`MCP server [${nsName}]`);
+  lines.push(
+    `  server     ${r.serverInfo.name || "(unknown)"}${r.serverInfo.version ? ` v${r.serverInfo.version}` : ""}`,
+  );
+  lines.push(`  protocol   ${r.protocolVersion}`);
+  const capKeys = Object.keys(r.capabilities);
+  lines.push(`  caps       ${capKeys.length > 0 ? capKeys.join(", ") : "(none advertised)"}`);
+  if (r.instructions) {
+    lines.push(`  notes      ${r.instructions.trim().slice(0, 200)}`);
+  }
+  lines.push("");
+  lines.push(formatSection("Tools", r.tools, toolLine));
+  lines.push(formatSection("Resources", r.resources, resourceLine));
+  lines.push(formatSection("Prompts", r.prompts, promptLine));
+  return lines.join("\n");
+}
+
+function formatSection<T>(
+  title: string,
+  section: { supported: true; items: T[] } | { supported: false; reason: string },
+  render: (item: T) => string,
+): string {
+  if (!section.supported) {
+    return `${title}: (not supported — ${section.reason})`;
+  }
+  if (section.items.length === 0) {
+    return `${title}: (none)`;
+  }
+  const lines = [`${title} (${section.items.length}):`];
+  for (const item of section.items) lines.push(`  ${render(item)}`);
+  return lines.join("\n");
+}
+
+function toolLine(t: { name: string; description?: string }): string {
+  const desc = t.description ? ` — ${oneLine(t.description, 80)}` : "";
+  return `· ${t.name}${desc}`;
+}
+
+function resourceLine(r: { uri: string; name: string; mimeType?: string }): string {
+  const mime = r.mimeType ? ` [${r.mimeType}]` : "";
+  return `· ${r.name}${mime}  ${r.uri}`;
+}
+
+function promptLine(p: {
+  name: string;
+  description?: string;
+  arguments?: Array<{ name: string; required?: boolean }>;
+}): string {
+  const argPart =
+    p.arguments && p.arguments.length > 0
+      ? ` (${p.arguments.map((a) => (a.required ? a.name : `${a.name}?`)).join(", ")})`
+      : "";
+  const desc = p.description ? ` — ${oneLine(p.description, 80)}` : "";
+  return `· ${p.name}${argPart}${desc}`;
+}
+
+function oneLine(s: string, max: number): string {
+  const flat = s.replace(/\s+/g, " ").trim();
+  return flat.length <= max ? flat : `${flat.slice(0, max - 1)}…`;
+}

src/cli/commands/mcp.ts

@@ -0,0 +1,41 @@
+/**
+ * `reasonix mcp <subcmd>` — the MCP discovery / helper surface.
+ *
+ * Currently one subcommand: `list`. Prints a curated catalog of popular
+ * MCP servers with their `--mcp` commands ready to copy-paste. More
+ * subcommands (`init`, `try`, etc.) may land in later alphas.
+ */
+
+import { MCP_CATALOG, mcpCommandFor } from "../../mcp/catalog.js";
+
+export interface McpListOptions {
+  /** Emit JSON on stdout instead of the human-readable table. */
+  json?: boolean;
+}
+
+export function mcpListCommand(opts: McpListOptions): void {
+  if (opts.json) {
+    console.log(JSON.stringify(MCP_CATALOG, null, 2));
+    return;
+  }
+
+  console.log("Popular MCP servers you can bridge into Reasonix:");
+  console.log("");
+  for (const entry of MCP_CATALOG) {
+    console.log(`  ${pad(entry.name, 12)} ${entry.summary}`);
+    console.log(`               ${mcpCommandFor(entry)}`);
+    if (entry.note) console.log(`               · ${entry.note}`);
+    console.log("");
+  }
+  console.log("Usage:  reasonix chat <one-of-the---mcp-lines-above>");
+  console.log(
+    "Docs:   https://github.com/modelcontextprotocol/servers  —  Anthropic's official server repo",
+  );
+  console.log(
+    "        https://mcp.so                                   —  community-maintained catalog",
+  );
+}
+
+function pad(s: string, width: number): string {
+  return s.length >= width ? s : s + " ".repeat(width - s.length);
+}

src/cli/commands/replay.ts

@@ -31,6 +31,7 @@ export async function replayCommand(opts: ReplayOptions): Promise<void> {
   const pages = groupRecordsByTurn(parsed.records);
   const { waitUntilExit } = render(React.createElement(ReplayApp, { meta: parsed.meta, pages }), {
     exitOnCtrlC: true,
+    patchConsole: false,
   });
   await waitUntilExit();
 }
@@ -74,6 +75,11 @@ function printReplay(opts: ReplayOptions): void {
   } else if (stats.prefixHashes.length > 1) {
     console.log("  (prefix churned — cache-hostile session)");
   }
+  if (stats.harvestedTurns > 0) {
+    console.log(`harvest (Pillar 2): ${stats.harvestedTurns} turn(s) produced plan state`);
+    console.log(`  subgoals:          ${stats.totalSubgoals}`);
+    console.log(`  uncertainties:     ${stats.totalUncertainties}`);
+  }
 }
 
 function sliceRecords(records: TranscriptRecord[], opts: ReplayOptions): TranscriptRecord[] {
@@ -100,6 +106,21 @@ function renderRecord(rec: TranscriptRecord): void {
           })()
         : "";
     console.log(`${turn} AGENT:${cost}${cache} ${oneLine(rec.content)}`);
+    if (rec.planState) {
+      const ps = rec.planState;
+      if (ps.subgoals.length)
+        console.log(`   ‹ subgoals     (${ps.subgoals.length}): ${ps.subgoals.join(" · ")}`);
+      if (ps.hypotheses.length)
+        console.log(`   ‹ hypotheses   (${ps.hypotheses.length}): ${ps.hypotheses.join(" · ")}`);
+      if (ps.uncertainties.length)
+        console.log(
+          `   ‹ uncertainties(${ps.uncertainties.length}): ${ps.uncertainties.join(" · ")}`,
+        );
+      if (ps.rejectedPaths.length)
+        console.log(
+          `   ‹ rejected     (${ps.rejectedPaths.length}): ${ps.rejectedPaths.join(" · ")}`,
+        );
+    }
   } else if (rec.role === "tool") {
     const args = rec.args ? ` args=${oneLine(rec.args, 80)}` : "";
     console.log(`${turn} TOOL ${rec.tool ?? "?"}:${args} → ${oneLine(rec.content, 120)}`);

src/cli/commands/run.ts

@@ -1,13 +1,31 @@
+import type { WriteStream } from "node:fs";
 import { stdin, stdout } from "node:process";
 import { createInterface } from "node:readline/promises";
 import { defaultConfigPath, isPlausibleKey, loadApiKey, saveApiKey } from "../../config.js";
 import { loadDotenv } from "../../env.js";
 import { CacheFirstLoop, DeepSeekClient, ImmutablePrefix } from "../../index.js";
+import { McpClient } from "../../mcp/client.js";
+import { bridgeMcpTools } from "../../mcp/registry.js";
+import { parseMcpSpec } from "../../mcp/spec.js";
+import { SseTransport } from "../../mcp/sse.js";
+import { type McpTransport, StdioTransport } from "../../mcp/stdio.js";
+import { ToolRegistry } from "../../tools.js";
+import { openTranscriptFile, recordFromLoopEvent, writeRecord } from "../../transcript.js";
 
 export interface RunOptions {
   task: string;
   model: string;
   system: string;
+  /** Opt into Pillar 2 plan-state harvesting. Adds a cheap V3 call per turn. */
+  harvest?: boolean;
+  /** Self-consistency budget. > 1 runs N parallel samples and picks the best. */
+  branch?: number;
+  /** JSONL transcript path — lets `reasonix replay` / `diff` audit this run. */
+  transcript?: string;
+  /** Zero or more MCP server specs. Each: `"name=cmd args..."` or `"cmd args..."`. */
+  mcp?: string[];
+  /** Global prefix — only honored when a single anonymous server is given. */
+  mcpPrefix?: string;
 }
 
 async function ensureApiKey(): Promise<string> {
@@ -48,19 +66,107 @@ export async function runCommand(opts: RunOptions): Promise<void> {
   const apiKey = await ensureApiKey();
   process.env.DEEPSEEK_API_KEY = apiKey;
 
-  const client = new DeepSeekClient();
-  const prefix = new ImmutablePrefix({ system: opts.system });
-  const loop = new CacheFirstLoop({ client, prefix, model: opts.model });
-
-  for await (const ev of loop.step(opts.task)) {
-    if (ev.role === "assistant_delta" && ev.content) process.stdout.write(ev.content);
-    if (ev.role === "tool") process.stdout.write(`\n[tool ${ev.toolName}] ${ev.content}\n`);
-    if (ev.role === "error") process.stderr.write(`\n[error] ${ev.error}\n`);
-    if (ev.role === "done") process.stdout.write("\n");
+  // Optional MCP setup — mirrors chat's flow. Must happen before loop
+  // construction so the tools make it into the prefix.
+  const requestedSpecs = opts.mcp ?? [];
+  const clients: McpClient[] = [];
+  let tools: ToolRegistry | undefined;
+  let successCount = 0;
+  if (requestedSpecs.length > 0) {
+    tools = new ToolRegistry();
+    for (const raw of requestedSpecs) {
+      try {
+        const spec = parseMcpSpec(raw);
+        const prefix = spec.name
+          ? `${spec.name}_`
+          : requestedSpecs.length === 1 && opts.mcpPrefix
+            ? opts.mcpPrefix
+            : "";
+        const transport: McpTransport =
+          spec.transport === "sse"
+            ? new SseTransport({ url: spec.url })
+            : new StdioTransport({ command: spec.command, args: spec.args });
+        const mcp = new McpClient({ transport });
+        await mcp.initialize();
+        const bridge = await bridgeMcpTools(mcp, { registry: tools, namePrefix: prefix });
+        const source =
+          spec.transport === "sse" ? spec.url : `${spec.command} ${spec.args.join(" ")}`;
+        process.stderr.write(
+          `▸ MCP[${spec.name ?? "anon"}]: ${bridge.registeredNames.length} tool(s) from ${source}\n`,
+        );
+        clients.push(mcp);
+        successCount++;
+      } catch (err) {
+        // Non-fatal — skip and continue, same as `reasonix chat`. A
+        // one-shot `run` invocation with a broken MCP server otherwise
+        // fails the whole run over a side-concern tool the task might
+        // not even touch.
+        process.stderr.write(
+          `▸ MCP setup SKIPPED for "${raw}": ${(err as Error).message}\n  → run \`reasonix setup\` to remove broken entries from your saved config.\n`,
+        );
+      }
+    }
+    if (successCount === 0) tools = undefined;
   }
+
+  const client = new DeepSeekClient();
+  const prefix = new ImmutablePrefix({
+    system: opts.system,
+    toolSpecs: tools?.specs(),
+  });
+  const loop = new CacheFirstLoop({
+    client,
+    prefix,
+    tools,
+    model: opts.model,
+    harvest: opts.harvest,
+    branch: opts.branch,
+  });
+  const prefixHash = prefix.fingerprint;
+
+  let transcriptStream: WriteStream | null = null;
+  if (opts.transcript) {
+    transcriptStream = openTranscriptFile(opts.transcript, {
+      version: 1,
+      source: "reasonix run",
+      model: opts.model,
+      startedAt: new Date().toISOString(),
+    });
+    // Also persist the user turn itself (the loop's event stream starts with
+    // assistant output, not the prompt we're about to send).
+    writeRecord(transcriptStream, {
+      ts: new Date().toISOString(),
+      turn: 1,
+      role: "user",
+      content: opts.task,
+    });
+  }
+
+  try {
+    for await (const ev of loop.step(opts.task)) {
+      if (ev.role === "assistant_delta" && ev.content) process.stdout.write(ev.content);
+      if (ev.role === "tool") process.stdout.write(`\n[tool ${ev.toolName}] ${ev.content}\n`);
+      if (ev.role === "error") process.stderr.write(`\n[error] ${ev.error}\n`);
+      if (ev.role === "done") process.stdout.write("\n");
+      // Persist every non-streaming event — deltas would flood the file and
+      // aren't useful for replay (replay renders final content, not keystrokes).
+      if (transcriptStream && ev.role !== "assistant_delta") {
+        writeRecord(transcriptStream, recordFromLoopEvent(ev, { model: opts.model, prefixHash }));
+      }
+    }
+  } finally {
+    transcriptStream?.end();
+  }
+
   const s = loop.stats.summary();
   process.stdout.write(
     `\n— turns:${s.turns} cache:${(s.cacheHitRatio * 100).toFixed(1)}% ` +
       `cost:$${s.totalCostUsd.toFixed(6)} save-vs-claude:${s.savingsVsClaudePct.toFixed(1)}%\n`,
   );
+  if (opts.transcript) {
+    process.stdout.write(`\ntranscript: ${opts.transcript}\n`);
+    process.stdout.write(`  → npx reasonix replay ${opts.transcript}\n`);
+  }
+
+  for (const c of clients) await c.close();
 }

src/cli/commands/sessions.ts

@@ -0,0 +1,107 @@
+/**
+ * `reasonix sessions` — CLI equivalent of the `/sessions` slash command.
+ *
+ * Two modes:
+ *   - `reasonix sessions`           list every session under ~/.reasonix/sessions/
+ *   - `reasonix sessions <name>`    dump one session's messages in readable form
+ *
+ * Neither needs an API key — pure filesystem reads of JSONL files written
+ * by previous chat runs.
+ */
+
+import { listSessions, loadSessionMessages, sessionPath } from "../../index.js";
+import type { ChatMessage } from "../../index.js";
+
+export interface SessionsOptions {
+  /** When present, inspect that session instead of listing. */
+  name?: string;
+  /** Include assistant tool-call metadata in the inspect output. */
+  verbose?: boolean;
+}
+
+export function sessionsCommand(opts: SessionsOptions): void {
+  if (opts.name) {
+    inspectSession(opts.name, !!opts.verbose);
+  } else {
+    listAll();
+  }
+}
+
+function listAll(): void {
+  const items = listSessions();
+  if (items.length === 0) {
+    console.log(
+      "no saved sessions yet — run `reasonix chat` (sessions are auto-saved unless --no-session).",
+    );
+    return;
+  }
+  console.log("Saved sessions (~/.reasonix/sessions/):");
+  console.log("");
+  console.log(`  ${"name".padEnd(22)} ${"msgs".padStart(6)}  ${"size".padStart(8)}  modified`);
+  console.log(`  ${"─".repeat(60)}`);
+  for (const s of items) {
+    const sizeKb = `${(s.size / 1024).toFixed(1)} KB`;
+    const when = s.mtime.toISOString().replace("T", " ").slice(0, 16);
+    console.log(
+      `  ${s.name.padEnd(22)} ${String(s.messageCount).padStart(6)}  ${sizeKb.padStart(8)}  ${when}`,
+    );
+  }
+  console.log("");
+  console.log("Inspect:  reasonix sessions <name>");
+  console.log("Resume:   reasonix chat --session <name>");
+}
+
+function inspectSession(name: string, verbose: boolean): void {
+  const path = sessionPath(name);
+  const messages = loadSessionMessages(name);
+  if (messages.length === 0) {
+    console.error(`no session named "${name}" (or it's empty).`);
+    console.error(`looked at: ${path}`);
+    process.exit(1);
+  }
+
+  console.log(`[session] ${name}   ${messages.length} messages   ${path}`);
+  console.log("");
+
+  let turnIndex = 0;
+  for (const msg of messages) {
+    renderMessage(msg, turnIndex, verbose);
+    // Roughly bump "turn" after each user message so the reader can follow
+    // the conversation shape without the transcript's richer turn numbering.
+    if (msg.role === "user") turnIndex++;
+  }
+}
+
+function renderMessage(msg: ChatMessage, turnIdx: number, verbose: boolean): void {
+  const turn = turnIdx > 0 ? `[t${turnIdx}]` : "[start]";
+  const content = typeof msg.content === "string" ? msg.content : "";
+  const flat = oneLine(content);
+
+  if (msg.role === "user") {
+    console.log(`${turn} USER: ${flat}`);
+  } else if (msg.role === "assistant") {
+    console.log(`${turn} AGENT: ${flat || "(tool call only)"}`);
+    if (verbose && msg.tool_calls?.length) {
+      for (const tc of msg.tool_calls) {
+        console.log(
+          `         → call ${tc.function?.name} ${truncate(tc.function?.arguments ?? "", 80)}`,
+        );
+      }
+    }
+  } else if (msg.role === "tool") {
+    console.log(`${turn} TOOL ${msg.name ?? "?"}: ${truncate(flat, 160)}`);
+  } else if (msg.role === "system") {
+    if (verbose) console.log(`${turn} SYSTEM: ${truncate(flat, 160)}`);
+    // otherwise suppress — session's system prompt is usually session-wide
+    // boilerplate.
+  }
+}
+
+function oneLine(s: string, max = 200): string {
+  const collapsed = s.replace(/\s+/g, " ").trim();
+  return collapsed.length > max ? `${collapsed.slice(0, max)}…` : collapsed;
+}
+
+function truncate(s: string, max: number): string {
+  return s.length <= max ? s : `${s.slice(0, max)}…`;
+}

src/cli/commands/setup.tsx

@@ -0,0 +1,45 @@
+/**
+ * `reasonix setup` — re-mount the first-run wizard on demand so users
+ * can reconfigure (add/remove MCP servers, switch preset) without
+ * editing JSON by hand.
+ *
+ * Invoked both explicitly (`reasonix setup`) and implicitly (the no-args
+ * entry point when `setupCompleted` is false).
+ */
+
+import { render } from "ink";
+import React from "react";
+import { loadApiKey, readConfig } from "../../config.js";
+import { loadDotenv } from "../../env.js";
+import { Wizard } from "../ui/Wizard.js";
+
+export interface SetupOptions {
+  /**
+   * When true, bypass the API-key step even if no key is saved — useful
+   * from test harnesses. Normal CLI use always pushes through the key
+   * step when missing.
+   */
+  skipKeyStep?: boolean;
+}
+
+export async function setupCommand(_opts: SetupOptions = {}): Promise<void> {
+  loadDotenv();
+  const existingKey = loadApiKey();
+  const existing = readConfig();
+
+  const { waitUntilExit, unmount } = render(
+    <Wizard
+      existingApiKey={existingKey}
+      initial={{ preset: existing.preset, mcp: existing.mcp }}
+      onComplete={() => {
+        // Ink handles its own enter-to-exit inside the "saved" step; we
+        // just wait for the app to exit naturally.
+      }}
+      onCancel={() => {
+        unmount();
+      }}
+    />,
+    { exitOnCtrlC: true, patchConsole: false },
+  );
+  await waitUntilExit();
+}

src/cli/commands/update.ts

@@ -0,0 +1,143 @@
+/**
+ * `reasonix update` — self-upgrade command.
+ *
+ * Talks to the npm registry, compares against the running version,
+ * and either runs `npm install -g reasonix@latest` (global install)
+ * or advises how to refresh the npx cache (ephemeral install).
+ *
+ * The decision logic is factored into `planUpdate()` so it can be
+ * unit-tested without spawning child processes or hitting the
+ * network. `updateCommand()` is the thin CLI wrapper that calls
+ * `getLatestVersion`, passes the result into `planUpdate`, and
+ * executes any suggested command.
+ */
+
+import { spawn } from "node:child_process";
+import { VERSION, compareVersions, getLatestVersion, isNpxInstall } from "../../version.js";
+
+export type UpdateAction = "up-to-date" | "newer-local" | "npx-hint" | "run-npm-install";
+
+export interface UpdatePlan {
+  action: UpdateAction;
+  /** Human-readable summary; the CLI prints this verbatim. */
+  message: string;
+  /**
+   * Argv for the install command when `action === "run-npm-install"`.
+   * Absent otherwise. Kept as array so the CLI can pass it straight
+   * to `spawn` without re-parsing shell syntax.
+   */
+  command?: string[];
+}
+
+export interface PlanUpdateInput {
+  current: string;
+  latest: string;
+  /** Overrides `isNpxInstall()` (tests). */
+  npx?: boolean;
+}
+
+/**
+ * Pure decision function: given current + latest + install kind,
+ * decide what the CLI should do. No I/O.
+ *
+ *   newer-local     — current > latest (dev build, local publish)
+ *   up-to-date      — current === latest
+ *   npx-hint        — current < latest AND running under npx
+ *   run-npm-install — current < latest AND running as a real install
+ */
+export function planUpdate(input: PlanUpdateInput): UpdatePlan {
+  const diff = compareVersions(input.current, input.latest);
+  if (diff > 0) {
+    return {
+      action: "newer-local",
+      message: `current (${input.current}) is newer than the published ${input.latest} — nothing to do.`,
+    };
+  }
+  if (diff === 0) {
+    return { action: "up-to-date", message: `reasonix ${input.current} is up to date.` };
+  }
+  if (input.npx) {
+    return {
+      action: "npx-hint",
+      message: [
+        `reasonix ${input.latest} is available.`,
+        "you're running via npx — the next `npx reasonix ...` launch will auto-fetch",
+        "the latest (npx caches packages for a short window). to force a refresh",
+        "sooner, clear the cache: `npm cache clean --force`.",
+      ].join("\n"),
+    };
+  }
+  return {
+    action: "run-npm-install",
+    message: `upgrading reasonix ${input.current} → ${input.latest}`,
+    command: ["npm", "install", "-g", "reasonix@latest"],
+  };
+}
+
+export interface UpdateCommandOptions {
+  /** Skip spawning npm; print the decision only. */
+  dryRun?: boolean;
+  /** Test seam: override the registry lookup. Returns null = offline. */
+  fetchLatest?: () => Promise<string | null>;
+  /** Test seam: override the npx detector. */
+  isNpx?: () => boolean;
+  /** Test seam: override the spawner. Must return exit code. */
+  spawnInstall?: (argv: string[]) => Promise<number>;
+  /** Test seam: stdout writer. */
+  write?: (msg: string) => void;
+  /** Test seam: process exit — tests don't want to tear down vitest. */
+  exit?: (code: number) => void;
+}
+
+function defaultSpawn(argv: string[]): Promise<number> {
+  return new Promise((resolve, reject) => {
+    // `shell: true` on Windows is what lets `npm` resolve to `npm.cmd`
+    // without routing through our `prepareSpawn` helper. The args here
+    // are literal strings under our control — no user input flows in,
+    // so injection is not a concern. Avoiding `prepareSpawn` keeps
+    // this command free of a dep on the shell tools module.
+    const child = spawn(argv[0]!, argv.slice(1), {
+      stdio: "inherit",
+      shell: process.platform === "win32",
+    });
+    child.once("error", reject);
+    child.once("exit", (code) => resolve(code ?? 1));
+  });
+}
+
+/**
+ * Run the update command. Prints a banner, resolves the latest
+ * version, prints the plan, and (unless `--dry-run`) executes the
+ * install when applicable.
+ */
+export async function updateCommand(opts: UpdateCommandOptions = {}): Promise<void> {
+  const write = opts.write ?? ((m: string) => process.stdout.write(m));
+  const exit = opts.exit ?? ((c: number) => process.exit(c));
+  const fetchLatest = opts.fetchLatest ?? (() => getLatestVersion({ force: true }));
+  const isNpx = opts.isNpx ?? isNpxInstall;
+  const doSpawn = opts.spawnInstall ?? defaultSpawn;
+
+  write(`current: reasonix ${VERSION}\n`);
+  const latest = await fetchLatest();
+  if (!latest) {
+    write("could not reach registry.npmjs.org — check your network.\n");
+    exit(1);
+    return;
+  }
+  write(`latest:  reasonix ${latest}\n`);
+
+  const plan = planUpdate({ current: VERSION, latest, npx: isNpx() });
+  write(`\n${plan.message}\n`);
+
+  if (plan.action !== "run-npm-install" || !plan.command) return;
+  if (opts.dryRun) {
+    write(`(dry run) would run: ${plan.command.join(" ")}\n`);
+    return;
+  }
+  write(`\nrunning: ${plan.command.join(" ")}\n`);
+  const code = await doSpawn(plan.command);
+  if (code !== 0) {
+    write(`\nnpm exited with code ${code}. upgrade did not complete.\n`);
+    exit(code);
+  }
+}

src/cli/index.ts

@@ -1,11 +1,20 @@
 import { Command } from "commander";
+import { readConfig } from "../config.js";
 import { VERSION } from "../index.js";
+import { applyMemoryStack } from "../user-memory.js";
 import { chatCommand } from "./commands/chat.js";
+import { codeCommand } from "./commands/code.js";
 import { diffCommand } from "./commands/diff.js";
+import { mcpInspectCommand } from "./commands/mcp-inspect.js";
+import { mcpListCommand } from "./commands/mcp.js";
 import { replayCommand } from "./commands/replay.js";
 import { runCommand } from "./commands/run.js";
+import { sessionsCommand } from "./commands/sessions.js";
+import { setupCommand } from "./commands/setup.js";
 import { statsCommand } from "./commands/stats.js";
+import { updateCommand } from "./commands/update.js";
 import { versionCommand } from "./commands/version.js";
+import { resolveDefaults } from "./resolve.js";
 
 const DEFAULT_SYSTEM =
   "You are Reasonix, a helpful DeepSeek-powered assistant. Be concise and accurate. Use tools when available.";
@@ -16,55 +25,157 @@ program
   .description("DeepSeek-native agent framework — built for cache hits and cheap tokens.")
   .version(VERSION);
 
+// `reasonix` with no subcommand → launch the friendliest flow.
+// First run (no config yet) → interactive setup wizard.
+// Otherwise → chat with saved defaults. This is the "one command to
+// rule them all" entry for non-power-users: they don't need to learn
+// `chat` / `setup` / `--mcp` — just type `reasonix`.
+program.action(async () => {
+  const cfg = readConfig();
+  if (!cfg.setupCompleted) {
+    await setupCommand({});
+    return;
+  }
+  const defaults = resolveDefaults({});
+  await chatCommand({
+    model: defaults.model,
+    system: applyMemoryStack(DEFAULT_SYSTEM, process.cwd()),
+    harvest: defaults.harvest,
+    branch: defaults.branch,
+    session: defaults.session,
+    mcp: defaults.mcp,
+  });
+});
+
+program
+  .command("setup")
+  .description("Interactive wizard — API key, preset, MCP servers. Re-run any time to reconfigure.")
+  .action(async () => {
+    await setupCommand({});
+  });
+
+program
+  .command("code [dir]")
+  .description(
+    "Code-editing chat — filesystem MCP auto-bridged at <dir> (default: cwd), coding system prompt, smart preset. Model proposes SEARCH/REPLACE blocks; Reasonix applies them to disk.",
+  )
+  .option("-m, --model <id>", "Override default reasoner model")
+  .option("--no-session", "Disable session persistence for this run")
+  .option("-r, --resume", "Skip the session picker — always continue prior messages")
+  .option("-n, --new", "Skip the session picker — always wipe prior messages and start fresh")
+  .option("--transcript <path>", "Write a JSONL transcript to this path")
+  .action(async (dir: string | undefined, opts) => {
+    await codeCommand({
+      dir,
+      model: opts.model,
+      noSession: opts.session === false,
+      transcript: opts.transcript,
+      forceResume: !!opts.resume,
+      forceNew: !!opts.new,
+    });
+  });
+
 program
   .command("chat")
   .description("Interactive Ink TUI with live cache/cost panel.")
-  .option("-m, --model <id>", "DeepSeek model id", "deepseek-chat")
+  .option("-m, --model <id>", "DeepSeek model id (overrides preset)")
   .option("-s, --system <prompt>", "System prompt (pinned in the immutable prefix)", DEFAULT_SYSTEM)
   .option("--transcript <path>", "Write a JSONL transcript to this path")
+  .option(
+    "--preset <name>",
+    "Bundle of model + harvest + branch. One of: fast, smart, max. Overrides config.preset.",
+  )
   .option(
     "--harvest",
-    "Extract typed plan state from R1 reasoning (Pillar 2, adds a cheap V3 call per turn)",
+    "Extract typed plan state from R1 reasoning (Pillar 2). Overrides preset's harvest setting.",
   )
   .option(
     "--branch <n>",
     "Self-consistency: run N parallel samples per turn and pick the most confident (disables streaming; enables harvest)",
     (v) => Number.parseInt(v, 10),
   )
-  .option(
-    "--session <name>",
-    "Use a named session (default: 'default'). Resume the same session next time.",
-  )
+  .option("--session <name>", "Use a named session (default: from config, usually 'default').")
   .option("--no-session", "Disable session persistence for this run (ephemeral chat)")
+  .option("-r, --resume", "Skip the session picker — always continue prior messages")
+  .option("-n, --new", "Skip the session picker — always wipe prior messages and start fresh")
+  .option(
+    "--mcp <spec>",
+    'MCP server spec; repeatable. "name=cmd args...", "cmd args...", or a URL (http/https → SSE transport). Overrides config.mcp when provided.',
+    (value: string, previous: string[] = []) => [...previous, value],
+    [] as string[],
+  )
+  .option(
+    "--mcp-prefix <str>",
+    "Global prefix applied to every MCP tool (only honored when no per-spec name is set; avoids collisions with a single anonymous server)",
+  )
+  .option("--no-config", "Ignore `~/.reasonix/config.json` — useful for CI or reproducing issues")
   .action(async (opts) => {
-    // Default behavior: every chat is auto-saved to a session named 'default'
-    // and auto-resumed next launch. Pass --no-session to opt out, or
-    // --session <name> to use a different session.
-    let session: string | undefined;
-    if (opts.session === false) {
-      session = undefined; // --no-session
-    } else if (typeof opts.session === "string" && opts.session.length > 0) {
-      session = opts.session;
-    } else {
-      session = "default";
-    }
-    await chatCommand({
+    const defaults = resolveDefaults({
       model: opts.model,
-      system: opts.system,
+      harvest: opts.harvest,
+      branch: opts.branch,
+      mcp: opts.mcp as string[],
+      session: opts.session,
+      preset: opts.preset,
+      noConfig: opts.config === false,
+    });
+    await chatCommand({
+      model: defaults.model,
+      system: applyMemoryStack(opts.system, process.cwd()),
       transcript: opts.transcript,
-      harvest: !!opts.harvest,
-      branch: Number.isFinite(opts.branch) && opts.branch > 1 ? opts.branch : undefined,
-      session,
+      harvest: defaults.harvest,
+      branch: defaults.branch,
+      session: defaults.session,
+      mcp: defaults.mcp,
+      mcpPrefix: opts.mcpPrefix,
+      forceResume: !!opts.resume,
+      forceNew: !!opts.new,
     });
   });
 
 program
   .command("run <task>")
   .description("Run a single task non-interactively, streaming output.")
-  .option("-m, --model <id>", "DeepSeek model id", "deepseek-chat")
+  .option("-m, --model <id>", "DeepSeek model id (overrides preset)")
   .option("-s, --system <prompt>", "System prompt", DEFAULT_SYSTEM)
+  .option("--preset <name>", "Bundle of model + harvest + branch: fast | smart | max")
+  .option("--harvest", "Extract typed plan state from R1 reasoning (Pillar 2)")
+  .option(
+    "--branch <n>",
+    "Self-consistency: run N parallel samples per turn and pick the most confident",
+    (v) => Number.parseInt(v, 10),
+  )
+  .option("--transcript <path>", "Write a JSONL transcript to this path for replay/diff")
+  .option(
+    "--mcp <spec>",
+    'MCP server spec; repeatable. "name=cmd args...", "cmd args...", or a URL (http/https → SSE).',
+    (value: string, previous: string[] = []) => [...previous, value],
+    [] as string[],
+  )
+  .option(
+    "--mcp-prefix <str>",
+    "Global prefix (only honored when no per-spec name is set; for a single anonymous server)",
+  )
+  .option("--no-config", "Ignore `~/.reasonix/config.json` — useful for CI or reproducing issues")
   .action(async (task: string, opts) => {
-    await runCommand({ task, model: opts.model, system: opts.system });
+    const defaults = resolveDefaults({
+      model: opts.model,
+      harvest: opts.harvest,
+      branch: opts.branch,
+      mcp: opts.mcp as string[],
+      preset: opts.preset,
+      noConfig: opts.config === false,
+    });
+    await runCommand({
+      task,
+      model: defaults.model,
+      system: applyMemoryStack(opts.system, process.cwd()),
+      harvest: defaults.harvest,
+      branch: defaults.branch,
+      transcript: opts.transcript,
+      mcp: defaults.mcp,
+      mcpPrefix: opts.mcpPrefix,
+    });
   });
 
 program
@@ -74,6 +185,14 @@ program
     statsCommand({ transcript });
   });
 
+program
+  .command("sessions [name]")
+  .description("List saved chat sessions, or inspect one by name.")
+  .option("-v, --verbose", "Include system prompts + tool-call metadata when inspecting")
+  .action((name: string | undefined, opts) => {
+    sessionsCommand({ name, verbose: !!opts.verbose });
+  });
+
 program
   .command("replay <transcript>")
   .description(
@@ -113,8 +232,45 @@ program
     });
   });
 
+const mcp = program
+  .command("mcp")
+  .description("Model Context Protocol helpers — discover servers, test your setup.");
+
+mcp
+  .command("list")
+  .description("Show a curated catalog of popular MCP servers with ready-to-use --mcp commands.")
+  .option("--json", "Emit the catalog as JSON instead of the human-readable table")
+  .action((opts) => {
+    mcpListCommand({ json: !!opts.json });
+  });
+
+mcp
+  .command("inspect <spec>")
+  .description(
+    'Connect to one MCP server and print its server info + tools/resources/prompts. <spec> takes the same forms as --mcp ("name=cmd args", "cmd args", or an SSE URL).',
+  )
+  .option("--json", "Emit the full inspection report as JSON instead of the human-readable summary")
+  .action(async (spec: string, opts) => {
+    try {
+      await mcpInspectCommand({ spec, json: !!opts.json });
+    } catch (err) {
+      process.stderr.write(`mcp inspect failed: ${(err as Error).message}\n`);
+      process.exit(1);
+    }
+  });
+
 program.command("version").description("Print Reasonix version.").action(versionCommand);
 
+program
+  .command("update")
+  .description(
+    "Check the npm registry for a newer Reasonix and install it. Detects npx vs global install; for npx users, prints a cache-refresh hint instead of running `npm i -g`.",
+  )
+  .option("--dry-run", "Print the plan without executing the install")
+  .action(async (opts: { dryRun?: boolean }) => {
+    await updateCommand({ dryRun: !!opts.dryRun });
+  });
+
 program.parseAsync(process.argv).catch((err) => {
   console.error(err);
   process.exit(1);

src/cli/resolve.ts

@@ -0,0 +1,89 @@
+/**
+ * Merge config defaults with CLI flags into the concrete options that
+ * `chatCommand` / `runCommand` need.
+ *
+ * Precedence (highest wins):
+ *   1. Explicit per-setting CLI flag (`--model`, `--harvest`, `--branch`, `--mcp`)
+ *   2. Explicit `--preset <name>` CLI flag
+ *   3. `config.preset` from `~/.reasonix/config.json` (set by `reasonix setup`)
+ *   4. Hardcoded "fast" preset defaults
+ *
+ * Keeping this logic in one place — rather than duplicating across
+ * `chat` and `run` — means the precedence rule only lives in one unit
+ * test and the shape of the merge is identical for both commands.
+ */
+
+import { type PresetName, type ReasonixConfig, readConfig } from "../config.js";
+import { PRESETS } from "./ui/presets.js";
+
+export interface ResolvedDefaults {
+  model: string;
+  harvest: boolean;
+  branch: number | undefined;
+  mcp: string[];
+  session: string | undefined;
+}
+
+export interface RawCliFlags {
+  model?: string;
+  harvest?: boolean;
+  /** From `commander`; already parseInt'd. */
+  branch?: number;
+  mcp?: string[];
+  /** Commander's `--no-session` surfaces as `false`; `--session X` as a string. */
+  session?: string | false;
+  /** `--preset <name>`. */
+  preset?: string;
+  /** When true, ignore config entirely (power-user escape hatch). */
+  noConfig?: boolean;
+}
+
+export function resolveDefaults(flags: RawCliFlags): ResolvedDefaults {
+  const cfg: ReasonixConfig = flags.noConfig ? {} : readConfig();
+  const preset = pickPreset(flags.preset, cfg.preset);
+  const presetSettings = PRESETS[preset];
+
+  const model = flags.model ?? presetSettings.model;
+  const harvest = flags.harvest === true ? true : presetSettings.harvest;
+  const branchFromFlag = normalizeBranch(flags.branch);
+  const branch = branchFromFlag ?? (presetSettings.branch > 1 ? presetSettings.branch : undefined);
+
+  // `--mcp` accumulator is [] when absent. Treat empty from flags as
+  // "user didn't pass" → fall through to config. Users who explicitly
+  // want zero MCP servers can pass `--no-config` or edit the file.
+  const mcp = flags.mcp && flags.mcp.length > 0 ? flags.mcp : (cfg.mcp ?? []);
+
+  const session = resolveSession(flags.session, cfg.session);
+
+  return { model, harvest, branch, mcp, session };
+}
+
+function pickPreset(
+  flagPreset: string | undefined,
+  configPreset: PresetName | undefined,
+): PresetName {
+  if (flagPreset && isPresetName(flagPreset)) return flagPreset;
+  if (configPreset) return configPreset;
+  return "fast";
+}
+
+function isPresetName(s: string): s is PresetName {
+  return s === "fast" || s === "smart" || s === "max";
+}
+
+function normalizeBranch(raw: number | undefined): number | undefined {
+  if (raw === undefined) return undefined;
+  if (!Number.isFinite(raw) || raw <= 1) return undefined;
+  return Math.min(raw, 8);
+}
+
+function resolveSession(
+  flag: string | false | undefined,
+  configSession: string | null | undefined,
+): string | undefined {
+  if (flag === false) return undefined; // --no-session
+  if (typeof flag === "string" && flag.length > 0) return flag;
+  if (configSession === null) return undefined; // config opted out
+  if (typeof configSession === "string" && configSession.length > 0) return configSession;
+  return "default";
+}

src/cli/ui/EventLog.tsx

@@ -1,11 +1,13 @@
 import { Box, Text } from "ink";
-import React, { useEffect, useState } from "react";
+import React from "react";
 import { type TypedPlanState, isPlanStateEmpty } from "../../harvest.js";
 import type { BranchProgress, BranchSummary } from "../../loop.js";
 import type { TurnStats } from "../../telemetry.js";
+import { PlanStateBlock } from "./PlanStateBlock.js";
 import { Markdown } from "./markdown.js";
+import { useElapsedSeconds, useTick } from "./ticker.js";
 
-export type DisplayRole = "user" | "assistant" | "tool" | "system" | "error" | "info";
+export type DisplayRole = "user" | "assistant" | "tool" | "system" | "error" | "info" | "warning";
 
 export interface DisplayEvent {
   id: string;
@@ -19,6 +21,7 @@ export interface DisplayEvent {
   stats?: TurnStats;
   repair?: string;
   streaming?: boolean;
+  toolCallBuild?: { name: string; chars: number };
 }
 
 export const EventRow = React.memo(function EventRow({ event }: { event: DisplayEvent }) {
@@ -53,10 +56,32 @@ export const EventRow = React.memo(function EventRow({ event }: { event: Display
     );
   }
   if (event.role === "tool") {
+    // `flattenMcpResult` prefixes server-side errors with "ERROR: ".
+    // Render those in red with a ✗ marker so they don't blend into
+    // successful tool output (yellow) — the failure mode is what the
+    // model most likely needs to act on next, and the user needs to
+    // see at a glance.
+    const isError = event.text.startsWith("ERROR:");
+    const color = isError ? "red" : "yellow";
+    const marker = isError ? "✗" : "→";
+    // `edit_file` results get a dedicated diff renderer — colored
+    // line-by-line so `-` removals show red, `+` additions show
+    // green, unchanged context lines dim. Always full, never
+    // truncated: users need to see the whole change to trust
+    // /apply. Other tools keep the 400-char clip + /tool N escape.
+    const isEditFile =
+      (event.toolName === "edit_file" || event.toolName?.endsWith("_edit_file")) && !isError;
     return (
       <Box flexDirection="column" marginTop={1}>
-        <Text color="yellow">{`tool<${event.toolName ?? "?"}>  →`}</Text>
-        <Text dimColor> {truncate(event.text, 400)}</Text>
+        <Text color={color}>{`tool<${event.toolName ?? "?"}>  ${marker}`}</Text>
+        {isEditFile ? (
+          <EditFileDiff text={event.text} />
+        ) : (
+          <Text color={isError ? "red" : undefined} dimColor={!isError}>
+            {" "}
+            {truncate(event.text, 400)}
+          </Text>
+        )}
       </Box>
     );
   }
@@ -77,6 +102,14 @@ export const EventRow = React.memo(function EventRow({ event }: { event: Display
       </Box>
     );
   }
+  if (event.role === "warning") {
+    return (
+      <Box>
+        <Text color="yellow">▸ </Text>
+        <Text color="yellow">{event.text}</Text>
+      </Box>
+    );
+  }
   return (
     <Box>
       <Text>{event.text}</Text>
@@ -84,6 +117,61 @@ export const EventRow = React.memo(function EventRow({ event }: { event: Display
   );
 });
 
+/**
+ * Render the payload of an `edit_file` tool result with proper
+ * diff coloring: first line is the header ("edited X (A→B chars)"),
+ * subsequent lines are prefixed with `-` (removed), `+` (added), or
+ * space (unchanged context). Unchanged lines render dim so the
+ * changed ones pop visually. No truncation — the whole diff is
+ * shown so the user can audit what landed before `/apply` or
+ * `git diff` review.
+ */
+function EditFileDiff({ text }: { text: string }) {
+  const lines = text.split(/\r?\n/);
+  // Line 0 is the status header ("edited X (A→B chars)"), Line 1 is
+  // the unified-diff hunk header ("@@ -N,M +N,M @@"), the rest is
+  // the colored diff body. We style the two headers distinctly so
+  // the hunk marker stands out the way git-diff's cyan `@@` does in
+  // most terminals.
+  const [statusHeader, hunkHeader, ...body] = lines;
+  return (
+    <Box flexDirection="column">
+      <Text dimColor>{` ${statusHeader ?? ""}`}</Text>
+      {hunkHeader !== undefined ? (
+        <Text color="cyan" bold>
+          {hunkHeader}
+        </Text>
+      ) : null}
+      {body.map((line, i) => {
+        // Key includes the line content slice so React isn't forced
+        // to treat purely-positional identity; lines in the same
+        // diff don't reorder but could repeat (e.g. blank lines).
+        const key = `${i}-${line.slice(0, 32)}`;
+        if (line.startsWith("- ")) {
+          return (
+            <Text key={key} color="red">
+              {line}
+            </Text>
+          );
+        }
+        if (line.startsWith("+ ")) {
+          return (
+            <Text key={key} color="green">
+              {line}
+            </Text>
+          );
+        }
+        // Context line (starts with "  ") or unknown — dim.
+        return (
+          <Text key={key} dimColor>
+            {line}
+          </Text>
+        );
+      })}
+    </Box>
+  );
+}
+
 function BranchBlock({ branch }: { branch: BranchSummary }) {
   const per = branch.uncertainties
     .map((u, i) => {
@@ -104,30 +192,16 @@ function BranchBlock({ branch }: { branch: BranchSummary }) {
   );
 }
 
-function PlanStateBlock({ planState }: { planState: TypedPlanState }) {
-  const lines: Array<[string, string[]]> = [];
-  if (planState.subgoals.length) lines.push(["subgoals", planState.subgoals]);
-  if (planState.hypotheses.length) lines.push(["hypotheses", planState.hypotheses]);
-  if (planState.uncertainties.length) lines.push(["uncertainties", planState.uncertainties]);
-  if (planState.rejectedPaths.length) lines.push(["rejected", planState.rejectedPaths]);
-  return (
-    <Box flexDirection="column" marginBottom={1}>
-      {lines.map(([label, items]) => (
-        <Text key={label} color="magenta">
-          {"‹ "}
-          <Text bold>{label}</Text>
-          {` (${items.length}): ${items.join(" · ")}`}
-        </Text>
-      ))}
-    </Box>
-  );
-}
-
 function ReasoningBlock({ reasoning }: { reasoning: string }) {
-  const max = 220;
+  const max = 260;
   const flat = reasoning.replace(/\s+/g, " ").trim();
+  // Show the TAIL of the reasoning rather than the head. R1 opens
+  // with generic scaffolding ("let me look at the structure...") that
+  // repeats across turns and hides the part users actually want to
+  // see — the decision right before the model commits to an action.
+  // Users can dump the full reasoning with `/think` if needed.
   const preview =
-    flat.length <= max ? flat : `${flat.slice(0, max)}… (+${flat.length - max} chars)`;
+    flat.length <= max ? flat : `… (+${flat.length - max} earlier chars) ${flat.slice(-max)}`;
   return (
     <Box marginBottom={1}>
       <Text dimColor italic>
@@ -144,12 +218,7 @@ function ReasoningBlock({ reasoning }: { reasoning: string }) {
  * the terminal viewport and leaves artifacts in scrollback.
  */
 function Elapsed() {
-  const [s, setS] = useState(0);
-  useEffect(() => {
-    const start = Date.now();
-    const id = setInterval(() => setS(Math.floor((Date.now() - start) / 1000)), 1000);
-    return () => clearInterval(id);
-  }, []);
+  const s = useElapsedSeconds();
   const mm = String(Math.floor(s / 60)).padStart(2, "0");
   const ss = String(s % 60).padStart(2, "0");
   return <Text dimColor>{`${mm}:${ss}`}</Text>;
@@ -202,16 +271,49 @@ function StreamingAssistant({ event }: { event: DisplayEvent }) {
 
   const tail = lastLine(event.text, 140);
   const reasoningTail = event.reasoning ? lastLine(event.reasoning, 120) : "";
+  const toolCallBuild = event.toolCallBuild;
+  // Four distinct phases a turn can be in — label them plainly so
+  // the user doesn't have to decode "streaming · 391 + think 4506
+  // chars" to figure out what's happening:
+  //   pre-first-byte: request in flight, no bytes back yet
+  //   reasoning-only: R1 thinking, no visible content yet
+  //   tool-call-only: tool_call arguments streaming, no content/reasoning bytes
+  //   writing: content streaming (R1 has already produced its thought)
+  //   both: rare — content present AND reasoning still growing
+  // We can't cheaply distinguish "reasoning still growing" from
+  // "reasoning finished but we already saw it", so when content is
+  // present we just say "writing response" and surface both counts.
+  const preFirstByte = !event.text && !event.reasoning && !toolCallBuild;
+  const reasoningOnly = !event.text && !!event.reasoning && !toolCallBuild;
+  const toolCallOnly = !event.text && !event.reasoning && !!toolCallBuild;
+  let label: string;
+  let labelColor: "yellow" | "cyan" | "green" | "magenta" | undefined;
+  if (preFirstByte) {
+    label = "request sent · waiting for server";
+    labelColor = "yellow";
+  } else if (reasoningOnly) {
+    label = `R1 reasoning · ${event.reasoning?.length ?? 0} chars of thought`;
+    labelColor = "cyan";
+  } else if (toolCallOnly) {
+    label = `assembling tool call <${toolCallBuild.name}> · ${toolCallBuild.chars} chars of arguments`;
+    labelColor = "magenta";
+  } else {
+    const parts: string[] = [`writing response · ${event.text.length} chars`];
+    if (event.reasoning) parts.push(`after ${event.reasoning.length} chars of reasoning`);
+    if (toolCallBuild) {
+      parts.push(`building tool call <${toolCallBuild.name}> · ${toolCallBuild.chars} chars`);
+    }
+    label = parts.join(" · ");
+    labelColor = "green";
+  }
   return (
     <Box flexDirection="column" marginTop={1}>
       <Box>
         <Text bold color="green">
           assistant{" "}
         </Text>
-        <Text dimColor>
-          (streaming · {event.text.length}
-          {event.reasoning ? ` + think ${event.reasoning.length}` : ""} chars){" "}
-        </Text>
+        <Pulse />
+        <Text color={labelColor}>{` ${label} `}</Text>
         <Elapsed />
       </Box>
       {reasoningTail ? (
@@ -221,15 +323,41 @@ function StreamingAssistant({ event }: { event: DisplayEvent }) {
       ) : null}
       {tail ? (
         <Text dimColor>▸ {tail}</Text>
-      ) : (
+      ) : preFirstByte ? (
         <Text dimColor italic>
-          {"  (waiting for first token…)"}
+          {"  connection open, first byte typically in 5-60s depending on model + load"}
         </Text>
-      )}
+      ) : reasoningOnly ? (
+        <Text color="yellow" dimColor>
+          {
+            "  R1 is thinking before it speaks — body text starts when reasoning completes (typically 20-90s)."
+          }
+        </Text>
+      ) : toolCallOnly ? (
+        <Text color="magenta" dimColor>
+          {"  tool-call arguments streaming — the model is about to dispatch a tool"}
+        </Text>
+      ) : event.reasoning ? (
+        <Text color="yellow" dimColor>
+          {"  R1 still reasoning — body text or tool call arrives when thinking completes"}
+        </Text>
+      ) : null}
     </Box>
   );
 }
 
+/**
+ * Blinking indicator so the user can tell the stream is alive even
+ * when the reasoner hasn't produced body text yet. Uses the shared
+ * tick (TICK_MS ≈ 120ms) scaled down 4× so the visible blink rate
+ * lands around 500ms — feels like a heartbeat, not a progress bar.
+ */
+function Pulse() {
+  const tick = useTick();
+  const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+  return <Text color="cyan">{frames[Math.floor(tick / 4) % frames.length]}</Text>;
+}
+
 function lastLine(s: string, maxChars: number): string {
   const flat = s.replace(/\s+/g, " ").trim();
   if (!flat) return "";

src/cli/ui/PlanConfirm.tsx

@@ -0,0 +1,97 @@
+/**
+ * Modal-style approval for a `submit_plan` proposal.
+ *
+ * Three choices:
+ *   1. Approve + implement — exits plan mode, pushes a synthetic user
+ *      message telling the model to implement the plan now.
+ *   2. Refine — stays in plan mode; tells the model to explore more
+ *      and submit an improved plan.
+ *   3. Cancel — exits plan mode, drops the plan, tells the model the
+ *      user didn't want any of it.
+ *
+ * Mirrors ShellConfirm in structure (border, SingleSelect, three
+ * options, no y/n hotkey — mid-typing triggers would be painful).
+ * The plan body is rendered verbatim above the picker so the user can
+ * actually read what they're approving.
+ */
+
+import { Box, Text } from "ink";
+import React from "react";
+import { SingleSelect } from "./Select.js";
+import { Markdown } from "./markdown.js";
+
+export type PlanConfirmChoice = "approve" | "refine" | "cancel";
+
+export interface PlanConfirmProps {
+  plan: string;
+  onChoose: (choice: PlanConfirmChoice) => void;
+  /**
+   * Cap on rendered plan length. A pathological 20-KB plan would push
+   * the picker off the bottom of the terminal; we show the head +
+   * "(…N chars truncated — /tool for full output)" instead. The picker
+   * itself gets the full plan (it's already been committed to the
+   * transcript via the tool result).
+   */
+  maxRenderedChars?: number;
+}
+
+const DEFAULT_MAX_RENDERED = 2400;
+
+export function PlanConfirm({ plan, onChoose, maxRenderedChars }: PlanConfirmProps) {
+  const cap = maxRenderedChars ?? DEFAULT_MAX_RENDERED;
+  const tooLong = plan.length > cap;
+  const visible = tooLong
+    ? `${plan.slice(0, cap)}\n\n… (${plan.length - cap} chars truncated — use /tool to view the full proposal)`
+    : plan;
+  // Crude signal for "the model left questions or risks for me" — the
+  // typical section headings. Triggers an extra hint toward the Refine
+  // option so users know where to answer them.
+  const hasOpenQuestions =
+    /^#{1,6}\s*(open[-\s]?questions?|risks?|unknowns?|assumptions?|unclear)/im.test(plan) ||
+    /^#{1,6}\s*(待确认|开放问题|风险|未知|假设|不确定)/im.test(plan);
+
+  return (
+    <Box flexDirection="column" borderStyle="round" borderColor="cyan" paddingX={1} marginY={1}>
+      <Box>
+        <Text bold color="cyan">
+          ▸ plan submitted — awaiting your review
+        </Text>
+      </Box>
+      <Box marginTop={1} flexDirection="column">
+        <Markdown text={visible} />
+      </Box>
+      {hasOpenQuestions ? (
+        <Box marginTop={1}>
+          <Text color="yellow">
+            ▲ the plan has open questions or flagged risks — pick{" "}
+            <Text bold>Refine / answer questions</Text> to write concrete answers before the model
+            moves on.
+          </Text>
+        </Box>
+      ) : null}
+      <Box marginTop={1}>
+        <SingleSelect
+          initialValue={hasOpenQuestions ? "refine" : "approve"}
+          items={[
+            {
+              value: "approve",
+              label: "Approve and implement",
+              hint: "Exit plan mode. The model starts executing. You'll get a text input to add any last instructions (or just press Enter to skip).",
+            },
+            {
+              value: "refine",
+              label: "Refine / answer questions",
+              hint: "Stay in plan mode. Write answers, modifications, or critiques; the model revises and re-submits.",
+            },
+            {
+              value: "cancel",
+              label: "Cancel",
+              hint: "Exit plan mode. Drop the plan; the model won't implement it.",
+            },
+          ]}
+          onSubmit={(v) => onChoose(v as PlanConfirmChoice)}
+        />
+      </Box>
+    </Box>
+  );
+}

src/cli/ui/PlanRefineInput.tsx

@@ -0,0 +1,91 @@
+/**
+ * Inline text input shown after the user picks Approve or Refine in
+ * PlanConfirm. Collects free-form feedback before the loop resumes.
+ *
+ * Why both paths: the plan may contain open questions or risks the
+ * model asked the user to weigh in on. If the user just picks Approve
+ * with no chance to answer, the model implements against its own
+ * guesses. This input lets the user answer questions, pass last-minute
+ * constraints, or (on Refine) request concrete changes. Empty input is
+ * fine for Approve (skip straight to implement) and triggers a
+ * "ask the user clarifying questions" path for Refine.
+ *
+ * Kept minimal: single-line prompt, Enter to submit, Esc to return to
+ * the picker without resuming.
+ */
+
+import { Box, Text, useInput } from "ink";
+import React, { useState } from "react";
+
+export interface PlanRefineInputProps {
+  /**
+   * Which path the user is on. Approve = "implement with these last
+   * instructions"; refine = "revise the plan with this feedback".
+   * Drives the header + hint text so users know what kind of message
+   * they're writing.
+   */
+  mode: "approve" | "refine";
+  /** Called with trimmed feedback. Empty string is allowed. */
+  onSubmit: (feedback: string) => void;
+  /** Called when the user presses Esc to return to the picker. */
+  onCancel: () => void;
+}
+
+export function PlanRefineInput({ mode, onSubmit, onCancel }: PlanRefineInputProps) {
+  const [value, setValue] = useState("");
+
+  useInput((input, key) => {
+    if (key.escape) {
+      onCancel();
+      return;
+    }
+    if (key.return) {
+      onSubmit(value.trim());
+      return;
+    }
+    if (key.backspace || key.delete) {
+      setValue((v) => v.slice(0, -1));
+      return;
+    }
+    // Filter out non-printable chars; accept ordinary text + CJK.
+    if (input && !key.ctrl && !key.meta) {
+      setValue((v) => v + input);
+    }
+  });
+
+  const title =
+    mode === "approve"
+      ? "▸ approving — any last instructions or answers to open questions?"
+      : "▸ refining — what should the model change?";
+  const hint =
+    mode === "approve"
+      ? "Answer questions the plan raised, add constraints, or just press Enter to approve as-is."
+      : "Describe what's wrong or missing, or answer questions the plan raised.";
+  const blankHint =
+    mode === "approve"
+      ? " (Enter with blank = approve without extra instructions.)"
+      : " (Enter with blank = ask the model to list concrete questions.)";
+
+  return (
+    <Box flexDirection="column" borderStyle="round" borderColor="yellow" paddingX={1} marginY={1}>
+      <Box>
+        <Text bold color="yellow">
+          {title}
+        </Text>
+      </Box>
+      <Box marginTop={1}>
+        <Text dimColor>
+          {hint} Enter to send · Esc to return to the picker.
+          {value === "" ? blankHint : ""}
+        </Text>
+      </Box>
+      <Box marginTop={1}>
+        <Text>
+          <Text color="yellow">› </Text>
+          <Text>{value || " "}</Text>
+          <Text color="yellow">▍</Text>
+        </Text>
+      </Box>
+    </Box>
+  );
+}

src/cli/ui/PlanStateBlock.tsx

@@ -0,0 +1,48 @@
+/**
+ * Shared Ink block that renders a TypedPlanState. Used by the live chat
+ * EventLog AND by the RecordView in replay/diff TUIs, so harvest output
+ * looks identical live and on replay.
+ *
+ * Colors are semantic (not decorative):
+ *   - subgoals:       cyan         — structure / plan
+ *   - hypotheses:     green        — current beliefs (like assistant)
+ *   - uncertainties:  yellow       — attention required (like tool)
+ *   - rejected paths: red dim      — ruled out (muted, like error-but-resolved)
+ *
+ * Only the label is colored + bold. The items themselves render in the
+ * terminal's default foreground, so they stay readable on any background —
+ * which is why the old single-magenta block was hard to see on dark themes.
+ */
+
+import { Box, Text } from "ink";
+import React from "react";
+import type { TypedPlanState } from "../../harvest.js";
+
+type FieldColor = "cyan" | "green" | "yellow" | "red";
+
+export function PlanStateBlock({ planState }: { planState: TypedPlanState }) {
+  const fields: Array<[string, string[], FieldColor, boolean]> = [];
+  if (planState.subgoals.length) fields.push(["subgoals", planState.subgoals, "cyan", false]);
+  if (planState.hypotheses.length)
+    fields.push(["hypotheses", planState.hypotheses, "green", false]);
+  if (planState.uncertainties.length)
+    fields.push(["uncertainties", planState.uncertainties, "yellow", false]);
+  if (planState.rejectedPaths.length)
+    fields.push(["rejected", planState.rejectedPaths, "red", true]);
+  if (fields.length === 0) return null;
+
+  return (
+    <Box flexDirection="column" marginBottom={1}>
+      {fields.map(([label, items, color, dim]) => (
+        <Text key={label}>
+          <Text color={color} bold dimColor={dim}>
+            {"‹ "}
+            {label}
+          </Text>
+          <Text dimColor>{` (${items.length})`}</Text>
+          <Text>{`: ${items.join(" · ")}`}</Text>
+        </Text>
+      ))}
+    </Box>
+  );
+}

src/cli/ui/PromptInput.tsx

@@ -1,6 +1,7 @@
-import { Box, Text } from "ink";
-import TextInput from "ink-text-input";
-import React from "react";
+import { Box, Text, useInput } from "ink";
+import React, { useRef, useState } from "react";
+import { type MultilineKey, lineAndColumn, processMultilineKey } from "./multiline-keys.js";
+import { useTick } from "./ticker.js";
 
 export interface PromptInputProps {
   value: string;
@@ -11,10 +12,16 @@ export interface PromptInputProps {
 }
 
 /**
- * Keep `<TextInput>` mounted at all times and use its `focus` prop to gate
- * input. Conditionally rendering it (mount / unmount between turns) loses
- * the stdin raw-mode claim on some terminals, which silently drops
- * keystrokes after the first turn finishes.
+ * Input box with real cursor support. ←/→ move one column, ↑/↓ move
+ * across lines in multi-line buffers, Ctrl+A / Ctrl+E jump to
+ * start/end of the current line. Backspace deletes before cursor,
+ * Delete deletes under cursor. Multi-line composition via Ctrl+J,
+ * Shift+Enter, or bash-style `\<Enter>`.
+ *
+ * Cursor state lives locally. When the parent replaces `value` out
+ * of band (history recall, slash completion, setup wizard) the
+ * cursor jumps to end; the `lastLocalValueRef` guards distinguishes
+ * that case from our own edits.
  */
 export function PromptInput({
   value,
@@ -23,21 +30,135 @@ export function PromptInput({
   disabled,
   placeholder,
 }: PromptInputProps) {
+  const [cursor, setCursor] = useState(value.length);
+  // Tracks the last `value` we ourselves produced via onChange. If the
+  // incoming `value` prop diverges from this, the parent (or some other
+  // source) replaced the buffer — we reset the cursor to end.
+  const lastLocalValueRef = useRef(value);
+  if (value !== lastLocalValueRef.current) {
+    lastLocalValueRef.current = value;
+    if (cursor !== value.length) {
+      // Conditional setState during render is the "derived state" pattern;
+      // React schedules the re-render and the else branch of the `if`
+      // prevents infinite loops.
+      setCursor(value.length);
+    }
+  }
+
+  // Shared ticker drives the cursor blink. Dividing the tick by 4 lands
+  // the visible on/off cycle around 480ms — standard cursor cadence.
+  const tick = useTick();
+  const showCursor = disabled ? false : Math.floor(tick / 4) % 2 === 0;
+
+  useInput(
+    (input, key) => {
+      const ke: MultilineKey = {
+        input,
+        return: key.return,
+        shift: key.shift,
+        ctrl: key.ctrl,
+        meta: key.meta,
+        backspace: key.backspace,
+        delete: key.delete,
+        tab: key.tab,
+        upArrow: key.upArrow,
+        downArrow: key.downArrow,
+        leftArrow: key.leftArrow,
+        rightArrow: key.rightArrow,
+        escape: key.escape,
+        pageUp: key.pageUp,
+        pageDown: key.pageDown,
+      };
+      const action = processMultilineKey(value, cursor, ke);
+      if (action.next !== null) {
+        lastLocalValueRef.current = action.next;
+        onChange(action.next);
+      }
+      if (action.cursor !== null) {
+        setCursor(action.cursor);
+      }
+      if (action.submit) onSubmit(action.submitValue ?? value);
+    },
+    { isActive: !disabled },
+  );
+
   const effectivePlaceholder = disabled
     ? (placeholder ?? "…waiting for response…")
-    : (placeholder ?? "type a message, or /command");
+    : (placeholder ?? "type a message, or /command · Ctrl+J for newline");
+
+  const lines = value.length > 0 ? value.split("\n") : [""];
+  const borderColor = disabled ? "gray" : "cyan";
+  const { line: cursorLine, col: cursorCol } = lineAndColumn(value, cursor);
+
   return (
-    <Box borderStyle="round" borderColor={disabled ? "gray" : "cyan"} paddingX={1}>
-      <Text bold color={disabled ? "gray" : "cyan"}>
-        you ›{" "}
-      </Text>
-      <TextInput
-        value={value}
-        onChange={onChange}
-        onSubmit={onSubmit}
-        focus={!disabled}
-        placeholder={effectivePlaceholder}
-      />
+    <Box borderStyle="round" borderColor={borderColor} paddingX={1} flexDirection="column">
+      {lines.map((line, i) => {
+        const isFirst = i === 0;
+        const showPlaceholder = isFirst && value.length === 0;
+        const isCursorLine = i === cursorLine;
+        return (
+          // biome-ignore lint/suspicious/noArrayIndexKey: stable by construction — lines are derived from `value.split("\n")` and never reordered
+          <Box key={i}>
+            {isFirst ? (
+              <Text bold color={borderColor}>
+                you ›{" "}
+              </Text>
+            ) : (
+              <Text dimColor>{"     "}</Text>
+            )}
+            {showPlaceholder ? (
+              <>
+                {isCursorLine && !disabled ? (
+                  <Text color={borderColor}>{showCursor ? "▌" : " "}</Text>
+                ) : null}
+                <Text dimColor>{effectivePlaceholder}</Text>
+              </>
+            ) : isCursorLine && !disabled ? (
+              <LineWithCursor
+                line={line}
+                col={cursorCol}
+                showCursor={showCursor}
+                borderColor={borderColor}
+              />
+            ) : (
+              <Text>{line}</Text>
+            )}
+          </Box>
+        );
+      })}
     </Box>
   );
 }
+
+function LineWithCursor({
+  line,
+  col,
+  showCursor,
+  borderColor,
+}: {
+  line: string;
+  col: number;
+  showCursor: boolean;
+  borderColor: "cyan" | "gray";
+}) {
+  const before = line.slice(0, col);
+  const atCursor = line.slice(col, col + 1);
+  const after = line.slice(col + 1);
+  if (atCursor.length === 0) {
+    // Cursor sits past the last char of this line (end-of-line). Render
+    // a trailing block so the user sees where they're typing next.
+    return (
+      <>
+        <Text>{before}</Text>
+        <Text color={borderColor}>{showCursor ? "▌" : " "}</Text>
+      </>
+    );
+  }
+  return (
+    <>
+      <Text>{before}</Text>
+      <Text inverse={showCursor}>{atCursor}</Text>
+      <Text>{after}</Text>
+    </>
+  );
+}

src/cli/ui/RecordView.tsx

@@ -11,6 +11,7 @@
 import { Box, Text } from "ink";
 import React from "react";
 import type { TranscriptRecord } from "../../transcript.js";
+import { PlanStateBlock } from "./PlanStateBlock.js";
 
 export interface RecordViewProps {
   rec: TranscriptRecord;
@@ -51,6 +52,7 @@ export function RecordView({ rec, compact = false }: RecordViewProps) {
           ) : null}
           {rec.usage ? <CacheBadge usage={rec.usage} /> : null}
         </Box>
+        {rec.planState ? <PlanStateBlock planState={rec.planState} /> : null}
         {rec.content ? (
           <Text>{rec.content}</Text>
         ) : (

src/cli/ui/ReplayApp.tsx

@@ -52,9 +52,13 @@ export function ReplayApp({ meta, pages }: ReplayAppProps) {
   const summary = {
     turns: cumStats.turns,
     totalCostUsd: cumStats.totalCostUsd,
+    totalInputCostUsd: cumStats.totalInputCostUsd,
+    totalOutputCostUsd: cumStats.totalOutputCostUsd,
     claudeEquivalentUsd: cumStats.claudeEquivalentUsd,
     savingsVsClaudePct: cumStats.savingsVsClaudePct,
     cacheHitRatio: cumStats.cacheHitRatio,
+    // Replay is read-only — no live last-turn prompt tokens to show.
+    lastPromptTokens: 0,
   };
 
   const prefixHash =

src/cli/ui/Select.tsx

@@ -0,0 +1,182 @@
+/**
+ * Minimal arrow-key list components for Ink — single-select and
+ * multi-select. No external deps beyond Ink's `useInput`.
+ *
+ * Why hand-roll: `ink-select-input` exists, but it defaults to
+ * Enter-only interaction (no space-to-toggle for multi-select), doesn't
+ * expose the "hint / footer" slot we want under each item, and would be
+ * another dep for ~60 lines of UI code. Reasonix already has one React
+ * rendering quirk bundled (`ink-text-input`); adding more is low value.
+ */
+
+import { Box, Text, useInput } from "ink";
+import React, { useState } from "react";
+
+export interface SelectItem<V extends string = string> {
+  /** Stable identifier — returned to caller on submit. */
+  value: V;
+  /** First-row label. */
+  label: string;
+  /** Optional second row rendered dimmed. */
+  hint?: string;
+  /** If true, item is not selectable (rendered dimmed, skipped on nav). */
+  disabled?: boolean;
+}
+
+export interface SingleSelectProps<V extends string> {
+  items: SelectItem<V>[];
+  initialValue?: V;
+  onSubmit: (value: V) => void;
+  onCancel?: () => void;
+}
+
+export function SingleSelect<V extends string>({
+  items,
+  initialValue,
+  onSubmit,
+  onCancel,
+}: SingleSelectProps<V>) {
+  const initialIndex = Math.max(
+    0,
+    items.findIndex((i) => i.value === initialValue && !i.disabled),
+  );
+  const [index, setIndex] = useState(initialIndex === -1 ? 0 : initialIndex);
+
+  useInput((_input, key) => {
+    if (key.upArrow) {
+      setIndex((i) => findNextEnabled(items, i, -1));
+    } else if (key.downArrow) {
+      setIndex((i) => findNextEnabled(items, i, +1));
+    } else if (key.return) {
+      const chosen = items[index];
+      if (chosen && !chosen.disabled) onSubmit(chosen.value);
+    } else if (key.escape && onCancel) {
+      onCancel();
+    }
+  });
+
+  return (
+    <Box flexDirection="column">
+      {items.map((item, i) => (
+        <SelectRow
+          key={item.value}
+          item={item}
+          active={i === index}
+          marker={i === index ? "▸" : " "}
+        />
+      ))}
+    </Box>
+  );
+}
+
+export interface MultiSelectProps<V extends string> {
+  items: SelectItem<V>[];
+  initialSelected?: V[];
+  onSubmit: (values: V[]) => void;
+  onCancel?: () => void;
+  /** Footer hint under the list — e.g. "space toggle · enter confirm". */
+  footer?: string;
+}
+
+export function MultiSelect<V extends string>({
+  items,
+  initialSelected = [],
+  onSubmit,
+  onCancel,
+  footer,
+}: MultiSelectProps<V>) {
+  const [index, setIndex] = useState(() => {
+    const first = items.findIndex((i) => !i.disabled);
+    return first === -1 ? 0 : first;
+  });
+  const [selected, setSelected] = useState<Set<V>>(new Set(initialSelected));
+
+  useInput((input, key) => {
+    if (key.upArrow) {
+      setIndex((i) => findNextEnabled(items, i, -1));
+    } else if (key.downArrow) {
+      setIndex((i) => findNextEnabled(items, i, +1));
+    } else if (input === " ") {
+      const item = items[index];
+      if (!item || item.disabled) return;
+      setSelected((prev) => {
+        const next = new Set(prev);
+        if (next.has(item.value)) next.delete(item.value);
+        else next.add(item.value);
+        return next;
+      });
+    } else if (key.return) {
+      // Preserve catalog order rather than insertion order, so reruns
+      // produce the same spec list for the same checkbox set — makes the
+      // `config.json` diff trivially stable.
+      const ordered = items.filter((i) => selected.has(i.value)).map((i) => i.value);
+      onSubmit(ordered);
+    } else if (key.escape && onCancel) {
+      onCancel();
+    }
+  });
+
+  return (
+    <Box flexDirection="column">
+      {items.map((item, i) => {
+        const checked = selected.has(item.value);
+        const marker = checked ? "[x]" : "[ ]";
+        return (
+          <SelectRow
+            key={item.value}
+            item={item}
+            active={i === index}
+            marker={`${i === index ? "▸" : " "} ${marker}`}
+          />
+        );
+      })}
+      {footer ? (
+        <Box marginTop={1}>
+          <Text dimColor>{footer}</Text>
+        </Box>
+      ) : null}
+    </Box>
+  );
+}
+
+// ---------- internals ----------
+
+function SelectRow<V extends string>({
+  item,
+  active,
+  marker,
+}: {
+  item: SelectItem<V>;
+  active: boolean;
+  marker: string;
+}) {
+  const color = item.disabled ? "gray" : active ? "cyan" : undefined;
+  return (
+    <Box flexDirection="column">
+      <Box>
+        <Text color={color}>
+          {marker} {item.label}
+        </Text>
+      </Box>
+      {item.hint ? (
+        <Box paddingLeft={marker.length + 1}>
+          <Text dimColor>{item.hint}</Text>
+        </Box>
+      ) : null}
+    </Box>
+  );
+}
+
+function findNextEnabled<V extends string>(
+  items: SelectItem<V>[],
+  from: number,
+  step: -1 | 1,
+): number {
+  if (items.length === 0) return 0;
+  let i = from;
+  for (let tries = 0; tries < items.length; tries++) {
+    i = (i + step + items.length) % items.length;
+    if (!items[i]?.disabled) return i;
+  }
+  return from;
+}

src/cli/ui/SessionPicker.tsx

@@ -0,0 +1,72 @@
+import { Box, Text } from "ink";
+import React from "react";
+import { SingleSelect } from "./Select.js";
+
+export type SessionChoice = "resume" | "new" | "delete";
+
+export interface SessionPickerProps {
+  sessionName: string;
+  messageCount: number;
+  /** mtime of the session file; used to render "last active Nh ago". */
+  lastActive: Date;
+  onChoose: (choice: SessionChoice) => void;
+}
+
+export function SessionPicker({
+  sessionName,
+  messageCount,
+  lastActive,
+  onChoose,
+}: SessionPickerProps) {
+  return (
+    <Box flexDirection="column" marginY={1}>
+      <Box marginBottom={1}>
+        <Text bold color="cyan">
+          {`Session "${sessionName}" has ${messageCount} prior message${messageCount === 1 ? "" : "s"}`}
+        </Text>
+        <Text dimColor>{` · last active ${relativeTime(lastActive)}`}</Text>
+      </Box>
+      <SingleSelect
+        initialValue="new"
+        items={[
+          {
+            value: "new",
+            label: "Start new conversation",
+            hint: "Previous messages kept on disk; your turn starts fresh.",
+          },
+          {
+            value: "resume",
+            label: "Resume",
+            hint: `Continue where you left off (${messageCount} messages in context).`,
+          },
+          {
+            value: "delete",
+            label: "Delete and start new",
+            hint: "Wipes the session file irreversibly. Other sessions untouched.",
+          },
+        ]}
+        onSubmit={(v) => onChoose(v as SessionChoice)}
+      />
+      <Box marginTop={1}>
+        <Text dimColor>↑↓ to move · Enter to pick</Text>
+      </Box>
+    </Box>
+  );
+}
+
+/**
+ * "Nh ago" / "Nm ago" / "yesterday" style relative time. Deliberately
+ * coarse — the picker just needs a sense of "how stale is this session".
+ */
+function relativeTime(date: Date): string {
+  const ms = Date.now() - date.getTime();
+  const mins = Math.floor(ms / 60_000);
+  if (mins < 1) return "just now";
+  if (mins < 60) return `${mins}m ago`;
+  const hours = Math.floor(mins / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  if (days === 1) return "yesterday";
+  if (days < 7) return `${days}d ago`;
+  return date.toISOString().slice(0, 10);
+}

src/cli/ui/ShellConfirm.tsx

@@ -0,0 +1,105 @@
+import { Box, Text } from "ink";
+import React from "react";
+import { SingleSelect } from "./Select.js";
+
+export type ShellConfirmChoice = "run_once" | "always_allow" | "deny";
+
+export interface ShellConfirmProps {
+  command: string;
+  /**
+   * The prefix that would be persisted if the user picks
+   * "always allow". Typically the first 1-2 tokens of `command`.
+   */
+  allowPrefix: string;
+  onChoose: (choice: ShellConfirmChoice) => void;
+}
+
+/**
+ * Modal-style approval for a shell command the model wants to run.
+ * Three choices:
+ *   1. Run once — execute this invocation, prefix NOT remembered.
+ *   2. Always allow — persist the prefix to `~/.reasonix/config.json`
+ *      under this project so every future invocation with that prefix
+ *      auto-runs.
+ *   3. Deny — tell the model the user refused.
+ * Arrow keys + Enter. No y/n hotkey — too easy to trigger by accident
+ * when the user was mid-typing a response.
+ */
+export function ShellConfirm({ command, allowPrefix, onChoose }: ShellConfirmProps) {
+  return (
+    <Box flexDirection="column" borderStyle="round" borderColor="yellow" paddingX={1} marginY={1}>
+      <Box>
+        <Text bold color="yellow">
+          ▸ model wants to run a shell command
+        </Text>
+      </Box>
+      <Box marginTop={1}>
+        <Text>
+          <Text dimColor>{"$ "}</Text>
+          <Text color="cyan">{command}</Text>
+        </Text>
+      </Box>
+      <Box marginTop={1}>
+        <SingleSelect
+          initialValue="run_once"
+          items={[
+            {
+              value: "run_once",
+              label: "Run once",
+              hint: "Execute this command, don't remember it.",
+            },
+            {
+              value: "always_allow",
+              label: `Always allow "${allowPrefix}" in this project`,
+              hint: "Save the prefix to ~/.reasonix/config.json; future matches auto-run.",
+            },
+            {
+              value: "deny",
+              label: "Deny",
+              hint: "Tell the model the user refused; it will continue without this command.",
+            },
+          ]}
+          onSubmit={(v) => onChoose(v as ShellConfirmChoice)}
+        />
+      </Box>
+    </Box>
+  );
+}
+
+/**
+ * Pick the "always allow" prefix from a full command. Heuristic:
+ *   - one-token commands ("ls", "pytest") → the token itself
+ *   - multi-token → first two tokens for well-known wrappers
+ *     (`npm install`, `git commit`, `cargo add`, `docker run` …)
+ *     otherwise just the first token (covers `node <script>` where the
+ *     second token is usually a file path specific to this invocation).
+ * Exported so tests can pin the heuristic.
+ */
+export function derivePrefix(command: string): string {
+  const tokens = command.trim().split(/\s+/).filter(Boolean);
+  if (tokens.length === 0) return "";
+  if (tokens.length === 1) return tokens[0]!;
+  const first = tokens[0]!;
+  const TWO_TOKEN_WRAPPERS = new Set([
+    "npm",
+    "npx",
+    "pnpm",
+    "yarn",
+    "bun",
+    "git",
+    "cargo",
+    "go",
+    "docker",
+    "kubectl",
+    "python",
+    "python3",
+    "deno",
+    "pip",
+    "pip3",
+    "make",
+    "rake",
+    "bundle",
+    "gem",
+  ]);
+  return TWO_TOKEN_WRAPPERS.has(first) ? `${first} ${tokens[1]}` : first;
+}

src/cli/ui/SlashSuggestions.tsx

@@ -0,0 +1,85 @@
+import { Box, Text } from "ink";
+// biome-ignore lint/style/useImportType: tsconfig.jsx = "react" needs React in value scope for JSX compilation
+import React from "react";
+import type { SlashCommandSpec } from "./slash.js";
+
+export interface SlashSuggestionsProps {
+  /**
+   * Current matching suggestions, computed by the parent. `null` means
+   * "not in slash-prefix mode" — render nothing. Empty array means "in
+   * slash mode but no matches" — render the "no matches" hint.
+   */
+  matches: SlashCommandSpec[] | null;
+  /** Index (within `matches`) of the currently highlighted row. */
+  selectedIndex: number;
+}
+
+/**
+ * Floating slash-command panel. Rendered below the input box when
+ * the user is typing a `/…` prefix. Navigation state lives in the
+ * parent (App.tsx owns `slashSelected`) so ↑/↓/Tab/Enter stay
+ * consistent with the useInput handler. This component is pure
+ * display: `matches` and `selectedIndex` come in, rows go out.
+ */
+export function SlashSuggestions({
+  matches,
+  selectedIndex,
+}: SlashSuggestionsProps): React.ReactElement | null {
+  if (matches === null) return null;
+  if (matches.length === 0) {
+    return (
+      <Box paddingX={1}>
+        <Text color="yellow">no slash command matches that prefix</Text>
+        <Text dimColor> — Backspace to edit, or /help for the full list</Text>
+      </Box>
+    );
+  }
+  // Limit rows so the suggestion list never dwarfs the rest of the
+  // UI. Keep the currently-selected row in view by sliding the
+  // window when the selection is near either edge.
+  const MAX = 8;
+  const total = matches.length;
+  const windowStart =
+    total <= MAX ? 0 : Math.max(0, Math.min(selectedIndex - Math.floor(MAX / 2), total - MAX));
+  const shown = matches.slice(windowStart, windowStart + MAX);
+  const hiddenAbove = windowStart;
+  const hiddenBelow = total - windowStart - shown.length;
+  return (
+    <Box flexDirection="column" paddingX={1}>
+      {hiddenAbove > 0 ? <Text dimColor> ↑ {hiddenAbove} more above</Text> : null}
+      {shown.map((spec, i) => (
+        <SuggestionRow key={spec.cmd} spec={spec} isSelected={windowStart + i === selectedIndex} />
+      ))}
+      {hiddenBelow > 0 ? <Text dimColor> ↓ {hiddenBelow} more below</Text> : null}
+      <Text dimColor> ↑/↓ navigate · Tab or Enter to pick</Text>
+    </Box>
+  );
+}
+
+function SuggestionRow({ spec, isSelected }: { spec: SlashCommandSpec; isSelected: boolean }) {
+  const marker = isSelected ? "▸" : " ";
+  const name = `/${spec.cmd}`;
+  const argsSuffix = spec.argsHint ? ` ${spec.argsHint}` : "";
+  // Selected row gets full cyan coloring so it pops out against the
+  // dimmed others — mirrors the style GitHub Issues / Discord use
+  // for focused dropdown rows.
+  if (isSelected) {
+    return (
+      <Box>
+        <Text bold color="cyan">
+          {marker} {name.padEnd(12)}
+          {argsSuffix.padEnd(16)}
+        </Text>
+        <Text color="cyan"> {spec.summary}</Text>
+      </Box>
+    );
+  }
+  return (
+    <Box>
+      <Text dimColor>
+        {marker} {name.padEnd(12)}
+        {argsSuffix.padEnd(16)} {spec.summary}
+      </Text>
+    </Box>
+  );
+}

src/cli/ui/StatsPanel.tsx

@@ -1,6 +1,8 @@
 import { Box, Text } from "ink";
 import React from "react";
+import { DEEPSEEK_CONTEXT_TOKENS, DEFAULT_CONTEXT_TOKENS } from "../../telemetry.js";
 import type { SessionSummary } from "../../telemetry.js";
+import { VERSION } from "../../version.js";
 
 export interface StatsPanelProps {
   summary: SessionSummary;
@@ -8,6 +10,29 @@ export interface StatsPanelProps {
   prefixHash: string;
   harvestOn?: boolean;
   branchBudget?: number;
+  /**
+   * True when `reasonix code` is currently running in read-only Plan
+   * Mode. Surfaced as a red "PLAN" tag in the panel header so the user
+   * can tell at a glance that edits are gated behind submit_plan +
+   * approval.
+   */
+  planMode?: boolean;
+  /**
+   * Account balance fetched once at launch (and optionally refreshed
+   * per-turn by the TUI). `null` or absent hides the balance cell
+   * entirely — /user/balance failed or the user ran with `--no-config`.
+   * The top-up warning fires below 1.0 unit of whatever currency
+   * the endpoint reports so a Chinese user with CNY and a U.S. user
+   * with USD both see "getting low."
+   */
+  balance?: { currency: string; total: number } | null;
+  /**
+   * Published npm version newer than VERSION. Rendered as a yellow
+   * "· update: X" nudge in the panel header. `null` / `undefined`
+   * hides the nudge (offline launch, already up to date, or check
+   * still in flight).
+   */
+  updateAvailable?: string | null;
 }
 
 export function StatsPanel({
@@ -16,11 +41,19 @@ export function StatsPanel({
   prefixHash,
   harvestOn,
   branchBudget,
+  planMode,
+  balance,
+  updateAvailable,
 }: StatsPanelProps) {
   const hitPct = (summary.cacheHitRatio * 100).toFixed(1);
   const hitColor =
     summary.cacheHitRatio >= 0.7 ? "green" : summary.cacheHitRatio >= 0.4 ? "yellow" : "red";
   const branchOn = (branchBudget ?? 1) > 1;
+
+  const ctxMax = DEEPSEEK_CONTEXT_TOKENS[model] ?? DEFAULT_CONTEXT_TOKENS;
+  const ctxRatio = summary.lastPromptTokens / ctxMax;
+  const ctxColor = ctxRatio >= 0.8 ? "red" : ctxRatio >= 0.5 ? "yellow" : undefined;
+
   return (
     <Box borderStyle="round" borderColor="cyan" flexDirection="column" paddingX={1}>
       <Box justifyContent="space-between">
@@ -28,14 +61,26 @@ export function StatsPanel({
           <Text color="cyan" bold>
             Reasonix
           </Text>
+          <Text dimColor>{` v${VERSION}`}</Text>
           <Text dimColor> · model </Text>
           <Text color="yellow">{model}</Text>
           <Text dimColor> · prefix </Text>
           <Text dimColor>{prefixHash}</Text>
           {harvestOn ? <Text color="magenta"> · harvest</Text> : null}
           {branchOn ? <Text color="blue"> · branch{branchBudget}</Text> : null}
+          {planMode ? (
+            <Text color="red" bold>
+              {" "}
+              · PLAN
+            </Text>
+          ) : null}
+        </Text>
+        <Text>
+          {updateAvailable ? (
+            <Text color="yellow" bold>{`update: ${updateAvailable} · `}</Text>
+          ) : null}
+          <Text dimColor>turns {summary.turns} · type /help</Text>
         </Text>
-        <Text dimColor>turns {summary.turns} · type /help</Text>
       </Box>
       <Box marginTop={1} gap={3}>
         <Text>
@@ -46,19 +91,52 @@ export function StatsPanel({
         </Text>
         <Text>
           <Text dimColor>cost </Text>
-          <Text color="green">${summary.totalCostUsd.toFixed(6)}</Text>
-        </Text>
-        <Text>
-          <Text dimColor>vs Claude </Text>
-          <Text>${summary.claudeEquivalentUsd.toFixed(6)}</Text>
-        </Text>
-        <Text>
-          <Text dimColor>saving </Text>
           <Text color="green" bold>
-            {summary.savingsVsClaudePct.toFixed(1)}%
+            ${summary.totalCostUsd.toFixed(6)}
+          </Text>
+          <Text dimColor>
+            {" (in "}${summary.totalInputCostUsd.toFixed(6)}
+            {" · out "}${summary.totalOutputCostUsd.toFixed(6)}
+            {")"}
           </Text>
         </Text>
+        {summary.lastPromptTokens > 0 ? (
+          <Text>
+            <Text dimColor>ctx </Text>
+            <Text color={ctxColor} bold={ctxColor !== undefined}>
+              {formatTokens(summary.lastPromptTokens)}/{formatTokens(ctxMax)}
+            </Text>
+            <Text dimColor> ({(ctxRatio * 100).toFixed(0)}%)</Text>
+            {ctxRatio >= 0.8 ? (
+              <Text color="red" bold>
+                {" "}
+                · /compact
+              </Text>
+            ) : null}
+          </Text>
+        ) : null}
+        {balance ? (
+          <Text>
+            <Text dimColor>balance </Text>
+            <Text color={balance.total < 1 ? "red" : balance.total < 5 ? "yellow" : "green"} bold>
+              {balance.currency === "USD" ? "$" : ""}
+              {balance.total.toFixed(2)}
+              {balance.currency !== "USD" ? ` ${balance.currency}` : ""}
+            </Text>
+          </Text>
+        ) : null}
       </Box>
     </Box>
   );
 }
+
+/**
+ * Compact integer formatter: 1234 → "1.2k", 131072 → "131k". Keeps the
+ * panel narrow enough to fit on 80-col terminals even when the context
+ * is near full.
+ */
+function formatTokens(n: number): string {
+  if (n < 1000) return String(n);
+  const k = n / 1000;
+  return k >= 100 ? `${k.toFixed(0)}k` : `${k.toFixed(1)}k`;
+}

src/cli/ui/Wizard.tsx

@@ -0,0 +1,447 @@
+/**
+ * First-run / re-configure wizard.
+ *
+ * Walks a new user through: API key → preset pick → MCP server pick →
+ * per-server args → save. Saved output lives in `~/.reasonix/config.json`
+ * so the next `reasonix chat` starts with everything already wired.
+ *
+ * The wizard is the antidote to "too many CLI flags" — a new user should
+ * never have to read `--help` to get MCP + a sensible model combo
+ * working. Everything a user could set via `--mcp`, `--harvest`,
+ * `--branch`, etc. can be picked here in a few arrow-key presses.
+ */
+
+import { Box, Text, useApp, useInput } from "ink";
+import TextInput from "ink-text-input";
+// biome-ignore lint/style/useImportType: JSX (jsx: "react") needs React as a value at runtime
+import React, { useState } from "react";
+import {
+  type PresetName,
+  type ReasonixConfig,
+  defaultConfigPath,
+  isPlausibleKey,
+  readConfig,
+  redactKey,
+  writeConfig,
+} from "../../config.js";
+import { type CatalogEntry, MCP_CATALOG } from "../../mcp/catalog.js";
+import { MultiSelect, type SelectItem, SingleSelect } from "./Select.js";
+import { PRESET_DESCRIPTIONS } from "./presets.js";
+
+export interface WizardProps {
+  /** Called once the config has been saved. */
+  onComplete: (cfg: ReasonixConfig) => void;
+  /** Called if the user presses Esc to abort. */
+  onCancel?: () => void;
+  /** Skip the API-key step if a key already exists (env or config). */
+  existingApiKey?: string;
+  /** Pre-fill selections when re-running (reconfigure flow). */
+  initial?: {
+    preset?: PresetName;
+    mcp?: string[];
+  };
+}
+
+type Step = "apiKey" | "preset" | "mcp" | "mcpArgs" | "review" | "saved";
+
+interface WizardData {
+  apiKey: string;
+  preset: PresetName;
+  selectedCatalog: string[]; // entries from MCP_CATALOG by `name`
+  /** Captured user inputs per catalog entry that has `userArgs` (e.g. fs dir). */
+  catalogArgs: Record<string, string>;
+}
+
+const CATALOG_BY_NAME = new Map(MCP_CATALOG.map((e) => [e.name, e]));
+
+export function Wizard({ onComplete, onCancel, existingApiKey, initial }: WizardProps) {
+  const { exit } = useApp();
+  const [step, setStep] = useState<Step>(existingApiKey ? "preset" : "apiKey");
+  const [data, setData] = useState<WizardData>({
+    apiKey: existingApiKey ?? "",
+    preset: initial?.preset ?? "fast",
+    selectedCatalog: deriveInitialCatalog(initial?.mcp ?? []),
+    catalogArgs: {},
+  });
+  const [error, setError] = useState<string | null>(null);
+
+  // Global Esc → cancel. Disabled once we've started saving to avoid
+  // ejecting out of a half-written state.
+  useInput((_input, key) => {
+    if (key.escape && step !== "saved" && onCancel) onCancel();
+  });
+
+  if (step === "apiKey") {
+    return (
+      <ApiKeyStep
+        onSubmit={(key) => {
+          setData((d) => ({ ...d, apiKey: key }));
+          setError(null);
+          setStep("preset");
+        }}
+        error={error}
+        onError={setError}
+      />
+    );
+  }
+
+  if (step === "preset") {
+    return (
+      <StepFrame title="Pick a preset" step={1} total={3}>
+        <SingleSelect<PresetName>
+          items={presetItems()}
+          initialValue={data.preset}
+          onSubmit={(preset) => {
+            setData((d) => ({ ...d, preset }));
+            setStep("mcp");
+          }}
+        />
+        <Box marginTop={1}>
+          <Text dimColor>↑/↓ move · enter confirm · esc cancel</Text>
+        </Box>
+      </StepFrame>
+    );
+  }
+
+  if (step === "mcp") {
+    return (
+      <StepFrame title="Which MCP servers should Reasonix wire up for you?" step={2} total={3}>
+        <MultiSelect
+          items={mcpItems()}
+          initialSelected={data.selectedCatalog}
+          onSubmit={(selected) => {
+            setData((d) => ({ ...d, selectedCatalog: selected }));
+            // Only advance to the args step if any selected entry needs args.
+            const needsArgs = selected.some((name) => CATALOG_BY_NAME.get(name)?.userArgs);
+            setStep(needsArgs ? "mcpArgs" : "review");
+          }}
+          footer="↑/↓ move · space toggle · enter confirm · esc cancel · leave empty to skip"
+        />
+      </StepFrame>
+    );
+  }
+
+  if (step === "mcpArgs") {
+    const pending = data.selectedCatalog.filter((name) => {
+      const entry = CATALOG_BY_NAME.get(name);
+      return entry?.userArgs && !data.catalogArgs[name];
+    });
+    if (pending.length === 0) {
+      setStep("review");
+      return null;
+    }
+    const currentName = pending[0]!;
+    const entry = CATALOG_BY_NAME.get(currentName)!;
+    return (
+      <McpArgsStep
+        entry={entry}
+        error={error}
+        onSubmit={(value) => {
+          setData((d) => ({
+            ...d,
+            catalogArgs: { ...d.catalogArgs, [currentName]: value },
+          }));
+          setError(null);
+        }}
+        onError={setError}
+      />
+    );
+  }
+
+  if (step === "review") {
+    const specs = data.selectedCatalog.map((name) => buildSpec(name, data.catalogArgs));
+    return (
+      <StepFrame title="Ready to save" step={3} total={3}>
+        <Box flexDirection="column">
+          <SummaryLine label="API key" value={redactKey(data.apiKey)} />
+          <SummaryLine label="Preset" value={data.preset} />
+          <SummaryLine
+            label="MCP"
+            value={specs.length === 0 ? "(none)" : `${specs.length} server(s)`}
+          />
+          {specs.map((spec, i) => (
+            // biome-ignore lint/suspicious/noArrayIndexKey: review-only render, order fixed
+            <Box key={i} paddingLeft={14}>
+              <Text dimColor>· {spec}</Text>
+            </Box>
+          ))}
+          <Box marginTop={1}>
+            <Text>Saves to {defaultConfigPath()}</Text>
+          </Box>
+          {error ? (
+            <Box marginTop={1}>
+              <Text color="red">{error}</Text>
+            </Box>
+          ) : null}
+          <Box marginTop={1}>
+            <Text dimColor>enter save · esc cancel</Text>
+          </Box>
+        </Box>
+        <ReviewConfirm
+          onConfirm={() => {
+            try {
+              const specsNow = data.selectedCatalog.map((name) =>
+                buildSpec(name, data.catalogArgs),
+              );
+              const prev = readConfig();
+              const next: ReasonixConfig = {
+                ...prev,
+                apiKey: data.apiKey,
+                preset: data.preset,
+                mcp: specsNow,
+                setupCompleted: true,
+              };
+              writeConfig(next);
+              setStep("saved");
+              onComplete(next);
+            } catch (e) {
+              setError(`Could not save config: ${(e as Error).message}`);
+            }
+          }}
+        />
+      </StepFrame>
+    );
+  }
+
+  // saved
+  return (
+    <Box flexDirection="column" borderStyle="round" borderColor="green" paddingX={1}>
+      <Text bold color="green">
+        ▸ Saved.
+      </Text>
+      <Box marginTop={1}>
+        <Text>Run `reasonix` any time to start chatting — your settings are remembered.</Text>
+      </Box>
+      <Box marginTop={1}>
+        <Text dimColor>Press enter to exit.</Text>
+      </Box>
+      <ExitOnEnter onExit={exit} />
+    </Box>
+  );
+}
+
+// ---------- step components ----------
+
+function ApiKeyStep({
+  onSubmit,
+  error,
+  onError,
+}: {
+  onSubmit: (key: string) => void;
+  error: string | null;
+  onError: (e: string | null) => void;
+}) {
+  const [value, setValue] = useState("");
+  return (
+    <Box flexDirection="column" borderStyle="round" borderColor="cyan" paddingX={1}>
+      <Text bold color="cyan">
+        Welcome to Reasonix.
+      </Text>
+      <Box marginTop={1}>
+        <Text>Paste your DeepSeek API key to get started.</Text>
+      </Box>
+      <Text dimColor>Get one (free credit on signup): https://platform.deepseek.com/api_keys</Text>
+      <Text dimColor>Saved locally to {defaultConfigPath()}</Text>
+      <Box marginTop={1}>
+        <Text bold color="cyan">
+          {"key › "}
+        </Text>
+        <TextInput
+          value={value}
+          onChange={setValue}
+          onSubmit={(raw) => {
+            const trimmed = raw.trim();
+            if (!isPlausibleKey(trimmed)) {
+              onError("Doesn't look like a DeepSeek key. They start with 'sk-' and are 30+ chars.");
+              setValue("");
+              return;
+            }
+            onSubmit(trimmed);
+          }}
+          mask="•"
+          placeholder="sk-..."
+        />
+      </Box>
+      {error ? (
+        <Box marginTop={1}>
+          <Text color="red">{error}</Text>
+        </Box>
+      ) : value ? (
+        <Box marginTop={1}>
+          <Text dimColor>preview: {redactKey(value)}</Text>
+        </Box>
+      ) : null}
+    </Box>
+  );
+}
+
+function McpArgsStep({
+  entry,
+  error,
+  onSubmit,
+  onError,
+}: {
+  entry: CatalogEntry;
+  error: string | null;
+  onSubmit: (value: string) => void;
+  onError: (e: string | null) => void;
+}) {
+  const [value, setValue] = useState("");
+  return (
+    <StepFrame title={`Configure ${entry.name}`} step={2} total={3}>
+      <Box flexDirection="column">
+        <Text>{entry.summary}</Text>
+        {entry.note ? (
+          <Box marginTop={1}>
+            <Text dimColor>{entry.note}</Text>
+          </Box>
+        ) : null}
+        <Box marginTop={1}>
+          <Text>Required parameter: </Text>
+          <Text bold>{entry.userArgs}</Text>
+        </Box>
+        <Box marginTop={1}>
+          <Text bold color="cyan">
+            {entry.userArgs}
+            {" › "}
+          </Text>
+          <TextInput
+            value={value}
+            onChange={setValue}
+            onSubmit={(raw) => {
+              const trimmed = raw.trim();
+              if (!trimmed) {
+                onError(`${entry.name} needs a value — got an empty string.`);
+                return;
+              }
+              onSubmit(trimmed);
+              setValue("");
+            }}
+            placeholder={placeholderFor(entry)}
+          />
+        </Box>
+        {error ? (
+          <Box marginTop={1}>
+            <Text color="red">{error}</Text>
+          </Box>
+        ) : null}
+      </Box>
+    </StepFrame>
+  );
+}
+
+function ReviewConfirm({ onConfirm }: { onConfirm: () => void }) {
+  useInput((_i, key) => {
+    if (key.return) onConfirm();
+  });
+  return null;
+}
+
+function ExitOnEnter({ onExit }: { onExit: () => void }) {
+  useInput((_i, key) => {
+    if (key.return) onExit();
+  });
+  return null;
+}
+
+// ---------- small bits ----------
+
+function StepFrame({
+  title,
+  step,
+  total,
+  children,
+}: {
+  title: string;
+  step: number;
+  total: number;
+  children: React.ReactNode;
+}) {
+  return (
+    <Box flexDirection="column" borderStyle="round" borderColor="cyan" paddingX={1}>
+      <Box>
+        <Text dimColor>
+          Step {step}/{total} ·{" "}
+        </Text>
+        <Text bold color="cyan">
+          {title}
+        </Text>
+      </Box>
+      <Box marginTop={1} flexDirection="column">
+        {children}
+      </Box>
+    </Box>
+  );
+}
+
+function SummaryLine({ label, value }: { label: string; value: string }) {
+  return (
+    <Box>
+      <Text>{label.padEnd(12)}</Text>
+      <Text bold>{value}</Text>
+    </Box>
+  );
+}
+
+// ---------- data helpers ----------
+
+function presetItems(): SelectItem<PresetName>[] {
+  return (["fast", "smart", "max"] as PresetName[]).map((name) => ({
+    value: name,
+    label: `${name} — ${PRESET_DESCRIPTIONS[name].headline}`,
+    hint: PRESET_DESCRIPTIONS[name].cost,
+  }));
+}
+
+function mcpItems(): SelectItem<string>[] {
+  return MCP_CATALOG.map((entry) => {
+    const hintParts: string[] = [entry.summary];
+    if (entry.userArgs) hintParts.push(`(you'll provide ${entry.userArgs})`);
+    if (entry.note) hintParts.push(entry.note);
+    return {
+      value: entry.name,
+      label: entry.name,
+      hint: hintParts.join(" · "),
+    };
+  });
+}
+
+function placeholderFor(entry: CatalogEntry): string {
+  if (entry.name === "filesystem") return "e.g. /tmp/reasonix-sandbox";
+  if (entry.name === "sqlite") return "e.g. ./notes.sqlite";
+  return entry.userArgs ?? "";
+}
+
+function deriveInitialCatalog(existingSpecs: string[]): string[] {
+  // Best-effort recovery: if the user previously picked catalog entries,
+  // the spec strings look like `name=npx -y <pkg> ...`. Match by package
+  // so reconfigure pre-checks the same boxes.
+  const packageToName = new Map(MCP_CATALOG.map((e) => [e.package, e.name]));
+  const out: string[] = [];
+  for (const spec of existingSpecs) {
+    for (const [pkg, name] of packageToName) {
+      if (spec.includes(pkg)) {
+        out.push(name);
+        break;
+      }
+    }
+  }
+  return out;
+}
+
+/**
+ * Build the `--mcp` spec string for a catalog entry. Same format
+ * `mcpCommandFor` produces for `reasonix mcp list`, minus the leading
+ * `--mcp "..."` wrapper — we store the inner spec directly.
+ */
+export function buildSpec(name: string, argsByName: Record<string, string>): string {
+  const entry = CATALOG_BY_NAME.get(name);
+  if (!entry) return name; // shouldn't happen; fall back gracefully
+  const userArg = entry.userArgs ? argsByName[name] : undefined;
+  const tail = userArg ? ` ${quoteIfNeeded(userArg)}` : "";
+  return `${entry.name}=npx -y ${entry.package}${tail}`;
+}
+
+function quoteIfNeeded(s: string): string {
+  return /\s|"/.test(s) ? `"${s.replace(/"/g, '\\"')}"` : s;
+}

src/cli/ui/markdown.tsx

@@ -144,8 +144,21 @@ export function stripMath(s: string): string {
   );
 }
 
-/** Split a single line into styled segments for bold / italic / inline code. */
-const INLINE_RE = /(\*\*([^*\n]+?)\*\*|`([^`\n]+?)`|(?<![*\w])\*([^*\n]+?)\*(?!\w))/g;
+/**
+ * Split a single line into styled segments for bold / italic / inline
+ * code.
+ *
+ * Triple-backtick (```…```) runs are matched BEFORE the single-backtick
+ * case so a one-line code span like `​``bash echo hi``​` is captured
+ * whole instead of the single-backtick regex greedily eating the
+ * middle and leaving two stray backticks on each side (what 0.4.15
+ * users saw when the model emitted `​``bash …``​` on the same line as
+ * prose). Content may contain single backticks but not newlines —
+ * multi-line fenced code is a block-level concern handled in
+ * `parseBlocks`.
+ */
+const INLINE_RE =
+  /(\*\*([^*\n]+?)\*\*|```([^\n]+?)```|`([^`\n]+?)`|(?<![*\w])\*([^*\n]+?)\*(?!\w))/g;
 
 function InlineMd({ text }: { text: string }) {
   const parts: React.ReactNode[] = [];
@@ -156,6 +169,11 @@ function InlineMd({ text }: { text: string }) {
     if (start > last) {
       parts.push(<Text key={`t${idx++}`}>{text.slice(last, start)}</Text>);
     }
+    // Groups, in the order they appear in INLINE_RE:
+    //   m[2] = bold content (inside ** **)
+    //   m[3] = triple-backtick content (strip leading lang tag)
+    //   m[4] = single-backtick inline code
+    //   m[5] = italic content (inside * *)
     if (m[2] !== undefined) {
       parts.push(
         <Text key={`b${idx++}`} bold>
@@ -163,17 +181,26 @@ function InlineMd({ text }: { text: string }) {
         </Text>,
       );
     } else if (m[3] !== undefined) {
+      // One-line fenced span: ```bash echo hi``` → drop the "bash "
+      // language tag so the user doesn't see it rendered in code color.
+      const stripped = m[3].replace(/^(\w+)\s+/, "");
       parts.push(
         <Text key={`c${idx++}`} color="yellow">
-          {m[3]}
+          {stripped}
         </Text>,
       );
     } else if (m[4] !== undefined) {
       parts.push(
-        <Text key={`i${idx++}`} italic>
+        <Text key={`c${idx++}`} color="yellow">
           {m[4]}
         </Text>,
       );
+    } else if (m[5] !== undefined) {
+      parts.push(
+        <Text key={`i${idx++}`} italic>
+          {m[5]}
+        </Text>,
+      );
     }
     last = start + m[0].length;
   }
@@ -206,10 +233,42 @@ interface CodeBlock {
 interface HrBlock {
   kind: "hr";
 }
+// First-class Aider-style SEARCH/REPLACE block. We detect these at
+// parse time instead of routing them through the paragraph / inline
+// markdown path because the inline parser would otherwise eat `**`
+// inside JSDoc `/** ... *\/` comments and `para.join(" ")` would
+// collapse the block's newlines. Rendered as a diff so the user can
+// actually read what's about to change.
+interface EditBlockView {
+  kind: "edit-block";
+  filename: string;
+  search: string;
+  replace: string;
+}
 
-type Block = ParagraphBlock | HeadingBlock | BulletBlock | CodeBlock | HrBlock;
+/**
+ * GitHub-Flavored-Markdown-ish tables. We don't do alignment flags
+ * (:--- / ---:) — column-wise left-alignment is fine for a terminal
+ * and the LLM rarely specifies alignment anyway. Columns grow to
+ * fit the widest cell, with a hard cap so a pathological 200-char
+ * cell doesn't blow past the terminal width.
+ */
+interface TableBlock {
+  kind: "table";
+  header: string[];
+  rows: string[][];
+}
 
-function parseBlocks(raw: string): Block[] {
+type Block =
+  | ParagraphBlock
+  | HeadingBlock
+  | BulletBlock
+  | CodeBlock
+  | HrBlock
+  | EditBlockView
+  | TableBlock;
+
+export function parseBlocks(raw: string): Block[] {
   const lines = raw.split(/\r?\n/);
   const out: Block[] = [];
   let para: string[] = [];
@@ -218,6 +277,11 @@ function parseBlocks(raw: string): Block[] {
   let codeBuf: string[] = [];
   let listBuf: BulletBlock | null = null;
 
+  // Fence length of the currently-open code block so a block opened
+  // with ````` closes only on `````, matching GFM. Empty when we're
+  // not in code mode.
+  let codeFence = "";
+
   const flushPara = () => {
     if (para.length) {
       out.push({ kind: "paragraph", text: para.join(" ") });
@@ -231,25 +295,95 @@ function parseBlocks(raw: string): Block[] {
     }
   };
 
-  for (const rawLine of lines) {
+  for (let i = 0; i < lines.length; i++) {
+    const rawLine = lines[i]!;
     const line = rawLine.replace(/\s+$/g, "");
 
-    const fence = line.match(/^```(\w*)/);
-    if (fence) {
-      if (inCode) {
-        out.push({ kind: "code", lang: codeLang, text: codeBuf.join("\n") });
-        codeBuf = [];
-        codeLang = "";
-        inCode = false;
-      } else {
+    // Detect Aider-style SEARCH/REPLACE block. Matches the preceding
+    // non-blank line as the filename, then `<<<<<<< SEARCH`, content,
+    // `=======`, content, `>>>>>>> REPLACE`. We don't do markdown
+    // inside — neither the paragraph nor inline parsers should touch
+    // this content.
+    if (!inCode && /^<{7} SEARCH\s*$/.test(line)) {
+      // Filename is the previous non-blank line we just pushed to para.
+      // Pull it back out; if there isn't one, treat as literal text.
+      const filename = para.pop()?.trim();
+      if (filename) {
+        flushPara();
+        flushList();
+        let j = i + 1;
+        const searchLines: string[] = [];
+        while (j < lines.length && !/^={7}\s*$/.test(lines[j]!)) {
+          searchLines.push(lines[j]!);
+          j++;
+        }
+        const replaceLines: string[] = [];
+        let k = j + 1;
+        while (k < lines.length && !/^>{7} REPLACE\s*$/.test(lines[k]!)) {
+          replaceLines.push(lines[k]!);
+          k++;
+        }
+        if (j < lines.length && k < lines.length) {
+          out.push({
+            kind: "edit-block",
+            filename,
+            search: searchLines.join("\n"),
+            replace: replaceLines.join("\n"),
+          });
+          i = k;
+          continue;
+        }
+        // Malformed — no separator or no close. Fall through: put
+        // the filename back in the paragraph so we don't lose it.
+        para.push(filename);
+      }
+    }
+
+    // Fenced code block (GFM). The fence is 3+ backticks, may have up
+    // to 3 leading spaces, and carries an optional language tag. A
+    // closing fence must be the SAME backtick run length or longer.
+    //
+    // Two paths:
+    //   a) Fence on its own line → multi-line block, accumulate until
+    //      a matching close fence.
+    //   b) Fence opens AND closes on the same line (e.g.
+    //      `​``bash echo hi``​`) → emit as a one-line code block so
+    //      the inline parser doesn't half-eat the backticks.
+    if (!inCode) {
+      const open = line.match(/^ {0,3}(`{3,})(\w*)\s*(.*)$/);
+      if (open) {
+        const fence = open[1]!;
+        const lang = open[2] ?? "";
+        const rest = open[3] ?? "";
+        const closeOnSame = rest.match(new RegExp(`^(.*?)${fence}\\s*$`));
+        if (closeOnSame) {
+          flushPara();
+          flushList();
+          out.push({ kind: "code", lang, text: (closeOnSame[1] ?? "").trim() });
+          continue;
+        }
         flushPara();
         flushList();
         inCode = true;
-        codeLang = fence[1] ?? "";
+        codeLang = lang;
+        codeFence = fence;
+        // Anything after the opening fence on the SAME line is
+        // still body content (rare but legal).
+        if (rest.length > 0) codeBuf.push(rest);
+        continue;
+      }
+    } else {
+      // In code mode — check for closing fence. Same indent rules as
+      // opening, and the backtick run must be at least as long.
+      const close = line.match(/^ {0,3}(`{3,})\s*$/);
+      if (close && close[1]!.length >= codeFence.length) {
+        out.push({ kind: "code", lang: codeLang, text: codeBuf.join("\n") });
+        codeBuf = [];
+        codeLang = "";
+        codeFence = "";
+        inCode = false;
+        continue;
       }
-      continue;
-    }
-    if (inCode) {
       codeBuf.push(rawLine);
       continue;
     }
@@ -275,6 +409,31 @@ function parseBlocks(raw: string): Block[] {
       continue;
     }
 
+    // Table detection: a line with at least one `|` where the NEXT
+    // line looks like a GFM separator (`| --- | --- |` or any mix of
+    // pipes + dashes + colons + spaces). Both the header row and the
+    // separator need to be present — a bare pipe in prose shouldn't
+    // trigger the table path.
+    if (line.includes("|")) {
+      const next = (lines[i + 1] ?? "").trim();
+      if (/^\|?\s*:?-{2,}:?\s*(\|\s*:?-{2,}:?\s*)+\|?\s*$/.test(next)) {
+        flushPara();
+        flushList();
+        const header = splitTableRow(line);
+        const rows: string[][] = [];
+        let j = i + 2; // skip header + separator
+        while (j < lines.length) {
+          const r = lines[j]!.replace(/\s+$/g, "");
+          if (r.trim() === "" || !r.includes("|")) break;
+          rows.push(splitTableRow(r));
+          j++;
+        }
+        out.push({ kind: "table", header, rows });
+        i = j - 1;
+        continue;
+      }
+    }
+
     const bm = line.match(/^\s*[-*+]\s+(.+)$/);
     if (bm) {
       flushPara();
@@ -336,11 +495,154 @@ function BlockView({ block }: { block: Block }) {
           <Text color="yellow">{block.text}</Text>
         </Box>
       );
+    case "edit-block":
+      return <EditBlockRow block={block} />;
+    case "table":
+      return <TableBlockRow block={block} />;
     case "hr":
       return <Text dimColor>{"────────────────────────"}</Text>;
   }
 }
 
+/**
+ * Split one table row into trimmed cells. Leading/trailing pipes are
+ * optional (both `| a | b |` and `a | b` are accepted). Pipes escaped
+ * as `\|` stay in the cell content.
+ */
+function splitTableRow(line: string): string[] {
+  // Temporarily replace escaped pipes so split() doesn't fire on them.
+  const SENTINEL = "\u0000";
+  const masked = line.replace(/\\\|/g, SENTINEL);
+  const trimmed = masked.trim().replace(/^\||\|$/g, "");
+  return trimmed.split("|").map((c) => c.trim().replace(new RegExp(SENTINEL, "g"), "|"));
+}
+
+/**
+ * Render a GFM table as an aligned grid. Column widths are the max
+ * display length in that column, capped at 40 chars so one huge cell
+ * doesn't wreck the layout. Header row is bold + cyan; body rows use
+ * the default text color. Separator is a dim row of dashes.
+ */
+function TableBlockRow({ block }: { block: TableBlock }) {
+  const colCount = Math.max(block.header.length, ...block.rows.map((r) => r.length));
+  const widths: number[] = [];
+  for (let c = 0; c < colCount; c++) {
+    const cellLengths = [displayWidth(block.header[c] ?? "")];
+    for (const r of block.rows) cellLengths.push(displayWidth(r[c] ?? ""));
+    widths.push(Math.min(40, Math.max(3, ...cellLengths)));
+  }
+  const pad = (s: string, w: number) => {
+    const dw = displayWidth(s);
+    if (dw >= w) return s;
+    return s + " ".repeat(w - dw);
+  };
+  const separator = widths.map((w) => "─".repeat(w)).join("─┼─");
+  return (
+    <Box flexDirection="column">
+      <Box>
+        {block.header.map((cell, ci) => (
+          // biome-ignore lint/suspicious/noArrayIndexKey: table columns never reorder — derived from a static header array
+          <Text key={`h-${ci}`} bold color="cyan">
+            {pad(cell, widths[ci] ?? 3)}
+            {ci < colCount - 1 ? " │ " : ""}
+          </Text>
+        ))}
+      </Box>
+      <Text dimColor>{separator}</Text>
+      {block.rows.map((row, ri) => (
+        // biome-ignore lint/suspicious/noArrayIndexKey: table rows render in source order and don't reorder
+        <Box key={`r-${ri}`}>
+          {Array.from({ length: colCount }).map((_, ci) => (
+            // biome-ignore lint/suspicious/noArrayIndexKey: same — column axis is fixed by the table shape
+            <Text key={`c-${ri}-${ci}`}>
+              {pad(row[ci] ?? "", widths[ci] ?? 3)}
+              {ci < colCount - 1 ? " │ " : ""}
+            </Text>
+          ))}
+        </Box>
+      ))}
+    </Box>
+  );
+}
+
+/**
+ * Terminal display width of a string, approximately. CJK characters
+ * and full-width punctuation take 2 columns; everything else is 1.
+ * Good enough for aligning table cells in a Chinese-or-English mix;
+ * real wcwidth is bigger than we need to drag in for this use case.
+ */
+function displayWidth(s: string): number {
+  let w = 0;
+  for (const ch of s) {
+    const code = ch.codePointAt(0) ?? 0;
+    // CJK unified ideographs, full-width forms, hiragana/katakana,
+    // Hangul syllables — rough bucket, close enough for the terminal.
+    if (
+      (code >= 0x1100 && code <= 0x115f) ||
+      (code >= 0x2e80 && code <= 0x303e) ||
+      (code >= 0x3041 && code <= 0x33ff) ||
+      (code >= 0x3400 && code <= 0x4dbf) ||
+      (code >= 0x4e00 && code <= 0x9fff) ||
+      (code >= 0xa000 && code <= 0xa4cf) ||
+      (code >= 0xac00 && code <= 0xd7a3) ||
+      (code >= 0xf900 && code <= 0xfaff) ||
+      (code >= 0xfe30 && code <= 0xfe4f) ||
+      (code >= 0xff00 && code <= 0xff60) ||
+      (code >= 0xffe0 && code <= 0xffe6)
+    ) {
+      w += 2;
+    } else {
+      w += 1;
+    }
+  }
+  return w;
+}
+
+/**
+ * SEARCH/REPLACE rendered as a minimal diff: filename on top, red
+ * `-` lines, a gutter, green `+` lines. No inner markdown / inline
+ * parsing — content is shown verbatim so JSDoc `/**` and `*` won't
+ * be eaten by bold/italic regex.
+ *
+ * A truly empty SEARCH means "new file" and we label the filename
+ * accordingly instead of rendering an empty red half.
+ */
+function EditBlockRow({ block }: { block: EditBlockView }) {
+  const isNewFile = block.search.length === 0;
+  const searchLines = block.search.split("\n");
+  const replaceLines = block.replace.split("\n");
+  return (
+    <Box flexDirection="column" borderStyle="round" borderColor="cyan" paddingX={1}>
+      <Box>
+        <Text bold color="cyan">
+          {block.filename}
+        </Text>
+        {isNewFile ? (
+          <Text color="green" bold>
+            {" (new file)"}
+          </Text>
+        ) : null}
+      </Box>
+      {isNewFile ? null : (
+        <Box flexDirection="column" marginTop={1}>
+          {searchLines.map((line, i) => (
+            <Text key={`s-${i}-${line.length}`} color="red">
+              {`- ${line}`}
+            </Text>
+          ))}
+        </Box>
+      )}
+      <Box flexDirection="column" marginTop={isNewFile ? 1 : 0}>
+        {replaceLines.map((line, i) => (
+          <Text key={`r-${i}-${line.length}`} color="green">
+            {`+ ${line}`}
+          </Text>
+        ))}
+      </Box>
+    </Box>
+  );
+}
+
 export function Markdown({ text }: { text: string }) {
   const cleaned = stripMath(text);
   const blocks = React.useMemo(() => parseBlocks(cleaned), [cleaned]);

src/cli/ui/multiline-keys.ts

@@ -0,0 +1,199 @@
+/**
+ * Pure keystroke → action reducer for PromptInput.
+ *
+ * Kept separate from the React component so the keyboard semantics
+ * are easy to unit-test. The component threads `useInput` through
+ * this function and applies the returned action.
+ *
+ * Edit model:
+ *   - Full cursor support. ←/→ move one column. ↑/↓ move across
+ *     lines in a multi-line buffer (column preserved when possible).
+ *     Ctrl+A / Ctrl+E jump to start / end of the current line.
+ *   - Backspace deletes the char before the cursor; Delete deletes
+ *     the char under the cursor.
+ *   - Printable chars (including multi-char paste bursts) insert
+ *     at the cursor.
+ *   - Enter submits unless Shift is held (newline), the line ends
+ *     with '\' and cursor is at end (bash-style continuation), or
+ *     the input is Ctrl+J (LF, terminal-universal newline).
+ *   - Parent owns Tab, Esc, PageUp/Down (slash-complete, abort,
+ *     unused). Arrow keys are split: empty buffer → parent (history
+ *     recall); non-empty → child (cursor movement).
+ */
+
+export interface MultilineKey {
+  input: string;
+  return?: boolean;
+  shift?: boolean;
+  ctrl?: boolean;
+  meta?: boolean;
+  backspace?: boolean;
+  delete?: boolean;
+  tab?: boolean;
+  upArrow?: boolean;
+  downArrow?: boolean;
+  leftArrow?: boolean;
+  rightArrow?: boolean;
+  escape?: boolean;
+  pageUp?: boolean;
+  pageDown?: boolean;
+}
+
+export interface MultilineAction {
+  /** New buffer value. `null` = unchanged. */
+  next: string | null;
+  /** New cursor position (0..value.length). `null` = unchanged. */
+  cursor: number | null;
+  /** When `true`, fire `onSubmit(submitValue ?? value)`. */
+  submit: boolean;
+  submitValue?: string;
+}
+
+const BACKSLASH_SUFFIX = /\\$/;
+
+const NOOP: MultilineAction = { next: null, cursor: null, submit: false };
+
+export function processMultilineKey(
+  value: string,
+  cursor: number,
+  key: MultilineKey,
+): MultilineAction {
+  // Parent-owned keys: Tab (slash-complete), Esc (abort), PageUp/Down.
+  if (key.tab || key.escape || key.pageUp || key.pageDown) {
+    return NOOP;
+  }
+
+  // Empty buffer + ↑/↓ → parent handles history recall.
+  if (value.length === 0 && (key.upArrow || key.downArrow)) {
+    return NOOP;
+  }
+
+  // Cursor motion.
+  if (key.leftArrow) {
+    return { next: null, cursor: Math.max(0, cursor - 1), submit: false };
+  }
+  if (key.rightArrow) {
+    return { next: null, cursor: Math.min(value.length, cursor + 1), submit: false };
+  }
+  if (key.upArrow) {
+    const moved = moveCursorUp(value, cursor);
+    return moved === cursor ? NOOP : { next: null, cursor: moved, submit: false };
+  }
+  if (key.downArrow) {
+    const moved = moveCursorDown(value, cursor);
+    return moved === cursor ? NOOP : { next: null, cursor: moved, submit: false };
+  }
+
+  // Emacs-style line jumps (universal across terminals; Home/End aren't
+  // reliably reported by Ink so we don't depend on them).
+  if (key.ctrl && key.input === "a") {
+    return { next: null, cursor: startOfLine(value, cursor), submit: false };
+  }
+  if (key.ctrl && key.input === "e") {
+    return { next: null, cursor: endOfLine(value, cursor), submit: false };
+  }
+
+  // Newline: Ctrl+J (LF literal) or ctrl+'j' normalized form.
+  if (key.input === "\n" || (key.ctrl && key.input === "j")) {
+    return insertAt(value, cursor, "\n");
+  }
+
+  if (key.return) {
+    if (key.shift) return insertAt(value, cursor, "\n");
+    // Bash-style line continuation: trailing '\' + Enter (only when the
+    // cursor sits at end-of-buffer, so a stray '\' mid-line doesn't
+    // trigger it).
+    if (cursor === value.length && BACKSLASH_SUFFIX.test(value)) {
+      const replaced = `${value.slice(0, -1)}\n`;
+      return { next: replaced, cursor: replaced.length, submit: false };
+    }
+    return { next: null, cursor: null, submit: true, submitValue: value };
+  }
+
+  // Backspace = delete the char BEFORE the cursor. We also accept
+  // `key.delete` and the raw DEL (0x7f) / BS (0x08) bytes as backspace
+  // for the same purpose — some Windows terminals (cmd.exe, certain
+  // winpty configs) report plain Backspace without setting
+  // `key.backspace`, which used to leave the user typing into a prompt
+  // where the Backspace key did nothing. Reasonix doesn't offer a
+  // separate forward-delete operation, so collapsing them is safe.
+  if (key.backspace || key.delete || key.input === "\x7f" || key.input === "\b") {
+    if (cursor === 0) return NOOP;
+    return {
+      next: value.slice(0, cursor - 1) + value.slice(cursor),
+      cursor: cursor - 1,
+      submit: false,
+    };
+  }
+
+  // Bare modifier events (Ctrl/Meta with no printable) and unhandled
+  // Ctrl-<letter> chords are dropped so a stray Ctrl+L doesn't insert "l".
+  if ((key.ctrl || key.meta) && key.input.length === 0) return NOOP;
+  if (key.ctrl || key.meta) return NOOP;
+
+  // Printable input (may be a multi-char paste; pasted newlines land
+  // inside the buffer rather than triggering submit on the first line).
+  if (key.input.length > 0) {
+    return insertAt(value, cursor, key.input);
+  }
+
+  return NOOP;
+}
+
+function insertAt(value: string, cursor: number, insert: string): MultilineAction {
+  return {
+    next: value.slice(0, cursor) + insert + value.slice(cursor),
+    cursor: cursor + insert.length,
+    submit: false,
+  };
+}
+
+/**
+ * Line + column of a cursor inside a buffer. Exported because the
+ * renderer needs the same mapping for drawing the cursor block on the
+ * right line.
+ */
+export function lineAndColumn(value: string, cursor: number): { line: number; col: number } {
+  let line = 0;
+  let col = 0;
+  const n = Math.min(cursor, value.length);
+  for (let i = 0; i < n; i++) {
+    if (value[i] === "\n") {
+      line++;
+      col = 0;
+    } else {
+      col++;
+    }
+  }
+  return { line, col };
+}
+
+function startOfLine(value: string, cursor: number): number {
+  return value.lastIndexOf("\n", cursor - 1) + 1;
+}
+
+function endOfLine(value: string, cursor: number): number {
+  const nl = value.indexOf("\n", cursor);
+  return nl === -1 ? value.length : nl;
+}
+
+function moveCursorUp(value: string, cursor: number): number {
+  const curStart = startOfLine(value, cursor);
+  if (curStart === 0) return cursor; // already on the first line
+  const col = cursor - curStart;
+  const prevEnd = curStart - 1; // the '\n' between the two lines
+  const prevStart = value.lastIndexOf("\n", prevEnd - 1) + 1;
+  const prevLen = prevEnd - prevStart;
+  return prevStart + Math.min(col, prevLen);
+}
+
+function moveCursorDown(value: string, cursor: number): number {
+  const nextNl = value.indexOf("\n", cursor);
+  if (nextNl === -1) return cursor; // already on the last line
+  const curStart = startOfLine(value, cursor);
+  const col = cursor - curStart;
+  const nextStart = nextNl + 1;
+  const followingNl = value.indexOf("\n", nextStart);
+  const nextLen = (followingNl === -1 ? value.length : followingNl) - nextStart;
+  return nextStart + Math.min(col, nextLen);
+}

src/cli/ui/presets.ts

@@ -0,0 +1,42 @@
+/**
+ * One place that defines what each preset means. Both `slash.ts`
+ * (in-chat `/preset`) and the wizard (first-run setup) read from here.
+ *
+ * Presets are the single vocabulary we teach new users: they don't need
+ * to know model IDs, Pillar 2, branch budgets, or cost tradeoffs
+ * independently — they pick "fast / smart / max" and we translate.
+ */
+
+import type { PresetName } from "../../config.js";
+
+export interface PresetSettings {
+  model: string;
+  harvest: boolean;
+  /** Branch budget. `1` means branching off. */
+  branch: number;
+}
+
+export const PRESETS: Record<PresetName, PresetSettings> = {
+  fast: { model: "deepseek-chat", harvest: false, branch: 1 },
+  smart: { model: "deepseek-reasoner", harvest: true, branch: 1 },
+  max: { model: "deepseek-reasoner", harvest: true, branch: 3 },
+};
+
+export const PRESET_DESCRIPTIONS: Record<PresetName, { headline: string; cost: string }> = {
+  fast: {
+    headline: "deepseek-chat, no reasoning harvest, no branching",
+    cost: "~1¢ per 100 turns · default",
+  },
+  smart: {
+    headline: "deepseek-reasoner + Pillar 2 harvest",
+    cost: "~10× cost vs fast · slower · better on multi-step tasks",
+  },
+  max: {
+    headline: "reasoner + harvest + self-consistency (3 branches)",
+    cost: "~30× cost vs fast · slowest · for hard single-shots",
+  },
+};
+
+export function resolvePreset(name: PresetName | undefined): PresetSettings {
+  return PRESETS[name ?? "fast"];
+}

src/cli/ui/slash.ts

@@ -1,5 +1,11 @@
+import { spawnSync } from "node:child_process";
 import type { CacheFirstLoop } from "../../loop.js";
+import type { InspectionReport } from "../../mcp/inspect.js";
+import { PROJECT_MEMORY_FILE, memoryEnabled, readProjectMemory } from "../../project-memory.js";
 import { deleteSession, listSessions } from "../../session.js";
+import { SkillStore } from "../../skills.js";
+import { DEEPSEEK_CONTEXT_TOKENS, DEFAULT_CONTEXT_TOKENS } from "../../telemetry.js";
+import { type MemoryScope, MemoryStore } from "../../user-memory.js";
 
 export interface SlashResult {
   /** Text to display back to the user as a system/info line. */
@@ -10,6 +16,197 @@ export interface SlashResult {
   clear?: boolean;
   /** Unknown command — display usage hint. */
   unknown?: boolean;
+  /**
+   * Re-submit this text as a user message after displaying `info`.
+   * Used by `/retry` — the slash command truncates the log, then
+   * asks the TUI to push the original text back through the normal
+   * submit flow so a fresh turn runs.
+   */
+  resubmit?: string;
+}
+
+/**
+ * Extra runtime context a slash handler may care about but that isn't
+ * already on the loop. Kept as an optional object so tests that only
+ * need loop-scoped commands can skip it, and callers only populate the
+ * slots that apply to their session.
+ */
+export interface SlashContext {
+  /**
+   * The exact `--mcp` / config-derived spec strings that were bridged
+   * into this session (one entry per server). Used by `/mcp`. Empty or
+   * omitted → no MCP servers attached.
+   */
+  mcpSpecs?: string[];
+  /**
+   * Callback for `/undo` — provided by the TUI when it's running in
+   * code mode. Returns a human-readable report of what was restored.
+   * Absent outside code mode → `/undo` replies "not available here".
+   */
+  codeUndo?: () => string;
+  /**
+   * Callback for `/apply` — commits pending edit blocks to disk. Returns
+   * a report of what landed. Absent → `/apply` replies "nothing pending"
+   * or "not available outside code mode".
+   */
+  codeApply?: () => string;
+  /**
+   * Callback for `/discard` — drops the pending edit blocks without
+   * touching disk.
+   */
+  codeDiscard?: () => string;
+  /**
+   * Root directory passed by `reasonix code`. Enables `/commit`, which
+   * runs `git add -A && git commit` in this directory. Missing → `/commit`
+   * replies "only available in code mode".
+   */
+  codeRoot?: string;
+  /**
+   * How many edit blocks are currently pending `/apply` or `/discard`.
+   * Surfaced by `/status`. TUI populates it live from its pending ref;
+   * omitted → treat as 0 (chat-only session).
+   */
+  pendingEditCount?: number;
+  /**
+   * Callback returning every tool result seen this session in
+   * chronological order (oldest first). Powers `/tool [N]` for
+   * inspecting the full untruncated output that `EventLog` clips at
+   * 400 chars for display. Absent → `/tool` replies "not available".
+   */
+  toolHistory?: () => Array<{ toolName: string; text: string }>;
+  /**
+   * Pre-captured inspection reports for each connected MCP server.
+   * Populated once at chat startup (chat.tsx) so `/mcp` can render
+   * tools + resources + prompts synchronously without needing async
+   * handler support.
+   */
+  mcpServers?: McpServerSummary[];
+  /**
+   * Directory `/memory` should resolve `REASONIX.md` from. In code
+   * mode this is the rootDir the filesystem tools are pinned to; in
+   * plain chat this is `process.cwd()` at launch time. Absent → the
+   * TUI is running in some non-cwd context (tests) and `/memory`
+   * replies "root unknown" instead of silently reading a different dir.
+   */
+  memoryRoot?: string;
+  /**
+   * Current plan-mode state, surfaced in `/status` and toggled by
+   * `/plan`. Present iff the session is a `reasonix code` run — chat
+   * mode doesn't have plan mode.
+   */
+  planMode?: boolean;
+  /**
+   * Callback the `/plan` slash uses to flip plan mode on/off. Also
+   * mirrors the state to the underlying ToolRegistry so dispatch
+   * enforcement follows. Absent → `/plan` replies "only available in
+   * code mode".
+   */
+  setPlanMode?: (on: boolean) => void;
+  /**
+   * Callback that clears a pending-plan picker state. Called by
+   * `/apply-plan` so that when the user force-approves, the picker
+   * dismisses without also firing its own approval synthetic (the
+   * slash returns its own `resubmit` instead). Safe to call with no
+   * pending plan.
+   */
+  clearPendingPlan?: () => void;
+}
+
+export interface McpServerSummary {
+  /** Short label shown in the `/mcp` output (server namespace or "anon"). */
+  label: string;
+  /** Original --mcp spec string. */
+  spec: string;
+  /** Count of tools bridged into the Reasonix registry from this server. */
+  toolCount: number;
+  /** Full inspection snapshot — used for the resources + prompts sections. */
+  report: InspectionReport;
+}
+
+/**
+ * Slash command registry. Drives `/help`, the on-type suggestion
+ * popup (`SlashSuggestions`), and auto-complete. Kept as data rather
+ * than derived from the `handleSlash` switch so summaries can be
+ * user-facing rather than code comments.
+ *
+ * `contextual` gates commands that only make sense in certain modes:
+ *   - `"code"` — only show when the TUI is running `reasonix code`
+ *   - absent → always shown
+ */
+export interface SlashCommandSpec {
+  cmd: string;
+  summary: string;
+  contextual?: "code";
+  /** If the command takes args, hint text shown after the name. */
+  argsHint?: string;
+}
+
+export const SLASH_COMMANDS: readonly SlashCommandSpec[] = [
+  { cmd: "help", summary: "show the full command reference" },
+  { cmd: "status", summary: "current model, flags, context, session" },
+  {
+    cmd: "preset",
+    argsHint: "<fast|smart|max>",
+    summary: "one-tap model + harvest + branch bundle",
+  },
+  { cmd: "model", argsHint: "<id>", summary: "switch DeepSeek model id" },
+  { cmd: "harvest", argsHint: "[on|off]", summary: "toggle Pillar-2 plan-state extraction" },
+  { cmd: "branch", argsHint: "<N|off>", summary: "run N parallel samples per turn (N>=2)" },
+  { cmd: "mcp", summary: "list MCP servers + tools attached to this session" },
+  { cmd: "tool", argsHint: "[N]", summary: "dump full output of the Nth tool call (1=latest)" },
+  {
+    cmd: "memory",
+    argsHint: "[list|show <name>|forget <name>|clear <scope> confirm]",
+    summary: "show / manage pinned memory (REASONIX.md + ~/.reasonix/memory)",
+  },
+  {
+    cmd: "skill",
+    argsHint: "[list|show <name>|<name> [args]]",
+    summary: "list / run user skills (<project>/.reasonix/skills + ~/.reasonix/skills)",
+  },
+  { cmd: "think", summary: "dump the last turn's full R1 reasoning (reasoner only)" },
+  { cmd: "retry", summary: "truncate & resend your last message (fresh sample)" },
+  { cmd: "compact", argsHint: "[cap]", summary: "shrink oversized tool results in the log" },
+  { cmd: "sessions", summary: "list saved sessions (current marked with ▸)" },
+  { cmd: "forget", summary: "delete the current session from disk" },
+  { cmd: "setup", summary: "reminds you to exit and run `reasonix setup`" },
+  { cmd: "clear", summary: "clear visible scrollback only (log/context kept)" },
+  { cmd: "new", summary: "start a fresh conversation (clear context + scrollback)" },
+  { cmd: "exit", summary: "quit the TUI" },
+  // Code-mode only
+  { cmd: "apply", summary: "commit pending edit blocks to disk", contextual: "code" },
+  { cmd: "discard", summary: "drop pending edit blocks without writing", contextual: "code" },
+  { cmd: "undo", summary: "roll back the last applied edit batch", contextual: "code" },
+  {
+    cmd: "commit",
+    argsHint: '"msg"',
+    summary: "git add -A && git commit -m ...",
+    contextual: "code",
+  },
+  {
+    cmd: "plan",
+    argsHint: "[on|off]",
+    summary: "toggle read-only plan mode (writes bounced until submit_plan + approval)",
+    contextual: "code",
+  },
+  {
+    cmd: "apply-plan",
+    summary: "force-approve a pending / in-text plan (fallback if picker was missed)",
+    contextual: "code",
+  },
+];
+
+/**
+ * Filter the registry by a prefix string (without the leading `/`).
+ * Empty prefix returns the full non-contextual list (plus code-mode
+ * entries when `codeMode` is true). Case-insensitive.
+ */
+export function suggestSlashCommands(prefix: string, codeMode = false): SlashCommandSpec[] {
+  const p = prefix.toLowerCase();
+  return SLASH_COMMANDS.filter((c) => {
+    if (c.contextual === "code" && !codeMode) return false;
+    return c.cmd.startsWith(p);
+  });
 }
 
 export function parseSlash(text: string): { cmd: string; args: string[] } | null {
@@ -20,14 +217,34 @@ export function parseSlash(text: string): { cmd: string; args: string[] } | null
   return { cmd, args: parts.slice(1) };
 }
 
-export function handleSlash(cmd: string, args: string[], loop: CacheFirstLoop): SlashResult {
+export function handleSlash(
+  cmd: string,
+  args: string[],
+  loop: CacheFirstLoop,
+  ctx: SlashContext = {},
+): SlashResult {
   switch (cmd) {
     case "exit":
     case "quit":
       return { exit: true };
 
     case "clear":
-      return { clear: true };
+      return {
+        clear: true,
+        info: "▸ cleared visible scrollback only. Context (message log) is intact — next turn still sees everything. Use /new to start fresh, or /forget to delete the session entirely.",
+      };
+
+    case "new":
+    case "reset": {
+      // Actually drop the in-memory log + rewrite the session file
+      // so the NEXT call has no prior context. Keeps session name,
+      // model, and other config — just the conversation is reset.
+      const { dropped } = loop.clearLog();
+      return {
+        clear: true,
+        info: `▸ new conversation — dropped ${dropped} message(s) from context. Same session, fresh slate.`,
+      };
+    }
 
     case "help":
     case "?":
@@ -40,9 +257,26 @@ export function handleSlash(cmd: string, args: string[], loop: CacheFirstLoop):
           "  /model <id>              deepseek-chat or deepseek-reasoner",
           "  /harvest [on|off]        Pillar 2: structured plan-state extraction",
           "  /branch <N|off>          run N parallel samples (N>=2), pick most confident",
+          "  /mcp                     list MCP servers + tools attached to this session",
+          "  /setup                   (exit + reconfigure) → run `reasonix setup`",
+          "  /compact [cap]           shrink large tool results in history (default 4k/result)",
+          "  /think                   dump the most recent turn's full R1 reasoning (reasoner only)",
+          "  /tool [N]                list tool calls (or dump full output of #N, 1=most recent)",
+          "  /memory [sub]            show pinned memory (REASONIX.md + ~/.reasonix/memory).",
+          "                            subs: list | show <name> | forget <name> | clear <scope> confirm",
+          "  /skill [sub]             list / run user skills (project/.reasonix/skills + ~/.reasonix/skills).",
+          "                            subs: list | show <name> | <name> [args] (injects skill body as user turn)",
+          "  /retry                   truncate & resend your last message (fresh sample from the model)",
+          "  /apply                   (code mode) commit the pending edit blocks to disk",
+          "  /discard                 (code mode) drop pending edits without writing",
+          "  /undo                    (code mode) roll back the last applied edit batch",
+          '  /commit "msg"            (code mode) git add -A && git commit -m "msg"',
+          "  /plan [on|off]           (code mode) toggle read-only plan mode; writes gated behind submit_plan + your approval",
+          "  /apply-plan              (code mode) force-approve pending/in-text plan (fallback)",
           "  /sessions                list saved sessions (current is marked with ▸)",
           "  /forget                  delete the current session from disk",
-          "  /clear                   clear displayed history (log + session kept)",
+          "  /new                     start fresh: drop all context + clear scrollback",
+          "  /clear                   clear displayed scrollback only (context kept — model still sees it)",
           "  /exit                    quit",
           "",
           "Presets:",
@@ -56,6 +290,240 @@ export function handleSlash(cmd: string, args: string[], loop: CacheFirstLoop):
         ].join("\n"),
       };
 
+    case "mcp": {
+      const servers = ctx.mcpServers ?? [];
+      const specs = ctx.mcpSpecs ?? [];
+      const toolSpecs = loop.prefix.toolSpecs ?? [];
+      if (servers.length === 0 && specs.length === 0 && toolSpecs.length === 0) {
+        return {
+          info:
+            "no MCP servers attached. Run `reasonix setup` to pick some, " +
+            'or launch with --mcp "<spec>". `reasonix mcp list` shows the catalog.',
+        };
+      }
+      // Rich path — we have full inspection reports, so show each
+      // server with its tools / resources / prompts grouped together.
+      if (servers.length > 0) {
+        const lines: string[] = [];
+        for (const s of servers) {
+          const { report } = s;
+          const serverName = report.serverInfo.name || "(unknown)";
+          const serverVer = report.serverInfo.version ? ` v${report.serverInfo.version}` : "";
+          lines.push(`[${s.label}] ${serverName}${serverVer}  —  ${s.spec}`);
+          lines.push(`  tools     ${s.toolCount}`);
+          appendSection(lines, "resources", report.resources);
+          appendSection(lines, "prompts  ", report.prompts);
+          lines.push("");
+        }
+        lines.push(
+          "Chat mode consumes tools today; resources+prompts are surfaced here for awareness.",
+        );
+        lines.push(
+          "Full catalog: `reasonix mcp list` · deeper diagnosis: `reasonix mcp inspect <spec>`.",
+        );
+        return { info: lines.join("\n") };
+      }
+      // Fallback — older path when the TUI hasn't populated `mcpServers`.
+      const lines: string[] = [];
+      if (specs.length > 0) {
+        lines.push(`MCP servers (${specs.length}):`);
+        for (const spec of specs) lines.push(`  · ${spec}`);
+        lines.push("");
+      }
+      if (toolSpecs.length > 0) {
+        lines.push(`Tools in registry (${toolSpecs.length}):`);
+        for (const t of toolSpecs) lines.push(`  · ${t.function.name}`);
+      }
+      lines.push("");
+      lines.push("To change this set, exit and run `reasonix setup`.");
+      return { info: lines.join("\n") };
+    }
+
+    case "setup":
+      return {
+        info:
+          "To reconfigure (preset, MCP servers, API key), exit this chat and run " +
+          "`reasonix setup`. Changes take effect on next launch.",
+      };
+
+    case "retry": {
+      const prev = loop.retryLastUser();
+      if (!prev) {
+        return {
+          info: "nothing to retry — no prior user message in this session's log.",
+        };
+      }
+      const preview = prev.length > 80 ? `${prev.slice(0, 80)}…` : prev;
+      return {
+        info: `▸ retrying: "${preview}"`,
+        resubmit: prev,
+      };
+    }
+
+    case "memory": {
+      return handleMemorySlash(args, ctx);
+    }
+
+    case "skill":
+    case "skills": {
+      return handleSkillSlash(args, ctx);
+    }
+
+    case "think":
+    case "reasoning": {
+      const raw = loop.scratch.reasoning;
+      if (!raw || !raw.trim()) {
+        return {
+          info:
+            "no reasoning cached. `/think` shows the full R1 thought for the most recent turn — " +
+            "only `deepseek-reasoner` produces it, and only once the turn completes.",
+        };
+      }
+      return { info: `↳ full thinking (${raw.length} chars):\n\n${raw.trim()}` };
+    }
+
+    case "tool": {
+      // EventLog truncates tool results at 400 chars for display. When
+      // the user wants to check what the model actually read (e.g. to
+      // verify it isn't hallucinating a file's contents), they need
+      // the full text. `/tool` is the escape hatch.
+      const history = ctx.toolHistory?.() ?? [];
+      if (history.length === 0) {
+        return {
+          info:
+            "no tool calls yet in this session. `/tool` lists them once the model has actually " +
+            "used a tool; `/tool N` dumps the full (untruncated) output of the Nth-most-recent.",
+        };
+      }
+      const raw = (args[0] ?? "").toLowerCase();
+      if (raw === "" || raw === "list" || raw === "ls") {
+        return { info: formatToolList(history) };
+      }
+      const n = Number.parseInt(raw, 10);
+      if (!Number.isFinite(n) || n < 1) {
+        return {
+          info: "usage: /tool [N]   (no arg → list; N=1 → most recent result in full, N=2 → previous, …)",
+        };
+      }
+      if (n > history.length) {
+        return {
+          info: `only ${history.length} tool call(s) in history — asked for #${n}. Try /tool with no arg to see the list.`,
+        };
+      }
+      const entry = history[history.length - n];
+      if (!entry) {
+        return { info: `could not read tool call #${n}` };
+      }
+      return {
+        info: `↳ tool<${entry.toolName}> #${n} (${entry.text.length} chars):\n\n${entry.text}`,
+      };
+    }
+
+    case "undo": {
+      if (!ctx.codeUndo) {
+        return {
+          info: "/undo is only available inside `reasonix code` — chat mode doesn't apply edits.",
+        };
+      }
+      return { info: ctx.codeUndo() };
+    }
+
+    case "apply": {
+      if (!ctx.codeApply) {
+        return {
+          info: "/apply is only available inside `reasonix code` (nothing to apply here).",
+        };
+      }
+      return { info: ctx.codeApply() };
+    }
+
+    case "discard": {
+      if (!ctx.codeDiscard) {
+        return {
+          info: "/discard is only available inside `reasonix code`.",
+        };
+      }
+      return { info: ctx.codeDiscard() };
+    }
+
+    case "plan": {
+      if (!ctx.setPlanMode) {
+        return {
+          info: "/plan is only available inside `reasonix code` — chat mode doesn't gate tool writes.",
+        };
+      }
+      const currentOn = Boolean(ctx.planMode);
+      const raw = (args[0] ?? "").toLowerCase();
+      let target: boolean;
+      if (raw === "on" || raw === "true" || raw === "1") target = true;
+      else if (raw === "off" || raw === "false" || raw === "0") target = false;
+      else target = !currentOn;
+      ctx.setPlanMode(target);
+      if (target) {
+        return {
+          info: "▸ plan mode ON — write tools are gated; the model MUST call `submit_plan` before anything executes. (The model can also call submit_plan on its own for big tasks even when plan mode is off — this toggle is the stronger, explicit constraint.) Type /plan off to leave.",
+        };
+      }
+      return {
+        info: "▸ plan mode OFF — write tools are live again. Model can still propose plans autonomously for large tasks.",
+      };
+    }
+
+    case "apply-plan":
+    case "applyplan": {
+      if (!ctx.setPlanMode) {
+        return {
+          info: "/apply-plan is only available inside `reasonix code`.",
+        };
+      }
+      ctx.setPlanMode(false);
+      ctx.clearPendingPlan?.();
+      return {
+        info: "▸ plan approved — implementing",
+        resubmit:
+          "The plan above has been approved. Implement it now. You are out of plan mode — use edit_file / write_file / run_command as needed. Stick to the plan unless you discover a concrete reason to deviate; if you do, tell me and wait for a response before making that deviation.",
+      };
+    }
+
+    case "commit": {
+      if (!ctx.codeRoot) {
+        return {
+          info: "/commit is only available inside `reasonix code` (needs a rooted git repo).",
+        };
+      }
+      // Reassemble the original argv. The parser lowercases cmd but
+      // leaves args alone, and the TUI splits on whitespace which
+      // mangles quoted messages — rejoin with spaces and strip a
+      // surrounding pair of double quotes if the user wrote them.
+      const raw = args.join(" ").trim();
+      const message = stripOuterQuotes(raw);
+      if (!message) {
+        return {
+          info: `usage: /commit "your commit message"  — runs \`git add -A && git commit -m "…"\` in ${ctx.codeRoot}`,
+        };
+      }
+      return runGitCommit(ctx.codeRoot, message);
+    }
+
+    case "compact": {
+      // Manual companion to the automatic heal-on-load. Re-applies
+      // truncation with a tighter cap (4k chars per tool result) and
+      // rewrites the session file so the shrink persists. Useful when
+      // the ctx gauge in StatsPanel goes yellow/red mid-session and
+      // the user wants to keep chatting without /forget'ing everything.
+      const tight = Number.parseInt(args[0] ?? "", 10);
+      const cap = Number.isFinite(tight) && tight >= 500 ? tight : 4000;
+      const { healedCount, charsSaved } = loop.compact(cap);
+      if (healedCount === 0) {
+        return {
+          info: `▸ nothing to compact — no tool result in history exceeds ${cap.toLocaleString()} chars.`,
+        };
+      }
+      return {
+        info: `▸ compacted ${healedCount} tool result(s), saved ${charsSaved.toLocaleString()} chars (~${Math.round(charsSaved / 4).toLocaleString()} tokens). Session file rewritten.`,
+      };
+    }
+
     case "sessions": {
       const items = listSessions();
       if (items.length === 0) {
@@ -92,13 +560,33 @@ export function handleSlash(cmd: string, args: string[], loop: CacheFirstLoop):
 
     case "status": {
       const branchBudget = loop.branchOptions.budget ?? 1;
-      return {
-        info:
-          `model=${loop.model}  ` +
-          `harvest=${loop.harvestEnabled ? "on" : "off"}  ` +
-          `branch=${branchBudget > 1 ? branchBudget : "off"}  ` +
-          `stream=${loop.stream ? "on" : "off"}`,
-      };
+      const ctxMax = DEEPSEEK_CONTEXT_TOKENS[loop.model] ?? DEFAULT_CONTEXT_TOKENS;
+      const lastPromptTokens = loop.stats.summary().lastPromptTokens;
+      const ctxPct = ctxMax > 0 ? Math.round((lastPromptTokens / ctxMax) * 100) : 0;
+      const ctxLine =
+        lastPromptTokens > 0
+          ? `  ctx    ${compactNum(lastPromptTokens)}/${compactNum(ctxMax)} (${ctxPct}%)`
+          : "  ctx    no turns yet";
+      const pending = ctx.pendingEditCount ?? 0;
+      const sessionLine = loop.sessionName
+        ? `  session "${loop.sessionName}" · ${loop.log.length} messages in log (resumed ${loop.resumedMessageCount})`
+        : "  session (ephemeral — no persistence)";
+      const mcpCount = ctx.mcpSpecs?.length ?? 0;
+      const toolCount = loop.prefix.toolSpecs.length;
+      const mcpLine = `  mcp     ${mcpCount} server(s), ${toolCount} tool(s) in registry`;
+      const pendingLine =
+        pending > 0 ? `  edits   ${pending} pending (/apply to commit, /discard to drop)` : "";
+      const planLine = ctx.planMode ? "  plan    ON — writes gated (submit_plan + approval)" : "";
+      const lines = [
+        `  model   ${loop.model}`,
+        `  flags   harvest=${loop.harvestEnabled ? "on" : "off"} · branch=${branchBudget > 1 ? branchBudget : "off"} · stream=${loop.stream ? "on" : "off"}`,
+        ctxLine,
+        mcpLine,
+        sessionLine,
+      ];
+      if (pendingLine) lines.push(pendingLine);
+      if (planLine) lines.push(planLine);
+      return { info: lines.join("\n") };
     }
 
     case "model": {
@@ -155,3 +643,385 @@ export function handleSlash(cmd: string, args: string[], loop: CacheFirstLoop):
       return { unknown: true, info: `unknown command: /${cmd}  (try /help)` };
   }
 }
+
+/**
+ * `/skill` family. Bare `/skill` (or `/skill list`) prints the
+ * discovered skills from `<projectRoot>/.reasonix/skills` (code mode
+ * only) + `~/.reasonix/skills`. `/skill show <name>` dumps one body
+ * inline for reading. `/skill <name> [args...]` injects the skill body
+ * as a user turn via `resubmit` — the same mechanism `/apply-plan`
+ * uses — so the next model turn runs with the skill's instructions
+ * fresh in the log.
+ *
+ * Project scope is only populated when the session has a `codeRoot`
+ * (set by `reasonix code`). In plain chat mode the store reads the
+ * global scope only, matching how user-memory behaves.
+ */
+function handleSkillSlash(args: string[], ctx: SlashContext): SlashResult {
+  const store = new SkillStore({ projectRoot: ctx.codeRoot });
+  const sub = (args[0] ?? "").toLowerCase();
+
+  if (sub === "" || sub === "list" || sub === "ls") {
+    const skills = store.list();
+    if (skills.length === 0) {
+      const lines = ["no skills found. Reasonix reads skills from:"];
+      if (store.hasProjectScope()) {
+        lines.push(
+          "  · <project>/.reasonix/skills/<name>/SKILL.md  (or <name>.md)  — project scope",
+        );
+      }
+      lines.push("  · ~/.reasonix/skills/<name>/SKILL.md  (or <name>.md)  — global scope");
+      if (!store.hasProjectScope()) {
+        lines.push("  (project scope is only active in `reasonix code`)");
+      }
+      lines.push(
+        "",
+        "Each file's frontmatter needs at least `name` and `description`.",
+        "Invoke a skill with `/skill <name> [args]` or by asking the model to call `run_skill`.",
+      );
+      return { info: lines.join("\n") };
+    }
+    const lines = [`User skills (${skills.length}):`];
+    for (const s of skills) {
+      const scope = `(${s.scope})`.padEnd(11);
+      const name = s.name.padEnd(24);
+      const desc = s.description.length > 70 ? `${s.description.slice(0, 69)}…` : s.description;
+      lines.push(`  ${scope} ${name}  ${desc}`);
+    }
+    lines.push("");
+    lines.push("View body: /skill show <name>   Run: /skill <name> [args]");
+    return { info: lines.join("\n") };
+  }
+
+  if (sub === "show" || sub === "cat") {
+    const target = args[1];
+    if (!target) return { info: "usage: /skill show <name>" };
+    const skill = store.read(target);
+    if (!skill) return { info: `no skill found: ${target}` };
+    return {
+      info: [
+        `▸ ${skill.name}  (${skill.scope})`,
+        skill.description ? `  ${skill.description}` : "",
+        `  ${skill.path}`,
+        "",
+        skill.body,
+      ]
+        .filter((l) => l !== "")
+        .join("\n"),
+    };
+  }
+
+  // Bare `/skill <name> [args...]` — inject the body as a user turn.
+  // The first arg is the skill name; remaining args are forwarded
+  // verbatim as the skill's "Arguments:" line.
+  const name = args[0] ?? "";
+  const skill = store.read(name);
+  if (!skill) {
+    return {
+      info: `no skill found: ${name}  (try /skill list)`,
+    };
+  }
+  const extra = args.slice(1).join(" ").trim();
+  const header = `# Skill: ${skill.name}${skill.description ? `\n> ${skill.description}` : ""}`;
+  const argsLine = extra ? `\n\nArguments: ${extra}` : "";
+  const payload = `${header}\n\n${skill.body}${argsLine}`;
+  return {
+    info: `▸ running skill: ${skill.name}${extra ? ` — ${extra}` : ""}`,
+    resubmit: payload,
+  };
+}
+
+/**
+ * `/memory` family. Bare `/memory` shows what's pinned (REASONIX.md +
+ * both MEMORY.md blocks). Subcommands manage the user-memory store:
+ *   list                 — every memory file, both scopes
+ *   show <name>          — dump one file's body
+ *   show <scope>/<name>  — disambiguate when name exists in both scopes
+ *   forget <name>        — delete (same scope resolution as show)
+ *   clear <scope> confirm — wipe a scope (typed literal "confirm" required)
+ */
+function handleMemorySlash(args: string[], ctx: SlashContext): SlashResult {
+  if (!memoryEnabled()) {
+    return {
+      info: "memory is disabled (REASONIX_MEMORY=off in env). Unset the var to re-enable — no REASONIX.md or ~/.reasonix/memory content will be pinned in the meantime.",
+    };
+  }
+  if (!ctx.memoryRoot) {
+    return {
+      info: "no working directory on this session — `/memory` needs a root to resolve REASONIX.md from. (Running in a test harness?)",
+    };
+  }
+  // `codeRoot` is set only when running `reasonix code`. Chat mode has
+  // `memoryRoot` = cwd (for REASONIX.md), but we don't treat cwd as a
+  // sandbox — project-scope user memory requires a real code-mode root.
+  const store = new MemoryStore({ projectRoot: ctx.codeRoot });
+  const sub = (args[0] ?? "").toLowerCase();
+
+  if (sub === "list" || sub === "ls") {
+    const entries = store.list();
+    if (entries.length === 0) {
+      return {
+        info: "no user memories yet. The model can call `remember` to save one, or you can create files by hand in ~/.reasonix/memory/global/ or the per-project subdir.",
+      };
+    }
+    const lines = [`User memories (${entries.length}):`];
+    for (const e of entries) {
+      const tag = `${e.scope}/${e.type}`.padEnd(18);
+      const name = e.name.padEnd(28);
+      const desc = e.description.length > 70 ? `${e.description.slice(0, 69)}…` : e.description;
+      lines.push(`  ${tag}  ${name}  ${desc}`);
+    }
+    lines.push("");
+    lines.push("View body: /memory show <name>   Delete: /memory forget <name>");
+    return { info: lines.join("\n") };
+  }
+
+  if (sub === "show" || sub === "cat") {
+    const target = args[1];
+    if (!target) return { info: "usage: /memory show <name>  or  /memory show <scope>/<name>" };
+    const resolved = resolveMemoryTarget(store, target);
+    if (!resolved) return { info: `no memory found: ${target}` };
+    try {
+      const entry = store.read(resolved.scope, resolved.name);
+      return {
+        info: [
+          `▸ ${entry.scope}/${entry.name}  (${entry.type}, created ${entry.createdAt || "?"})`,
+          entry.description ? `  ${entry.description}` : "",
+          "",
+          entry.body,
+        ]
+          .filter((l) => l !== "")
+          .concat("")
+          .join("\n"),
+      };
+    } catch (err) {
+      return { info: `show failed: ${(err as Error).message}` };
+    }
+  }
+
+  if (sub === "forget" || sub === "rm" || sub === "delete") {
+    const target = args[1];
+    if (!target) return { info: "usage: /memory forget <name>  or  /memory forget <scope>/<name>" };
+    const resolved = resolveMemoryTarget(store, target);
+    if (!resolved) return { info: `no memory found: ${target}` };
+    try {
+      const ok = store.delete(resolved.scope, resolved.name);
+      return {
+        info: ok
+          ? `▸ forgot ${resolved.scope}/${resolved.name}. Next /new or launch won't see it.`
+          : `could not forget ${resolved.scope}/${resolved.name} (already gone?)`,
+      };
+    } catch (err) {
+      return { info: `forget failed: ${(err as Error).message}` };
+    }
+  }
+
+  if (sub === "clear") {
+    const rawScope = (args[1] ?? "").toLowerCase();
+    if (rawScope !== "global" && rawScope !== "project") {
+      return { info: "usage: /memory clear <global|project> confirm" };
+    }
+    if ((args[2] ?? "").toLowerCase() !== "confirm") {
+      return {
+        info: `about to delete every memory in scope=${rawScope}. Re-run with the word 'confirm' to proceed: /memory clear ${rawScope} confirm`,
+      };
+    }
+    const scope = rawScope as MemoryScope;
+    const entries = store.list().filter((e) => e.scope === scope);
+    let deleted = 0;
+    for (const e of entries) {
+      try {
+        if (store.delete(scope, e.name)) deleted++;
+      } catch {
+        /* skip */
+      }
+    }
+    return { info: `▸ cleared scope=${scope} — deleted ${deleted} memory file(s).` };
+  }
+
+  // Bare `/memory` — show REASONIX.md + both MEMORY.md blocks.
+  const parts: string[] = [];
+  const projMem = readProjectMemory(ctx.memoryRoot);
+  if (projMem) {
+    const hdr = projMem.truncated
+      ? `▸ ${PROJECT_MEMORY_FILE}: ${projMem.path} (${projMem.originalChars.toLocaleString()} chars, truncated)`
+      : `▸ ${PROJECT_MEMORY_FILE}: ${projMem.path} (${projMem.originalChars.toLocaleString()} chars)`;
+    parts.push(hdr, "", projMem.content);
+  }
+  const globalIdx = store.loadIndex("global");
+  if (globalIdx) {
+    parts.push(
+      "",
+      `▸ global memory (${globalIdx.originalChars.toLocaleString()} chars${globalIdx.truncated ? ", truncated" : ""})`,
+      "",
+      globalIdx.content,
+    );
+  }
+  const projectIdx = store.loadIndex("project");
+  if (projectIdx) {
+    parts.push(
+      "",
+      `▸ project memory (${projectIdx.originalChars.toLocaleString()} chars${projectIdx.truncated ? ", truncated" : ""})`,
+      "",
+      projectIdx.content,
+    );
+  }
+  if (parts.length === 0) {
+    return {
+      info: [
+        `no memory pinned in ${ctx.memoryRoot}.`,
+        "",
+        "Three layers are available:",
+        `  1. ${PROJECT_MEMORY_FILE} — committable team memory (in the repo).`,
+        "  2. ~/.reasonix/memory/global/ — your cross-project private memory.",
+        `  3. ~/.reasonix/memory/<project-hash>/ — this project's private memory.`,
+        "",
+        "Ask the model to `remember` something, or hand-edit files directly.",
+        "Changes take effect on next /new or launch — the system prompt is hashed once per session to keep the prefix cache warm.",
+        "",
+        "Subcommands: /memory list | /memory show <name> | /memory forget <name> | /memory clear <scope> confirm",
+      ].join("\n"),
+    };
+  }
+  parts.push(
+    "",
+    "Changes take effect on next /new or launch. Subcommands: /memory list | show | forget | clear",
+  );
+  return { info: parts.join("\n") };
+}
+
+/**
+ * Parse a `/memory show|forget` argument. Accepts bare `<name>` or
+ * `<scope>/<name>`. For bare names, tries project scope first (more
+ * specific, usually what the user means) then falls back to global.
+ */
+function resolveMemoryTarget(
+  store: MemoryStore,
+  raw: string,
+): { scope: MemoryScope; name: string } | null {
+  const slash = raw.indexOf("/");
+  if (slash > 0) {
+    const scopeRaw = raw.slice(0, slash).toLowerCase();
+    const name = raw.slice(slash + 1);
+    if (scopeRaw !== "global" && scopeRaw !== "project") return null;
+    const scope = scopeRaw as MemoryScope;
+    if (scope === "project" && !store.hasProjectScope()) return null;
+    return { scope, name };
+  }
+  for (const scope of ["project", "global"] as MemoryScope[]) {
+    if (scope === "project" && !store.hasProjectScope()) continue;
+    try {
+      store.read(scope, raw);
+      return { scope, name: raw };
+    } catch {
+      /* next scope */
+    }
+  }
+  return null;
+}
+
+/**
+ * Render a section (resources / prompts) of an MCP inspection into a
+ * compact "name  count  items" form, collapsing when unsupported.
+ * Names-only — descriptions and full metadata live in
+ * `reasonix mcp inspect`, which is purpose-built for the deep view.
+ */
+function appendSection(
+  lines: string[],
+  label: string,
+  section:
+    | { supported: true; items: Array<{ name: string }> }
+    | { supported: false; reason: string }
+    | undefined,
+): void {
+  if (!section || !section.supported) {
+    lines.push(
+      `  ${label.trim()}    ${section?.supported === false ? "(not supported)" : "(none)"}`,
+    );
+    return;
+  }
+  const names = section.items.map((i) => i.name);
+  if (names.length === 0) {
+    lines.push(`  ${label.trim()}    (none)`);
+    return;
+  }
+  const head = names.slice(0, 5).join(", ");
+  const more = names.length > 5 ? ` +${names.length - 5} more` : "";
+  lines.push(`  ${label.trim()}    ${names.length}  [${head}${more}]`);
+}
+
+function formatToolList(history: Array<{ toolName: string; text: string }>): string {
+  const total = history.length;
+  const header = `Tool calls in this session (${total}, most recent first):`;
+  // Show the 10 most recent. Older ones are rarely what the user
+  // wants — and the help footer tells them how to reach any entry
+  // by index if they do.
+  const shown = Math.min(total, 10);
+  const lines: string[] = [header];
+  for (let i = 0; i < shown; i++) {
+    const entry = history[total - 1 - i];
+    if (!entry) continue;
+    const idx = i + 1; // 1-based from most recent
+    const flat = entry.text.replace(/\s+/g, " ").trim();
+    const preview = flat.length > 80 ? `${flat.slice(0, 80)}…` : flat;
+    const name = entry.toolName.length > 24 ? `${entry.toolName.slice(0, 23)}…` : entry.toolName;
+    lines.push(
+      `  #${String(idx).padStart(2)}  ${name.padEnd(24)}  ${String(entry.text.length).padStart(6)} chars  ${preview}`,
+    );
+  }
+  if (total > shown) {
+    lines.push(`  … (${total - shown} earlier, reach with /tool N)`);
+  }
+  lines.push("");
+  lines.push("View full output: /tool N   (N=1 → most recent)");
+  return lines.join("\n");
+}
+
+function compactNum(n: number): string {
+  if (n < 1000) return String(n);
+  const k = n / 1000;
+  return k >= 100 ? `${Math.round(k)}k` : `${k.toFixed(1)}k`;
+}
+
+function stripOuterQuotes(s: string): string {
+  if (s.length >= 2 && s.startsWith('"') && s.endsWith('"')) {
+    return s.slice(1, -1);
+  }
+  return s;
+}
+
+/**
+ * Run `git add -A` then `git commit -m <message>` in `rootDir`. Returns
+ * a SlashResult with a human-scannable info line. We surface stderr on
+ * failure so the user sees exactly what git complained about (bad
+ * config, pre-commit hook rejection, nothing staged, etc.).
+ */
+function runGitCommit(rootDir: string, message: string): SlashResult {
+  const add = spawnSync("git", ["add", "-A"], { cwd: rootDir, encoding: "utf8" });
+  if (add.error || add.status !== 0) {
+    return { info: `git add failed (${add.status ?? "?"}):\n${gitTail(add)}` };
+  }
+  const commit = spawnSync("git", ["commit", "-m", message], {
+    cwd: rootDir,
+    encoding: "utf8",
+  });
+  if (commit.error || commit.status !== 0) {
+    return { info: `git commit failed (${commit.status ?? "?"}):\n${gitTail(commit)}` };
+  }
+  const firstLine = (commit.stdout || "").split(/\r?\n/)[0] ?? "";
+  return { info: `▸ committed: ${message}${firstLine ? `\n  ${firstLine}` : ""}` };
+}
+
+/**
+ * Safely extract whatever diagnostic text is available from a spawnSync
+ * result — on Windows or when cwd doesn't exist, `stderr`/`stdout` can
+ * be `undefined` and the caller has only `error.message` to go on.
+ */
+function gitTail(res: ReturnType<typeof spawnSync>): string {
+  const stderr = (res.stderr as string | undefined) ?? "";
+  const stdout = (res.stdout as string | undefined) ?? "";
+  const body = stderr.trim() || stdout.trim();
+  if (body) return body;
+  if (res.error) return (res.error as Error).message;
+  return "(no output from git)";
+}

src/cli/ui/ticker.tsx

@@ -0,0 +1,55 @@
+import React, { type ReactNode, createContext, useContext, useEffect, useState } from "react";
+
+/**
+ * Global heartbeat for every animated component (braille spinners,
+ * elapsed-seconds counters, cursor blink). A single setInterval feeds
+ * all of them instead of each component owning one. Consolidating the
+ * 5-6 independent timers that used to exist in App.tsx + EventLog.tsx +
+ * PromptInput.tsx into one source dramatically cuts the number of
+ * React re-renders per second on heavy turns and stops Ink from
+ * patching the terminal 30+ times/sec — the main amplifier of redraw
+ * artifacts on winpty/MINTTY-class Windows terminals.
+ *
+ * Resolution: `TICK_MS` (default 120). Components that want 500ms or
+ * 1s cadence just modulo the tick counter.
+ */
+export const TICK_MS = 120;
+
+const TickContext = createContext(0);
+
+export interface TickerProviderProps {
+  children: ReactNode;
+  /**
+   * When true, the provider skips the setInterval entirely — tick stays at
+   * 0, all consumers render once and never re-render from the timer. Used
+   * by PLAIN_UI mode so the cursor and any surviving spinners don't drive
+   * repaints on fragile Windows terminals.
+   */
+  disabled?: boolean;
+}
+
+export function TickerProvider({ children, disabled }: TickerProviderProps) {
+  const [tick, setTick] = useState(0);
+  useEffect(() => {
+    if (disabled) return;
+    const id = setInterval(() => setTick((t) => t + 1), TICK_MS);
+    return () => clearInterval(id);
+  }, [disabled]);
+  return <TickContext.Provider value={tick}>{children}</TickContext.Provider>;
+}
+
+/** Current global tick. Re-renders the calling component every `TICK_MS`. */
+export function useTick(): number {
+  return useContext(TickContext);
+}
+
+/**
+ * Seconds elapsed since the calling component mounted. Derived from
+ * the shared tick + a fresh Date.now() read, so no dedicated timer
+ * is needed.
+ */
+export function useElapsedSeconds(): number {
+  const [start] = useState(() => Date.now());
+  useTick(); // subscribe to the tick so we re-render
+  return Math.floor((Date.now() - start) / 1000);
+}

src/client.ts

@@ -45,6 +45,25 @@ export interface StreamChunk {
   raw: any;
 }
 
+/**
+ * Response shape for DeepSeek's `/user/balance` endpoint. One entry
+ * per currency the account is funded in (typically CNY, sometimes
+ * USD). `total_balance` is the spendable figure; `granted_balance`
+ * counts promotional credits that expire, `topped_up_balance` is
+ * what the user paid for and keeps.
+ */
+export interface BalanceInfo {
+  currency: string;
+  total_balance: string;
+  granted_balance?: string;
+  topped_up_balance?: string;
+}
+
+export interface UserBalance {
+  is_available: boolean;
+  balance_infos: BalanceInfo[];
+}
+
 export interface DeepSeekClientOptions {
   apiKey?: string;
   baseUrl?: string;
@@ -92,6 +111,28 @@ export class DeepSeekClient {
     return payload;
   }
 
+  /**
+   * Fetch the current DeepSeek account balance. Separate endpoint
+   * from chat completions, no billing impact. Returns null on any
+   * network/auth failure so callers can gate the balance display
+   * without a hard error — the rest of the session works regardless.
+   */
+  async getBalance(opts: { signal?: AbortSignal } = {}): Promise<UserBalance | null> {
+    try {
+      const resp = await this._fetch(`${this.baseUrl}/user/balance`, {
+        method: "GET",
+        headers: { Authorization: `Bearer ${this.apiKey}` },
+        signal: opts.signal,
+      });
+      if (!resp.ok) return null;
+      const data = (await resp.json()) as UserBalance;
+      if (!data || !Array.isArray(data.balance_infos)) return null;
+      return data;
+    } catch {
+      return null;
+    }
+  }
+
   async chat(opts: ChatRequestOptions): Promise<ChatResponse> {
     const ctrl = new AbortController();
     const timer = setTimeout(() => ctrl.abort(), this.timeoutMs);

src/code/edit-blocks.ts

@@ -0,0 +1,241 @@
+/**
+ * Aider-style SEARCH/REPLACE edit blocks.
+ *
+ * The model emits blocks in this exact shape, one or more per response:
+ *
+ *   path/to/file.ts
+ *   <<<<<<< SEARCH
+ *   exact existing lines (whitespace-sensitive)
+ *   =======
+ *   replacement lines
+ *   >>>>>>> REPLACE
+ *
+ * We chose this over unified diffs because:
+ *   - Models produce it reliably — no line-number drift.
+ *   - It tolerates multi-edit responses without ambiguity over which
+ *     hunk belongs to which file.
+ *   - Aider has years of evidence that this format works even against
+ *     weaker models than DeepSeek R1, so it's a conservative pick.
+ *
+ * The SEARCH text must match the file byte-for-byte. Empty SEARCH is a
+ * sentinel for "create new file" — the REPLACE becomes the whole file.
+ * If SEARCH doesn't match we refuse the edit and surface the failure;
+ * we do NOT guess or fuzzy-match. A wrong silent edit is worse than a
+ * missing one — the user can re-ask with the exact current content.
+ */
+
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+
+export interface EditBlock {
+  /** Path as written by the model — relative to rootDir, or absolute. */
+  path: string;
+  /** Literal text to match in the target file. Empty → create new file. */
+  search: string;
+  /** Replacement text to write in place of `search`. */
+  replace: string;
+  /** Char offset in the source message where this block started. */
+  offset: number;
+}
+
+export type ApplyStatus =
+  /** Edit landed on disk. */
+  | "applied"
+  /** New file created (SEARCH was empty and file didn't exist). */
+  | "created"
+  /** File exists but SEARCH block wasn't found in its content. */
+  | "not-found"
+  /** File doesn't exist and SEARCH was non-empty (can't create without content). */
+  | "file-missing"
+  /** Path escapes rootDir — refused on safety grounds. */
+  | "path-escape"
+  /** fs write / read threw. */
+  | "error";
+
+export interface ApplyResult {
+  path: string;
+  status: ApplyStatus;
+  /** Extra detail (e.g. error message) for logs. */
+  message?: string;
+}
+
+/**
+ * One edit block per match. The regex is anchored to the 7-char marker
+ * lines because those are visually distinct and unlikely to appear in
+ * normal code.
+ *
+ * Anchored with `^` + `m` flag so the filename has to live on its own
+ * line. Keeps us from matching e.g. a JS-import string that happens to
+ * contain `<<<<<<< SEARCH` in inner text.
+ */
+// `\n?` before the =======/REPLACE separators makes the body optional:
+// empty SEARCH (new-file sentinel) works without requiring a gratuitous
+// empty line, and the same holds for empty REPLACE (file-deletion
+// semantics, not yet supported but cheaply representable).
+const BLOCK_RE = /^(\S[^\n]*)\n<{7} SEARCH\n([\s\S]*?)\n?={7}\n([\s\S]*?)\n?>{7} REPLACE/gm;
+
+export function parseEditBlocks(text: string): EditBlock[] {
+  const out: EditBlock[] = [];
+  BLOCK_RE.lastIndex = 0;
+  let m: RegExpExecArray | null = BLOCK_RE.exec(text);
+  while (m !== null) {
+    out.push({
+      path: m[1]!.trim(),
+      search: m[2]!,
+      replace: m[3]!,
+      offset: m.index,
+    });
+    m = BLOCK_RE.exec(text);
+  }
+  return out;
+}
+
+export function applyEditBlock(block: EditBlock, rootDir: string): ApplyResult {
+  const absRoot = resolve(rootDir);
+  const absTarget = resolve(absRoot, block.path);
+  // Refuse paths that escape rootDir. `resolve` normalizes `..`, so
+  // startsWith on the normalized pair is enough.
+  if (absTarget !== absRoot && !absTarget.startsWith(`${absRoot}${sep()}`)) {
+    return {
+      path: block.path,
+      status: "path-escape",
+      message: `resolved path ${absTarget} is outside rootDir ${absRoot}`,
+    };
+  }
+
+  const searchEmpty = block.search.length === 0;
+  const exists = existsSync(absTarget);
+
+  try {
+    if (!exists) {
+      if (!searchEmpty) {
+        return {
+          path: block.path,
+          status: "file-missing",
+          message: "file does not exist; to create it, use an empty SEARCH block",
+        };
+      }
+      mkdirSync(dirname(absTarget), { recursive: true });
+      writeFileSync(absTarget, block.replace, "utf8");
+      return { path: block.path, status: "created" };
+    }
+
+    const content = readFileSync(absTarget, "utf8");
+    if (searchEmpty) {
+      return {
+        path: block.path,
+        status: "not-found",
+        message: "empty SEARCH only creates new files — this file already exists",
+      };
+    }
+    const idx = content.indexOf(block.search);
+    if (idx === -1) {
+      return {
+        path: block.path,
+        status: "not-found",
+        message: "SEARCH text does not match the current file content exactly",
+      };
+    }
+    // Replace only the first occurrence — if the model needs multiple
+    // identical edits it should emit multiple blocks (each anchored by
+    // more surrounding context). Auto-expanding to replace-all is a
+    // footgun when the same string legitimately appears in several
+    // unrelated places.
+    const replaced = `${content.slice(0, idx)}${block.replace}${content.slice(idx + block.search.length)}`;
+    writeFileSync(absTarget, replaced, "utf8");
+    return { path: block.path, status: "applied" };
+  } catch (err) {
+    return { path: block.path, status: "error", message: (err as Error).message };
+  }
+}
+
+export function applyEditBlocks(blocks: EditBlock[], rootDir: string): ApplyResult[] {
+  return blocks.map((b) => applyEditBlock(b, rootDir));
+}
+
+// ---------- snapshot / restore (for /undo) ----------
+
+export interface EditSnapshot {
+  /** Path relative to rootDir, as the block named it. */
+  path: string;
+  /**
+   * File content before the edit batch was applied. `null` means the
+   * file didn't exist yet — restoring that means deleting whatever the
+   * edit created.
+   */
+  prevContent: string | null;
+}
+
+/**
+ * Capture the current state of every file an edit batch is about to
+ * touch, so `/undo` can roll back if the user doesn't like the result.
+ * De-duplicates by path because one batch can contain multiple blocks
+ * for the same file, and we only want one "before" snapshot per file.
+ */
+export function snapshotBeforeEdits(blocks: EditBlock[], rootDir: string): EditSnapshot[] {
+  const absRoot = resolve(rootDir);
+  const seen = new Set<string>();
+  const snapshots: EditSnapshot[] = [];
+  for (const b of blocks) {
+    if (seen.has(b.path)) continue;
+    seen.add(b.path);
+    const abs = resolve(absRoot, b.path);
+    if (!existsSync(abs)) {
+      snapshots.push({ path: b.path, prevContent: null });
+      continue;
+    }
+    try {
+      snapshots.push({ path: b.path, prevContent: readFileSync(abs, "utf8") });
+    } catch {
+      // Unreadable (permission / binary) — record null so we at least
+      // don't pretend the snapshot is authoritative. The restore path
+      // will treat null as "delete on undo", which is wrong in that
+      // case but the file wasn't ours to begin with.
+      snapshots.push({ path: b.path, prevContent: null });
+    }
+  }
+  return snapshots;
+}
+
+/**
+ * Restore files to their snapshotted state. Snapshots with
+ * `prevContent === null` were created by the edit, so undo = delete.
+ * Otherwise the prior content is written back, replacing whatever the
+ * edit left behind.
+ */
+export function restoreSnapshots(snapshots: EditSnapshot[], rootDir: string): ApplyResult[] {
+  const absRoot = resolve(rootDir);
+  return snapshots.map((snap) => {
+    const abs = resolve(absRoot, snap.path);
+    if (abs !== absRoot && !abs.startsWith(`${absRoot}${sep()}`)) {
+      return {
+        path: snap.path,
+        status: "path-escape",
+        message: "snapshot path escapes rootDir — refusing to restore",
+      };
+    }
+    try {
+      if (snap.prevContent === null) {
+        if (existsSync(abs)) unlinkSync(abs);
+        return {
+          path: snap.path,
+          status: "applied",
+          message: "removed (the edit had created it)",
+        };
+      }
+      writeFileSync(abs, snap.prevContent, "utf8");
+      return {
+        path: snap.path,
+        status: "applied",
+        message: "restored to pre-edit content",
+      };
+    } catch (err) {
+      return { path: snap.path, status: "error", message: (err as Error).message };
+    }
+  });
+}
+
+/** Platform separator — `\` on Windows, `/` elsewhere. */
+function sep(): string {
+  return process.platform === "win32" ? "\\" : "/";
+}

src/code/prompt.ts

@@ -0,0 +1,127 @@
+/**
+ * System prompt used by `reasonix code`. Teaches the model:
+ *
+ *   1. It has a filesystem MCP bridge rooted at the user's CWD.
+ *   2. To modify files it emits SEARCH/REPLACE blocks (not
+ *      `write_file` — that would whole-file rewrite and kill diff
+ *      reviewability).
+ *   3. Read first, edit second — SEARCH must match byte-for-byte.
+ *   4. Be concise. The user can read a diff faster than prose.
+ *
+ * Kept short on purpose. Long system prompts eat context budget that
+ * the Cache-First Loop is trying to conserve. The SEARCH/REPLACE spec
+ * is the one unavoidable bloat; we trim everything else.
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { applyMemoryStack } from "../user-memory.js";
+
+export const CODE_SYSTEM_PROMPT = `You are Reasonix Code, a coding assistant. You have filesystem tools (read_file, write_file, list_directory, search_files, etc.) rooted at the user's working directory.
+
+# When to propose a plan (submit_plan)
+
+You have a \`submit_plan\` tool that shows the user a markdown plan and lets them Approve / Refine / Cancel before you execute. Use it proactively when the task is large enough to deserve a review gate:
+
+- Multi-file refactors or renames.
+- Architecture changes (moving modules, splitting / merging files, new abstractions).
+- Anything where "undo" after the fact would be expensive — migrations, destructive cleanups, API shape changes.
+- When the user's request is ambiguous and multiple reasonable interpretations exist — propose your reading as a plan and let them confirm.
+
+Skip submit_plan for small, obvious changes: one-line typo, clear bug with a clear fix, adding a missing import, renaming a local variable. Just do those.
+
+Plan body: one-sentence summary, then a file-by-file breakdown of what you'll change and why, and any risks or open questions. If some decisions are genuinely up to the user (naming, tradeoffs, out-of-scope possibilities), list them in an "Open questions" section — the user sees the plan in a picker and has a text input to answer your questions before approving. Don't pretend certainty you don't have; flagged questions are how the user tells you what they care about. After calling submit_plan, STOP — don't call any more tools, wait for the user's verdict.
+
+# Plan mode (/plan)
+
+The user can ALSO enter "plan mode" via /plan, which is a stronger, explicit constraint:
+- Write tools (edit_file, write_file, create_directory, move_file) and non-allowlisted run_command calls are BOUNCED at dispatch — you'll get a tool result like "unavailable in plan mode". Don't retry them.
+- Read tools (read_file, list_directory, search_files, directory_tree, get_file_info) and allowlisted read-only / test shell commands still work — use them to investigate.
+- You MUST call submit_plan before anything will execute. Approve exits plan mode; Refine stays in; Cancel exits without implementing.
+
+
+# When to edit vs. when to explore
+
+Only propose edits when the user explicitly asks you to change, fix, add, remove, refactor, or write something. Do NOT propose edits when the user asks you to:
+- analyze, read, explore, describe, or summarize a project
+- explain how something works
+- answer a question about the code
+
+In those cases, use tools to gather what you need, then reply in prose. No SEARCH/REPLACE blocks, no file changes. If you're unsure what the user wants, ask.
+
+When you do propose edits, the user will review them and decide whether to \`/apply\` or \`/discard\`. Don't assume they'll accept — write as if each edit will be audited, because it will.
+
+# Editing files
+
+When you've been asked to change a file, output one or more SEARCH/REPLACE blocks in this exact format:
+
+path/to/file.ext
+<<<<<<< SEARCH
+exact existing lines from the file, including whitespace
+=======
+the new lines
+>>>>>>> REPLACE
+
+Rules:
+- Always read_file first so your SEARCH matches byte-for-byte. If it doesn't match, the edit is rejected and you'll have to retry with the exact current content.
+- One edit per block. Multiple blocks in one response are fine.
+- To create a new file, leave SEARCH empty:
+    path/to/new.ts
+    <<<<<<< SEARCH
+    =======
+    (whole file content here)
+    >>>>>>> REPLACE
+- Do NOT use write_file to change existing files — the user reviews your edits as SEARCH/REPLACE. write_file is only for files you explicitly want to overwrite wholesale (rare).
+- Paths are relative to the working directory. Don't use absolute paths.
+
+# Trust what you already know
+
+Before exploring the filesystem to answer a factual question, check whether the answer is already in context: the user's current message, earlier turns in this conversation (including prior tool results from \`remember\`), and the pinned memory blocks at the top of this prompt. When the user has stated a fact or you have remembered one, it outranks what the files say — don't re-derive from code what the user already told you. Explore when you genuinely don't know.
+
+# Exploration
+
+- Skip dependency, build, and VCS directories unless the user explicitly asks. The pinned .gitignore block (if any, below) is your authoritative denylist.
+- Prefer search_files / grep over list_directory when you know roughly what you're looking for — it saves context and avoids enumerating huge trees.
+
+# Style
+
+- Show edits; don't narrate them in prose. "Here's the fix:" is enough.
+- One short paragraph explaining *why*, then the blocks.
+- If you need to explore first (list / grep / read), do it with tool calls before writing any prose — silence while exploring is fine.
+`;
+
+/**
+ * Inject the project's `.gitignore` content into the system prompt as a
+ * "respect this on top of the built-in denylist" hint. We don't parse
+ * the file — we hand it to the model as-is. Truncate long ones so we
+ * don't eat context budget on huge generated ignore lists.
+ *
+ * Stacking order (stable for cache prefix):
+ *   base prompt → REASONIX.md → global MEMORY.md → project MEMORY.md → .gitignore
+ */
+export function codeSystemPrompt(rootDir: string): string {
+  const withMemory = applyMemoryStack(CODE_SYSTEM_PROMPT, rootDir);
+  const gitignorePath = join(rootDir, ".gitignore");
+  if (!existsSync(gitignorePath)) return withMemory;
+  let content: string;
+  try {
+    content = readFileSync(gitignorePath, "utf8");
+  } catch {
+    return withMemory;
+  }
+  const MAX = 2000;
+  const truncated =
+    content.length > MAX
+      ? `${content.slice(0, MAX)}\n… (truncated ${content.length - MAX} chars)`
+      : content;
+  return `${withMemory}
+
+# Project .gitignore
+
+The user's repo ships this .gitignore — treat every pattern as "don't traverse or edit inside these paths unless explicitly asked":
+
+\`\`\`
+${truncated}
+\`\`\`
+`;
+}

src/config.ts

@@ -8,15 +8,59 @@
  * The library itself never touches the config file — it only reads
  * `DEEPSEEK_API_KEY` from the environment. The CLI is responsible for
  * pulling from the config file and exposing it via env var to the loop.
+ *
+ * Beyond the API key, the config also remembers the user's *defaults*
+ * from `reasonix setup`: preset, MCP servers, session. This is what
+ * makes `reasonix chat` with no flags "just work" after first-run.
  */
 
 import { chmodSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 
+/** One of the preset bundles (model + harvest + branch combo). */
+export type PresetName = "fast" | "smart" | "max";
+
 export interface ReasonixConfig {
   apiKey?: string;
   baseUrl?: string;
+  /**
+   * Default preset for `reasonix chat` / `reasonix run` when no flags override.
+   * Maps to model + harvest + branch combos (see presets.ts). Missing → "fast".
+   */
+  preset?: PresetName;
+  /**
+   * Default MCP server specs to bridge on every `reasonix chat`, in the
+   * same `"name=cmd args..."` format that `--mcp` takes. Stored as strings
+   * so `reasonix setup` stays symmetrical with the flag — one parser, one
+   * format in the config file, grep-friendly.
+   */
+  mcp?: string[];
+  /**
+   * Default session name (null/missing → "default", which is what the
+   * CLI has been doing anyway). `reasonix setup` lets users pick a name
+   * or opt into ephemeral.
+   */
+  session?: string | null;
+  /** Marks that `reasonix setup` has completed at least once. */
+  setupCompleted?: boolean;
+  /**
+   * Whether `web_search` + `web_fetch` tools are registered. Default:
+   * enabled (no key required — backed by DuckDuckGo's public HTML
+   * endpoint). Set to `false` to keep the session offline.
+   */
+  search?: boolean;
+  /**
+   * Per-project state keyed by absolute directory path. Written by the
+   * "always allow" choice on a shell confirmation prompt; merged into
+   * `registerShellTools({ extraAllowed })` when `reasonix code` runs
+   * against that directory again.
+   */
+  projects?: {
+    [absoluteRootDir: string]: {
+      shellAllowed?: string[];
+    };
+  };
 }
 
 export function defaultConfigPath(): string {
@@ -51,12 +95,57 @@ export function loadApiKey(path: string = defaultConfigPath()): string | undefin
   return readConfig(path).apiKey;
 }
 
+/**
+ * Resolve whether web-search tools should be registered. Default: on.
+ * Env `REASONIX_SEARCH=off` or config `search: false` turns it off.
+ * Any other value falls through to enabled.
+ */
+export function searchEnabled(path: string = defaultConfigPath()): boolean {
+  const env = process.env.REASONIX_SEARCH;
+  if (env === "off" || env === "false" || env === "0") return false;
+  const cfg = readConfig(path).search;
+  if (cfg === false) return false;
+  return true;
+}
+
 export function saveApiKey(key: string, path: string = defaultConfigPath()): void {
   const cfg = readConfig(path);
   cfg.apiKey = key.trim();
   writeConfig(cfg, path);
 }
 
+/**
+ * Read the persisted "always allow" shell-command prefixes for a
+ * given project root. Returns an empty array when nothing's stored.
+ */
+export function loadProjectShellAllowed(
+  rootDir: string,
+  path: string = defaultConfigPath(),
+): string[] {
+  const cfg = readConfig(path);
+  return cfg.projects?.[rootDir]?.shellAllowed ?? [];
+}
+
+/**
+ * Append a prefix to the project's shell-allowed list, dedup and
+ * persist. No-op if the prefix is empty/whitespace or already stored.
+ */
+export function addProjectShellAllowed(
+  rootDir: string,
+  prefix: string,
+  path: string = defaultConfigPath(),
+): void {
+  const trimmed = prefix.trim();
+  if (!trimmed) return;
+  const cfg = readConfig(path);
+  if (!cfg.projects) cfg.projects = {};
+  if (!cfg.projects[rootDir]) cfg.projects[rootDir] = {};
+  const existing = cfg.projects[rootDir].shellAllowed ?? [];
+  if (existing.includes(trimmed)) return;
+  cfg.projects[rootDir].shellAllowed = [...existing, trimmed];
+  writeConfig(cfg, path);
+}
+
 export function isPlausibleKey(key: string): boolean {
   const trimmed = key.trim();
   return /^sk-[A-Za-z0-9_-]{16,}$/.test(trimmed);

src/diff.ts

@@ -271,6 +271,43 @@ export function renderSummaryTable(report: DiffReport, _opts: RenderOptions = {}
     ),
   );
   lines.push(statRow("prefix hashes", a.stats.prefixHashes.length, b.stats.prefixHashes.length));
+  // Harvest signal row — only surface when at least one side carries plan
+  // state. Keeps no-harvest diffs visually identical to pre-v0.3 output.
+  if (a.stats.harvestedTurns > 0 || b.stats.harvestedTurns > 0) {
+    lines.push(
+      row(
+        [
+          "harvest turns",
+          `${a.stats.harvestedTurns}`,
+          `${b.stats.harvestedTurns}`,
+          signed(b.stats.harvestedTurns - a.stats.harvestedTurns),
+        ],
+        [20, 14, 14, 14],
+      ),
+    );
+    lines.push(
+      row(
+        [
+          "  subgoals",
+          `${a.stats.totalSubgoals}`,
+          `${b.stats.totalSubgoals}`,
+          signed(b.stats.totalSubgoals - a.stats.totalSubgoals),
+        ],
+        [20, 14, 14, 14],
+      ),
+    );
+    lines.push(
+      row(
+        [
+          "  uncertainties",
+          `${a.stats.totalUncertainties}`,
+          `${b.stats.totalUncertainties}`,
+          signed(b.stats.totalUncertainties - a.stats.totalUncertainties),
+        ],
+        [20, 14, 14, 14],
+      ),
+    );
+  }
   lines.push("");
 
   // Prefix stability story — the headline finding when comparing bench modes.
@@ -348,6 +385,17 @@ export function renderMarkdown(report: DiffReport): string {
   out.push(
     `| prefix hashes | ${a.stats.prefixHashes.length} | ${b.stats.prefixHashes.length} | — |`,
   );
+  if (a.stats.harvestedTurns > 0 || b.stats.harvestedTurns > 0) {
+    out.push(
+      `| harvest turns | ${a.stats.harvestedTurns} | ${b.stats.harvestedTurns} | ${signed(b.stats.harvestedTurns - a.stats.harvestedTurns)} |`,
+    );
+    out.push(
+      `| harvest subgoals | ${a.stats.totalSubgoals} | ${b.stats.totalSubgoals} | ${signed(b.stats.totalSubgoals - a.stats.totalSubgoals)} |`,
+    );
+    out.push(
+      `| harvest uncertainties | ${a.stats.totalUncertainties} | ${b.stats.totalUncertainties} | ${signed(b.stats.totalUncertainties - a.stats.totalUncertainties)} |`,
+    );
+  }
   out.push("");
 
   out.push("## Turn-by-turn");

src/harvest.ts

@@ -68,8 +68,12 @@ export async function harvest(
   reasoningContent: string | null | undefined,
   client?: DeepSeekClient,
   options: HarvestOptions = {},
+  signal?: AbortSignal,
 ): Promise<TypedPlanState> {
   if (!client || !reasoningContent) return emptyPlanState();
+  // Fast-path the already-aborted case so we don't burn a network
+  // round-trip for a result the caller no longer wants.
+  if (signal?.aborted) return emptyPlanState();
   const minLen = options.minReasoningLen ?? 40;
   const trimmed = reasoningContent.trim();
   if (trimmed.length < minLen) return emptyPlanState();
@@ -92,6 +96,7 @@ export async function harvest(
       responseFormat: { type: "json_object" },
       temperature: 0,
       maxTokens: 600,
+      signal,
     });
     return parsePlanState(resp.content, maxItems, maxItemLen);
   } catch {

src/index.ts

@@ -3,7 +3,12 @@
 export { DeepSeekClient, Usage } from "./client.js";
 export type { ChatResponse, StreamChunk, DeepSeekClientOptions } from "./client.js";
 
-export { CacheFirstLoop } from "./loop.js";
+export {
+  CacheFirstLoop,
+  formatLoopError,
+  healLoadedMessages,
+  stripHallucinatedToolMarkup,
+} from "./loop.js";
 export type {
   CacheFirstLoopOptions,
   LoopEvent,
@@ -24,10 +29,76 @@ export type {
 export { ImmutablePrefix, AppendOnlyLog, VolatileScratch } from "./memory.js";
 export type { ImmutablePrefixOptions } from "./memory.js";
 
-export { ToolRegistry } from "./tools.js";
-export type { ToolDefinition } from "./tools.js";
+export {
+  PROJECT_MEMORY_FILE,
+  PROJECT_MEMORY_MAX_CHARS,
+  applyProjectMemory,
+  memoryEnabled,
+  readProjectMemory,
+} from "./project-memory.js";
+export type { ProjectMemory } from "./project-memory.js";
 
-export { SessionStats, costUsd, claudeEquivalentCost } from "./telemetry.js";
+export {
+  MEMORY_INDEX_FILE,
+  MEMORY_INDEX_MAX_CHARS,
+  MemoryStore,
+  USER_MEMORY_DIR,
+  applyMemoryStack,
+  applyUserMemory,
+  projectHash,
+  sanitizeMemoryName,
+} from "./user-memory.js";
+export type {
+  MemoryEntry,
+  MemoryScope,
+  MemoryStoreOptions,
+  MemoryType,
+  WriteInput as MemoryWriteInput,
+} from "./user-memory.js";
+
+export { ToolRegistry } from "./tools.js";
+export type { ToolDefinition, ToolCallContext } from "./tools.js";
+export { registerFilesystemTools } from "./tools/filesystem.js";
+export type { FilesystemToolsOptions } from "./tools/filesystem.js";
+export { registerMemoryTools } from "./tools/memory.js";
+export type { MemoryToolsOptions } from "./tools/memory.js";
+export { PlanProposedError, registerPlanTool } from "./tools/plan.js";
+export type { PlanToolOptions } from "./tools/plan.js";
+export {
+  NeedsConfirmationError,
+  formatCommandResult,
+  isAllowed,
+  prepareSpawn,
+  quoteForCmdExe,
+  registerShellTools,
+  resolveExecutable,
+  runCommand,
+  tokenizeCommand,
+} from "./tools/shell.js";
+export type { RunCommandResult, ShellToolsOptions } from "./tools/shell.js";
+export {
+  formatSearchResults,
+  htmlToText,
+  parseMojeekResults,
+  registerWebTools,
+  webFetch,
+  webSearch,
+} from "./tools/web.js";
+export type {
+  PageContent,
+  SearchResult,
+  WebFetchOptions,
+  WebSearchOptions,
+  WebToolsOptions,
+} from "./tools/web.js";
+
+export {
+  SessionStats,
+  costUsd,
+  inputCostUsd,
+  outputCostUsd,
+  claudeEquivalentCost,
+} from "./telemetry.js";
 export type { TurnStats, SessionSummary } from "./telemetry.js";
 
 export {
@@ -85,6 +156,71 @@ export {
 } from "./diff.js";
 export type { DiffReport, DiffSide, TurnPair, RenderOptions as DiffRenderOptions } from "./diff.js";
 
+// ---------- MCP (v0.3 foundation) ----------
+export { McpClient } from "./mcp/client.js";
+export type { McpClientOptions } from "./mcp/client.js";
+export { StdioTransport } from "./mcp/stdio.js";
+export type { McpTransport, StdioTransportOptions } from "./mcp/stdio.js";
+export { SseTransport } from "./mcp/sse.js";
+export type { SseTransportOptions } from "./mcp/sse.js";
+export {
+  DEFAULT_MAX_RESULT_CHARS,
+  bridgeMcpTools,
+  flattenMcpResult,
+  truncateForModel,
+} from "./mcp/registry.js";
+export type { BridgeOptions, BridgeResult, FlattenOptions } from "./mcp/registry.js";
+export { parseMcpSpec } from "./mcp/spec.js";
+export type { McpSpec, StdioMcpSpec, SseMcpSpec } from "./mcp/spec.js";
+export { inspectMcpServer } from "./mcp/inspect.js";
+export type { InspectionReport, SectionResult } from "./mcp/inspect.js";
+
+// ---------- code mode (v0.3 — `reasonix code`) ----------
+export {
+  parseEditBlocks,
+  applyEditBlock,
+  applyEditBlocks,
+  snapshotBeforeEdits,
+  restoreSnapshots,
+} from "./code/edit-blocks.js";
+export type {
+  EditBlock,
+  ApplyResult,
+  ApplyStatus,
+  EditSnapshot,
+} from "./code/edit-blocks.js";
+export { CODE_SYSTEM_PROMPT, codeSystemPrompt } from "./code/prompt.js";
+export {
+  MCP_PROTOCOL_VERSION,
+  isJsonRpcError,
+} from "./mcp/types.js";
+export type {
+  McpTool,
+  McpToolSchema,
+  CallToolResult,
+  ListToolsResult,
+  McpContentBlock,
+  InitializeResult,
+  JsonRpcRequest,
+  JsonRpcResponse,
+  JsonRpcMessage,
+  McpResource,
+  McpResourceContents,
+  McpResourceContentsText,
+  McpResourceContentsBlob,
+  ListResourcesResult,
+  ReadResourceResult,
+  McpPrompt,
+  McpPromptArgument,
+  McpPromptMessage,
+  McpPromptResourceBlock,
+  ListPromptsResult,
+  GetPromptResult,
+  McpProgressHandler,
+  McpProgressInfo,
+  ProgressNotificationParams,
+} from "./mcp/types.js";
+
 export { fetchWithRetry } from "./retry.js";
 export type { RetryOptions, RetryInfo } from "./retry.js";
 
@@ -108,4 +244,12 @@ export type {
   JSONSchema,
 } from "./types.js";
 
-export const VERSION = "0.2.2";
+export {
+  LATEST_CACHE_TTL_MS,
+  LATEST_FETCH_TIMEOUT_MS,
+  VERSION,
+  compareVersions,
+  getLatestVersion,
+  isNpxInstall,
+} from "./version.js";
+export type { GetLatestVersionOptions } from "./version.js";

src/loop.ts

@@ -6,19 +6,50 @@ import {
   runBranches,
 } from "./consistency.js";
 import { type HarvestOptions, type TypedPlanState, emptyPlanState, harvest } from "./harvest.js";
+import { DEFAULT_MAX_RESULT_CHARS, truncateForModel } from "./mcp/registry.js";
 import { AppendOnlyLog, type ImmutablePrefix, VolatileScratch } from "./memory.js";
 import { type RepairReport, ToolCallRepair } from "./repair/index.js";
-import { appendSessionMessage, loadSessionMessages } from "./session.js";
-import { SessionStats, type TurnStats } from "./telemetry.js";
+import { appendSessionMessage, loadSessionMessages, rewriteSession } from "./session.js";
+import {
+  DEEPSEEK_CONTEXT_TOKENS,
+  DEFAULT_CONTEXT_TOKENS,
+  SessionStats,
+  type TurnStats,
+} from "./telemetry.js";
 import { ToolRegistry } from "./tools.js";
 import type { ChatMessage, ToolCall } from "./types.js";
 
 export type EventRole =
   | "assistant_delta"
   | "assistant_final"
+  /**
+   * Emitted as `tool_calls[].function.arguments` streams in. A tool
+   * call with a large arguments payload produces no `content` or
+   * `reasoning_content` bytes — this is the only signal the UI has
+   * that the stream is alive during that window.
+   */
+  | "tool_call_delta"
+  /**
+   * Yielded immediately before a tool is dispatched. Lets the TUI put
+   * up a "▸ tool<X> running…" spinner while the tool's Promise is
+   * pending — otherwise the UI looks frozen whenever a tool call
+   * takes more than a few hundred ms (a big `filesystem_edit_file`
+   * is a typical trigger).
+   */
+  | "tool_start"
   | "tool"
   | "done"
   | "error"
+  | "warning"
+  /**
+   * Transient "what's happening right now" indicator. Emitted during
+   * silent phases — between a tool result and the next iteration's
+   * first streaming byte, and right before harvest — so the TUI can
+   * show a spinner with explanatory text instead of looking frozen.
+   * The UI clears it on the next primary event (assistant_delta,
+   * tool_start, tool, assistant_final, error).
+   */
+  | "status"
   | "branch_start"
   | "branch_progress"
   | "branch_done";
@@ -50,12 +81,24 @@ export interface LoopEvent {
    * what it returned. Needed by `reasonix diff` to explain divergences.
    */
   toolArgs?: string;
+  /** Cumulative arguments-string length for `role === "tool_call_delta"`. */
+  toolCallArgsChars?: number;
   stats?: TurnStats;
   planState?: TypedPlanState;
   repair?: RepairReport;
   branch?: BranchSummary;
   branchProgress?: BranchProgress;
   error?: string;
+  /**
+   * True on `assistant_final` events emitted by the no-tools fallback
+   * when the loop hit its budget, was aborted, or tripped the
+   * token-context guard. Consumers that act on assistant text (notably
+   * the code-mode edit applier) MUST treat these as display-only —
+   * the model is "wrapping up," not proposing new work. Applying
+   * SEARCH/REPLACE blocks found in a forced summary caused the
+   * "analysis became edits" bug in v0.4.1 and earlier.
+   */
+  forcedSummary?: boolean;
 }
 
 export interface CacheFirstLoopOptions {
@@ -127,13 +170,30 @@ export class CacheFirstLoop {
 
   private _turn = 0;
   private _streamPreference: boolean;
+  /**
+   * AbortController per active turn. Threaded through the DeepSeek
+   * HTTP calls AND every tool dispatch so Esc actually cancels the
+   * in-flight network/subprocess work — not "we'll get to it after
+   * the current call finishes." Re-created at the start of each
+   * `step()` (the prior turn's signal has already fired).
+   */
+  private _turnAbort: AbortController = new AbortController();
 
   constructor(opts: CacheFirstLoopOptions) {
     this.client = opts.client;
     this.prefix = opts.prefix;
     this.tools = opts.tools ?? new ToolRegistry();
     this.model = opts.model ?? "deepseek-chat";
-    this.maxToolIters = opts.maxToolIters ?? 8;
+    // Iter cap is a safety net, not the primary stop condition. The
+    // primary stop is the token-context guard inside step(): after
+    // every model response we check whether the prompt is already past
+    // 80% of the model's context window, and if so divert to the
+    // forced-summary path. 64 is high enough that exploration almost
+    // never exhausts it before the token guard fires first — which
+    // is the point: let the real constraint (context window) drive
+    // the decision, keep the iter cap as a last-resort backstop for
+    // the case where something spins without growing the prompt.
+    this.maxToolIters = opts.maxToolIters ?? 64;
 
     // Resolve branch config first (since it forces harvest on).
     if (typeof opts.branch === "number") {
@@ -165,16 +225,78 @@ export class CacheFirstLoop {
 
     // Session resume: pre-load prior messages into the log if a session name
     // is provided. New messages appended to the log are also persisted.
+    //
+    // Heal-on-load: if a previous run (or a pre-alpha.6 client) stored a
+    // tool result bigger than the cap, the next API call would blow past
+    // DeepSeek's 131k-token limit *before the user even types anything*.
+    // Truncating here lets the user pick up their session history without
+    // losing the conversational context around the oversized call.
     this.sessionName = opts.session ?? null;
     if (this.sessionName) {
       const prior = loadSessionMessages(this.sessionName);
-      for (const msg of prior) this.log.append(msg);
-      this.resumedMessageCount = prior.length;
+      const { messages, healedCount, healedFrom } = healLoadedMessages(
+        prior,
+        DEFAULT_MAX_RESULT_CHARS,
+      );
+      for (const msg of messages) this.log.append(msg);
+      this.resumedMessageCount = messages.length;
+      if (healedCount > 0) {
+        // Persist the healed log back to disk so the damage doesn't
+        // re-surface on the next session load — otherwise `heal →
+        // append → resume → heal → …` would keep noticing the same
+        // broken tail every restart. Non-fatal on I/O error: the
+        // in-memory log is already healed so this session still works.
+        try {
+          rewriteSession(this.sessionName, messages);
+        } catch {
+          /* disk full / perms — skip, in-memory heal still applies */
+        }
+        process.stderr.write(
+          `▸ session "${this.sessionName}": healed ${healedCount} entr${healedCount === 1 ? "y" : "ies"}${healedFrom > 0 ? ` (was ${healedFrom.toLocaleString()} chars oversized)` : " (dropped dangling tool_calls tail)"}. Rewrote session file.\n`,
+        );
+      }
     } else {
       this.resumedMessageCount = 0;
     }
   }
 
+  /**
+   * Shrink the log by re-truncating oversized tool results to a tighter
+   * cap, and persist the result back to disk so the next launch doesn't
+   * re-inherit a fat session file. Returns a summary the TUI can
+   * display.
+   *
+   * Only tool-role messages are touched (same rationale as
+   * {@link healLoadedMessages}). User and assistant messages carry
+   * authored intent we can't mechanically shrink without losing
+   * meaning.
+   */
+  compact(tightCapChars = 4000): { healedCount: number; charsSaved: number } {
+    const before = this.log.toMessages();
+    // Use `shrinkOversizedToolResults` (not `healLoadedMessages`) — the
+    // full heal would also strip a dangling `assistant.tool_calls` tail,
+    // which during an active turn is legitimate state we still need
+    // (tools haven't been dispatched yet). Structural healing is only
+    // appropriate at session LOAD; mid-session `/compact` is strictly
+    // about shrinking oversized tool payloads.
+    const { messages, healedCount, healedFrom } = shrinkOversizedToolResults(before, tightCapChars);
+    const afterBytes = messages
+      .filter((m) => m.role === "tool")
+      .reduce((s, m) => s + (typeof m.content === "string" ? m.content.length : 0), 0);
+    const charsSaved = healedFrom - afterBytes;
+    if (healedCount > 0) {
+      this.log.compactInPlace(messages);
+      if (this.sessionName) {
+        try {
+          rewriteSession(this.sessionName, messages);
+        } catch {
+          /* disk full or perms — compaction still applies in-memory */
+        }
+      }
+    }
+    return { healedCount, charsSaved };
+  }
+
   private appendAndPersist(message: ChatMessage): void {
     this.log.append(message);
     if (this.sessionName) {
@@ -186,6 +308,31 @@ export class CacheFirstLoop {
     }
   }
 
+  /**
+   * Start a fresh conversation WITHOUT exiting. Drops every message
+   * in the in-memory log AND rewrites the session file to empty so
+   * a resume won't re-hydrate the old turns. Unlike `/forget`, which
+   * deletes the session entirely, this keeps the session name and
+   * config intact — it's the "new chat" button.
+   *
+   * The immutable prefix (system prompt + tool specs) is preserved
+   * — that's the cache-first invariant, not part of the conversation.
+   * Returns the number of messages dropped so the UI can show it.
+   */
+  clearLog(): { dropped: number } {
+    const dropped = this.log.length;
+    this.log.compactInPlace([]);
+    if (this.sessionName) {
+      try {
+        rewriteSession(this.sessionName, []);
+      } catch {
+        /* disk issue shouldn't block the in-memory clear */
+      }
+    }
+    this.scratch.reset();
+    return { dropped };
+  }
+
   /**
    * Reconfigure model/harvest/branch/stream mid-session. The loop's log,
    * scratch, and stats are preserved — only the per-turn behavior changes.
@@ -224,18 +371,150 @@ export class CacheFirstLoop {
   }
 
   private buildMessages(pendingUser: string | null): ChatMessage[] {
-    const msgs: ChatMessage[] = [...this.prefix.toMessages(), ...this.log.toMessages()];
+    // Full tool_calls ↔ tool pairing validation. DeepSeek 400s on
+    // both sides of this contract — unpaired assistant.tool_calls
+    // ("insufficient tool messages following") OR stray tool entries
+    // ("tool must be a response to a preceding tool_calls"). A corrupted
+    // session from an earlier build can have either. Rather than
+    // applying a bunch of narrow tail-trim heuristics, rebuild the
+    // message stream through the same validator used at load time so
+    // the payload we hand to the API is well-formed by construction.
+    const healed = healLoadedMessages(this.log.toMessages(), DEFAULT_MAX_RESULT_CHARS);
+    const msgs: ChatMessage[] = [...this.prefix.toMessages(), ...healed.messages];
     if (pendingUser !== null) msgs.push({ role: "user", content: pendingUser });
     return msgs;
   }
 
+  /**
+   * Signal the currently-running {@link step} to stop **now**. Cancels
+   * the in-flight network request (DeepSeek HTTP/SSE) AND any tool call
+   * currently dispatching (MCP `notifications/cancelled` + promise
+   * reject). The loop itself also sees `signal.aborted` at each
+   * iteration boundary and exits quickly instead of looping again.
+   * Called by the TUI on Esc.
+   */
+  abort(): void {
+    this._turnAbort.abort();
+  }
+
+  /**
+   * Drop everything in the log after (and including) the most recent
+   * user message. Used by `/retry` so the caller can re-send that
+   * message with a fresh turn instead of layering another response on
+   * top of the prior exchange. Returns the content of the dropped user
+   * message, or `null` if there isn't one yet.
+   *
+   * Persists by rewriting the session file — otherwise the next
+   * launch would rehydrate the old exchange and `/retry` would seem
+   * to have done nothing.
+   */
+  retryLastUser(): string | null {
+    const entries = this.log.entries;
+    let lastUserIdx = -1;
+    for (let i = entries.length - 1; i >= 0; i--) {
+      if (entries[i]!.role === "user") {
+        lastUserIdx = i;
+        break;
+      }
+    }
+    if (lastUserIdx < 0) return null;
+    const raw = entries[lastUserIdx]!.content;
+    const userText = typeof raw === "string" ? raw : "";
+    // Keep everything strictly before the user message. The caller
+    // will submit the text again through the normal path, which
+    // re-appends the user turn on first successful API response.
+    const preserved = entries.slice(0, lastUserIdx).map((m) => ({ ...m }));
+    this.log.compactInPlace(preserved);
+    if (this.sessionName) {
+      try {
+        rewriteSession(this.sessionName, preserved);
+      } catch {
+        /* disk-full / perms — in-memory compaction still applies */
+      }
+    }
+    return userText;
+  }
+
   async *step(userInput: string): AsyncGenerator<LoopEvent> {
     this._turn++;
     this.scratch.reset();
+    // A fresh user turn is a new intent — don't let StormBreaker's
+    // old sliding window of (name, args) signatures keep blocking
+    // calls that are now legitimately on-task. The window repopulates
+    // naturally as this turn's tool calls flow through.
+    this.repair.resetStorm();
+    // Fresh controller for this turn: the prior step's signal has
+    // already fired (or stayed clean); either way we don't want its
+    // state to bleed into the new turn.
+    this._turnAbort = new AbortController();
+    const signal = this._turnAbort.signal;
     let pendingUser: string | null = userInput;
     const toolSpecs = this.prefix.tools();
+    // 70% of the iter budget is the "you're getting close" threshold. We
+    // only warn once per step so the user sees a single signal, not a
+    // string of identical yellow lines stacked up.
+    const warnAt = Math.max(1, Math.floor(this.maxToolIters * 0.7));
+    let warnedForIterBudget = false;
 
     for (let iter = 0; iter < this.maxToolIters; iter++) {
+      if (signal.aborted) {
+        // Esc means "stop now" — not "stop and force another 30-90s
+        // reasoner call to produce a summary I didn't ask for". The
+        // user's mental model of cancel is immediate. We emit a
+        // synthetic assistant_final (tagged forcedSummary so the
+        // code-mode applier ignores it) with a short stopped
+        // message, then done. The prior tool outputs are still in
+        // the log if the user wants to continue — asking again
+        // will hit a warm cache and be cheap.
+        //
+        // Budget / context-guard still call forceSummaryAfterIterLimit
+        // because there the USER didn't choose to stop — we did —
+        // and leaving them staring at nothing is worse than one extra
+        // call.
+        yield {
+          turn: this._turn,
+          role: "warning",
+          content: `aborted at iter ${iter}/${this.maxToolIters} — stopped without producing a summary (press ↑ + Enter or /retry to resume)`,
+        };
+        const stoppedMsg =
+          "[aborted by user (Esc) — no summary produced. Ask again or /retry when ready; prior tool output is still in the log.]";
+        this.appendAndPersist({ role: "assistant", content: stoppedMsg });
+        yield {
+          turn: this._turn,
+          role: "assistant_final",
+          content: stoppedMsg,
+          forcedSummary: true,
+        };
+        yield { turn: this._turn, role: "done", content: stoppedMsg };
+        return;
+      }
+      // Bridge the silence between the PREVIOUS iter's tool result and
+      // THIS iter's first streaming byte. R1 can spend 20-90s reasoning
+      // about tool output before the first delta lands, and prior to
+      // this hint the UI had nothing to render. Only emit on iter > 0
+      // because iter 0's "thinking" phase is already covered by the
+      // streaming row / StreamingAssistant's placeholder.
+      //
+      // Wording is explicit about the two things happening: the tool
+      // result IS being uploaded (it's now part of the next prompt) and
+      // the model IS thinking. Users were reading "thinking about the
+      // tool result" as the model-only phase, but the wait also covers
+      // the upload round-trip.
+      if (iter > 0) {
+        yield {
+          turn: this._turn,
+          role: "status",
+          content: "tool result uploaded · model thinking before next response…",
+        };
+      }
+      if (!warnedForIterBudget && iter >= warnAt) {
+        warnedForIterBudget = true;
+        yield {
+          turn: this._turn,
+          role: "warning",
+          content: `${iter}/${this.maxToolIters} tool calls used — approaching budget. Press Esc to force a summary now.`,
+        };
+      }
       const messages = this.buildMessages(pendingUser);
 
       let assistantContent = "";
@@ -283,6 +562,7 @@ export class CacheFirstLoop {
               model: this.model,
               messages,
               tools: toolSpecs.length ? toolSpecs : undefined,
+              signal,
             },
             {
               ...this.branchOptions,
@@ -341,6 +621,7 @@ export class CacheFirstLoop {
             model: this.model,
             messages,
             tools: toolSpecs.length ? toolSpecs : undefined,
+            signal,
           })) {
             if (chunk.contentDelta) {
               assistantContent += chunk.contentDelta;
@@ -371,6 +652,16 @@ export class CacheFirstLoop {
               if (d.argumentsDelta)
                 cur.function.arguments = (cur.function.arguments ?? "") + d.argumentsDelta;
               callBuf.set(d.index, cur);
+              // Skip the id-only opener: name is empty until the next chunk.
+              if (cur.function.name) {
+                yield {
+                  turn: this._turn,
+                  role: "tool_call_delta",
+                  content: "",
+                  toolName: cur.function.name,
+                  toolCallArgsChars: (cur.function.arguments ?? "").length,
+                };
+              }
             }
             if (chunk.usage) usage = chunk.usage;
           }
@@ -380,6 +671,7 @@ export class CacheFirstLoop {
             model: this.model,
             messages,
             tools: toolSpecs.length ? toolSpecs : undefined,
+            signal,
           });
           assistantContent = resp.content;
           reasoningContent = resp.reasoningContent ?? "";
@@ -391,7 +683,7 @@ export class CacheFirstLoop {
           turn: this._turn,
           role: "error",
           content: "",
-          error: (err as Error).message,
+          error: formatLoopError(err as Error),
         };
         return;
       }
@@ -405,15 +697,31 @@ export class CacheFirstLoop {
       }
 
       this.scratch.reasoning = reasoningContent || null;
+      // Harvest is a second API round-trip (cheap model, but still
+      // 1-10s) that was previously silent. Bridge the gap with a
+      // status indicator so the TUI shows *something* instead of
+      // "reasoning finished, now staring at the wall."
+      if (
+        !preHarvestedPlanState &&
+        this.harvestEnabled &&
+        (reasoningContent?.trim().length ?? 0) >= 40
+      ) {
+        yield {
+          turn: this._turn,
+          role: "status",
+          content: "extracting plan state from reasoning…",
+        };
+      }
       const planState = preHarvestedPlanState
         ? preHarvestedPlanState
         : this.harvestEnabled
-          ? await harvest(reasoningContent || null, this.client, this.harvestOptions)
+          ? await harvest(reasoningContent || null, this.client, this.harvestOptions, signal)
           : emptyPlanState();
 
       const { calls: repairedCalls, report } = this.repair.process(
         toolCalls,
         reasoningContent || null,
+        assistantContent || null,
       );
 
       this.appendAndPersist(this.assistantMessage(assistantContent, repairedCalls));
@@ -428,15 +736,117 @@ export class CacheFirstLoop {
         branch: branchSummary,
       };
 
+      // Loud signal when the storm breaker caught a repeat pattern.
+      // The `repair` field on assistant_final already carries the
+      // count as a subtext on the assistant row, but a dedicated
+      // warning row is far more noticeable — and critical when ALL
+      // calls were suppressed, because the turn then ends with no
+      // visible explanation of why nothing happened.
+      if (report.stormsBroken > 0) {
+        const noteTail = report.notes.length ? ` — ${report.notes[report.notes.length - 1]}` : "";
+        const allSuppressed = repairedCalls.length === 0 && toolCalls.length > 0;
+        const phrase = allSuppressed
+          ? `stopped the model from calling the same tool with identical args repeatedly (all ${toolCalls.length} call(s) this turn were already in the recent-repeat window). Likely a stuck retry — reword your instruction, rule out the underlying blocker, or try /retry after fixing it`
+          : `suppressed ${report.stormsBroken} repeat tool call(s) that had fired 3+ times with identical args in a sliding window`;
+        yield {
+          turn: this._turn,
+          role: "warning",
+          content: `${phrase}${noteTail}`,
+        };
+      }
+
       if (repairedCalls.length === 0) {
         yield { turn: this._turn, role: "done", content: assistantContent };
         return;
       }
 
+      // Token-budget guard — the real stop condition. Iter count is a
+      // proxy that misses the actual constraint: how close the prompt
+      // already is to DeepSeek's 131k context. If we're over 80%, the
+      // NEXT call (with the just-executed tools' results stuffed into
+      // history) will be worse, and fairly soon it'll 400 with
+      // "maximum context length".
+      //
+      // Strategy, in order:
+      //   1. Try auto-compacting the log (shrink oversized tool
+      //      results). If that gets us back under 80% we keep going —
+      //      the user doesn't lose their turn to a premature summary.
+      //   2. If still over after compact, divert to the forced-summary
+      //      path. BUT first drop the trailing assistant-with-tool_calls
+      //      that we just appended — we haven't executed the tools yet,
+      //      so sending this to the summary call with no matching tool
+      //      responses would 400 ("insufficient tool messages following
+      //      tool_calls"). The summary is about what was LEARNED so far,
+      //      not what we intended to do next.
+      const ctxMax = DEEPSEEK_CONTEXT_TOKENS[this.model] ?? DEFAULT_CONTEXT_TOKENS;
+      if (usage && usage.promptTokens / ctxMax > 0.8) {
+        const before = usage.promptTokens;
+        const compactResult = this.compact(4000);
+        if (compactResult.healedCount > 0) {
+          // Rough estimate: 4 chars per token. Good enough to decide
+          // whether compaction pushed us back under the threshold; the
+          // exact number comes back from the NEXT API response's usage.
+          const approxSaved = Math.round(compactResult.charsSaved / 4);
+          const after = before - approxSaved;
+          yield {
+            turn: this._turn,
+            role: "warning",
+            content: `context ${before.toLocaleString()}/${ctxMax.toLocaleString()} — auto-compacted ${compactResult.healedCount} oversized tool result(s), saved ~${approxSaved.toLocaleString()} tokens (now ~${after.toLocaleString()}). Continuing.`,
+          };
+          // Intentionally don't re-check the threshold here: even if
+          // compaction didn't fully clear us under 80%, one more tool
+          // call's overhead isn't going to overflow, and the NEXT
+          // iter's fresh `usage` from the API will catch real danger.
+        } else {
+          yield {
+            turn: this._turn,
+            role: "warning",
+            content: `context ${before.toLocaleString()}/${ctxMax.toLocaleString()} (${Math.round(
+              (before / ctxMax) * 100,
+            )}%) — nothing to auto-compact. Forcing summary from what was gathered.`,
+          };
+          // Drop the trailing assistant-with-tool_calls we just
+          // appended. The forced-summary call would otherwise trip
+          // DeepSeek's "insufficient tool messages following tool_calls"
+          // validator, since we bail BEFORE dispatching the tools.
+          const tail = this.log.entries[this.log.entries.length - 1];
+          if (
+            tail &&
+            tail.role === "assistant" &&
+            Array.isArray(tail.tool_calls) &&
+            tail.tool_calls.length > 0
+          ) {
+            const kept = this.log.entries.slice(0, -1);
+            this.log.compactInPlace([...kept]);
+            if (this.sessionName) {
+              try {
+                rewriteSession(this.sessionName, kept);
+              } catch {
+                /* disk issue shouldn't block the summary path */
+              }
+            }
+          }
+          yield* this.forceSummaryAfterIterLimit({ reason: "context-guard" });
+          return;
+        }
+      }
+
       for (const call of repairedCalls) {
         const name = call.function?.name ?? "";
         const args = call.function?.arguments ?? "{}";
-        const result = await this.tools.dispatch(name, args);
+        // Announce the tool BEFORE awaiting it so the TUI can render a
+        // "running…" indicator. Without this, the window between
+        // assistant_final and the tool-result yield is silent from the
+        // UI's perspective — which makes long tool calls feel like the
+        // app has hung.
+        yield {
+          turn: this._turn,
+          role: "tool_start",
+          content: "",
+          toolName: name,
+          toolArgs: args,
+        };
+        const result = await this.tools.dispatch(name, args, { signal });
         this.appendAndPersist({
           role: "tool",
           tool_call_id: call.id ?? "",
@@ -453,7 +863,71 @@ export class CacheFirstLoop {
       }
     }
 
-    yield { turn: this._turn, role: "done", content: "[max_tool_iters reached]" };
+    // We exhausted the tool-call budget while the model still wanted to
+    // call more tools. Rather than stopping silently (which leaves the
+    // user staring at a blank prompt), force one final no-tools call so
+    // the model must produce a text summary from everything it has
+    // already seen.
+    yield* this.forceSummaryAfterIterLimit({ reason: "budget" });
+  }
+
+  private async *forceSummaryAfterIterLimit(
+    opts: { reason: "budget" | "aborted" | "context-guard" } = { reason: "budget" },
+  ): AsyncGenerator<LoopEvent> {
+    try {
+      // The summary call is non-streaming (reasoner, 30-60s typical).
+      // Without this status the user sees nothing happening after the
+      // yellow "budget reached" warning until the summary arrives.
+      yield {
+        turn: this._turn,
+        role: "status",
+        content: "summarizing what was gathered…",
+      };
+      const messages = this.buildMessages(null);
+      // Passing `tools: undefined` was supposed to force a text
+      // response, but R1 can still hallucinate tool-call markup
+      // (e.g. DSML `<｜DSML｜function_calls>…</｜DSML｜function_calls>`)
+      // in prose when it's been primed by prior tool use. An explicit
+      // user-role instruction plus post-hoc stripping of known
+      // hallucination shapes keeps the user from seeing raw markup.
+      messages.push({
+        role: "user",
+        content:
+          "I'm out of tool-call budget for this turn. Summarize in plain prose what you learned from the tool results above. Do NOT emit any tool calls, function-call markup, DSML invocations, or SEARCH/REPLACE edit blocks — they will be silently discarded. Just plain text.",
+      });
+      const resp = await this.client.chat({
+        model: this.model,
+        messages,
+        // no tools → model is forced to answer in text
+        signal: this._turnAbort.signal,
+      });
+      const rawContent = resp.content?.trim() ?? "";
+      const cleaned = stripHallucinatedToolMarkup(rawContent);
+      const summary =
+        cleaned ||
+        "(model emitted fake tool-call markup instead of a prose summary — try /retry with a narrower question, or /think to inspect R1's reasoning)";
+      const reasonPrefix = reasonPrefixFor(opts.reason, this.maxToolIters);
+      const annotated = `${reasonPrefix}\n\n${summary}`;
+      const summaryStats = this.stats.record(this._turn, this.model, resp.usage ?? new Usage());
+      this.appendAndPersist({ role: "assistant", content: summary });
+      yield {
+        turn: this._turn,
+        role: "assistant_final",
+        content: annotated,
+        stats: summaryStats,
+        forcedSummary: true,
+      };
+      yield { turn: this._turn, role: "done", content: summary };
+    } catch (err) {
+      const label = errorLabelFor(opts.reason, this.maxToolIters);
+      yield {
+        turn: this._turn,
+        role: "error",
+        content: "",
+        error: `${label} and the fallback summary call failed: ${(err as Error).message}. Run /clear and retry with a narrower question, or raise --max-tool-iters.`,
+      };
+      yield { turn: this._turn, role: "done", content: "" };
+    }
   }
 
   async run(userInput: string, onEvent?: (ev: LoopEvent) => void): Promise<string> {
@@ -473,6 +947,45 @@ export class CacheFirstLoop {
   }
 }
 
+/**
+ * R1 occasionally hallucinates tool-call markup as plain text when the
+ * real tool channel has been closed — typically our forced-summary
+ * path, where `tools: undefined` is supposed to force prose but isn't
+ * always respected. The markup isn't parsed by our tool-call path
+ * (the API response's structured `tool_calls` field is empty), so
+ * it's just noise in the user's view. Strip known envelope shapes.
+ *
+ * Exported so tests can exercise it against concrete R1 outputs.
+ */
+export function stripHallucinatedToolMarkup(s: string): string {
+  let out = s;
+  // DeepSeek's DSML envelope (both the full-width "｜" character and
+  // the ASCII-only fallback we've seen — the full-width form is the
+  // one R1 emits in practice)
+  out = out.replace(/<｜DSML｜function_calls>[\s\S]*?<\/?｜DSML｜function_calls>/g, "");
+  out = out.replace(/<\|DSML\|function_calls>[\s\S]*?<\/?\|DSML\|function_calls>/g, "");
+  // Anthropic / generic XML-ish envelope
+  out = out.replace(/<function_calls>[\s\S]*?<\/function_calls>/g, "");
+  // Lone unpaired DSML opener left over after the closer was on a
+  // different line (seen when R1 truncates mid-call).
+  out = out.replace(/<｜DSML｜[\s\S]*$/g, "");
+  return out.trim();
+}
+
+function reasonPrefixFor(reason: "budget" | "aborted" | "context-guard", iterCap: number): string {
+  if (reason === "aborted") return "[aborted by user (Esc) — summarizing what I found so far]";
+  if (reason === "context-guard") {
+    return "[context budget running low — summarizing before the next call would overflow]";
+  }
+  return `[tool-call budget (${iterCap}) reached — forcing summary from what I found]`;
+}
+
+function errorLabelFor(reason: "budget" | "aborted" | "context-guard", iterCap: number): string {
+  if (reason === "aborted") return "aborted by user";
+  if (reason === "context-guard") return "context-guard triggered (prompt > 80% of window)";
+  return `tool-call budget (${iterCap}) reached`;
+}
+
 function summarizeBranch(chosen: BranchSample, samples: BranchSample[]): BranchSummary {
   return {
     budget: samples.length,
@@ -481,3 +994,126 @@ function summarizeBranch(chosen: BranchSample, samples: BranchSample[]): BranchS
     temperatures: samples.map((s) => s.temperature),
   };
 }
+
+/**
+ * Truncate any tool-role message whose content exceeds the cap. User
+ * and assistant messages are left alone because (a) they're almost
+ * always small, (b) truncating user prompts would corrupt conversational
+ * intent in a way the user didn't author. Exported for tests.
+ */
+/**
+ * Shrink oversized tool results only — the original compact concern.
+ * Separated from `healLoadedMessages` so `/compact` (live, mid-session)
+ * doesn't accidentally strip structural tail that belongs in the
+ * current turn's state.
+ */
+export function shrinkOversizedToolResults(
+  messages: ChatMessage[],
+  maxChars: number,
+): { messages: ChatMessage[]; healedCount: number; healedFrom: number } {
+  let healedCount = 0;
+  let healedFrom = 0;
+  const out = messages.map((msg) => {
+    if (msg.role !== "tool") return msg;
+    const content = typeof msg.content === "string" ? msg.content : "";
+    if (content.length <= maxChars) return msg;
+    healedCount += 1;
+    healedFrom += content.length;
+    return { ...msg, content: truncateForModel(content, maxChars) };
+  });
+  return { messages: out, healedCount, healedFrom };
+}
+
+export function healLoadedMessages(
+  messages: ChatMessage[],
+  maxChars: number,
+): { messages: ChatMessage[]; healedCount: number; healedFrom: number } {
+  // Pass 1: shrink oversized tool results (original heal purpose).
+  const shrunk = shrinkOversizedToolResults(messages, maxChars);
+  let healedCount = shrunk.healedCount;
+  // Pass 2: enforce tool_calls ↔ tool pairing across the full log.
+  //
+  // DeepSeek rejects two shapes at the API boundary:
+  //   (a) assistant with tool_calls not followed by matching tool
+  //       responses ("insufficient tool messages following tool_calls")
+  //   (b) tool message without a preceding assistant.tool_calls with
+  //       the matching tool_call_id ("must be a response to a preceding
+  //       message with 'tool_calls'")
+  //
+  // Corrupted session files from earlier builds have hit both. Rebuild
+  // the message stream so only well-formed (assistant.tool_calls + all
+  // matching responses) groups survive. Plain user/assistant messages
+  // (no tool_calls) always pass through.
+  const out: ChatMessage[] = [];
+  const openCallIds = new Set<string>();
+  let droppedAssistantCalls = 0;
+  let droppedStrayTools = 0;
+  for (let i = 0; i < shrunk.messages.length; i++) {
+    const msg = shrunk.messages[i]!;
+    if (msg.role === "assistant" && Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0) {
+      // Look ahead for tool responses matching every id in this
+      // assistant's tool_calls. If all present (in any order, but
+      // contiguous after this message), include the whole group.
+      const needed = new Set<string>();
+      for (const call of msg.tool_calls) {
+        if (call?.id) needed.add(call.id);
+      }
+      const candidates: ChatMessage[] = [];
+      let j = i + 1;
+      while (j < shrunk.messages.length && needed.size > 0) {
+        const nxt = shrunk.messages[j]!;
+        if (nxt.role !== "tool") break;
+        const id = nxt.tool_call_id ?? "";
+        if (!needed.has(id)) break;
+        needed.delete(id);
+        candidates.push(nxt);
+        j++;
+      }
+      if (needed.size === 0) {
+        // Every call has a response — emit the whole group.
+        out.push(msg);
+        for (const r of candidates) out.push(r);
+        i = j - 1; // for-loop ++ will advance past the last response
+      } else {
+        // Drop the assistant entry and anything that was speculatively
+        // its responses — they'd become stray tool messages.
+        droppedAssistantCalls += 1;
+        droppedStrayTools += candidates.length;
+        i = j - 1;
+      }
+      continue;
+    }
+    if (msg.role === "tool") {
+      // Any tool message that reaches here did NOT get consumed by
+      // the assistant-with-tool_calls branch above, so it's stray.
+      // Drop it — surfacing it would 400 the next API call.
+      droppedStrayTools += 1;
+      continue;
+    }
+    // Plain user/assistant/system message — pass through.
+    out.push(msg);
+  }
+  healedCount += droppedAssistantCalls + droppedStrayTools;
+  return { messages: out, healedCount, healedFrom: shrunk.healedFrom };
+}
+
+/**
+ * Annotate the `DeepSeek 400: … maximum context length …` error the API
+ * returns when a session's history has grown past 131,072 tokens. The
+ * raw message is a JSON blob; we surface a short actionable hint on top
+ * so the user knows to `/forget` or `/clear` rather than parsing the
+ * JSON themselves. Other errors pass through unchanged — the loop's
+ * error channel already formats them well enough.
+ */
+export function formatLoopError(err: Error): string {
+  const msg = err.message ?? "";
+  if (msg.includes("maximum context length")) {
+    // Pull the "requested X tokens" figure out of the JSON for scale.
+    const reqMatch = msg.match(/requested\s+(\d+)\s+tokens/);
+    const requested = reqMatch
+      ? `${Number(reqMatch[1]).toLocaleString()} tokens`
+      : "too many tokens";
+    return `Context overflow (DeepSeek 400): session history is ${requested}, past the 131,072-token limit. Usually this means a single tool call returned a huge payload. v0.3.0-alpha.6+ caps new tool results at 32k chars, AND auto-heals oversized history on session load — restart Reasonix and this session should come back trimmed. If it still overflows, run /forget (delete the session) or /clear (drop the displayed history) to start fresh.`;
+  }
+  return msg;
+}

src/mcp/README.md

@@ -0,0 +1,147 @@
+# MCP client (v0.3 foundation)
+
+Minimal [Model Context Protocol](https://spec.modelcontextprotocol.io/)
+client, hand-rolled in TypeScript. Lets Reasonix consume tools from any
+MCP server (filesystem, github, slack, puppeteer, …) while applying the
+Cache-First Loop and tool-call repair to the whole thing automatically.
+
+## Design choice: roll-our-own, not @modelcontextprotocol/sdk
+
+Same reasoning that drove `client.ts` (DeepSeek) rather than `openai`:
+
+- **Zero runtime deps** for this module. Consistent with Reasonix's
+  policy of owning the wire format where it matters.
+- **Surface tuning**: we only implement what Reasonix actually uses —
+  initialize + tools/list + tools/call. Resources, prompts, sampling,
+  and progress notifications are deferred.
+- **Insulation** from SDK breaking changes. The spec is more stable
+  than any single SDK release.
+
+Swappable if needed: `McpClient` depends on the `McpTransport` interface,
+so the day we do want the official SDK's transport layer we can adapt
+it and keep everything else.
+
+## What's shipped here
+
+```
+src/mcp/
+├── types.ts      JSON-RPC 2.0 + MCP-specific message types
+├── stdio.ts      McpTransport interface + StdioTransport (spawn child)
+├── sse.ts        SseTransport (HTTP+SSE for remote/hosted servers)
+├── spec.ts       parseMcpSpec — parses --mcp CLI arg into transport-tagged spec
+├── catalog.ts    curated list of popular official MCP servers
+├── client.ts     McpClient: initialize / listTools / callTool
+├── registry.ts   bridgeMcpTools: MCP → ToolRegistry
+└── README.md     (this file)
+
+tests/mcp.test.ts — in-process fake transport, no child processes
+tests/mcp-sse.test.ts — in-process http.Server fake for SSE
+```
+
+## What's NOT here (yet)
+
+| feature | status | note |
+|---|---|---|
+| CLI wiring (`reasonix chat --mcp <cmd>`) | ✅ shipped | see Usage below |
+| Bundled demo server | ✅ shipped | `examples/mcp-server-demo.ts`, exposes echo/add/get_time |
+| Real-subprocess integration test | ✅ shipped | `tests/mcp-integration.test.ts` |
+| Resources / `resources/list` / `resources/read` | deferred | Reasonix doesn't surface resources today |
+| Prompts / `prompts/list` | deferred | ditto |
+| Progress notifications | deferred | long-running tool support comes with the CLI work |
+| Streaming results | deferred | current shape returns one CallToolResult per call |
+| SSE transport | ✅ shipped | `src/mcp/sse.ts` — pass `http(s)://…` to `--mcp` |
+| Streamable HTTP (2025-03-26 spec) | deferred | waiting for a real server to validate against |
+| MCP server that Reasonix exposes | never | out of scope — Reasonix is a client |
+
+## Usage (CLI)
+
+`--mcp` is repeatable — attach one or many MCP servers; their tools become
+first-class citizens of the loop.
+
+```bash
+# Single server, anonymous (tools use native names):
+reasonix chat --mcp "node --import tsx examples/mcp-server-demo.ts"
+
+# Official filesystem server:
+reasonix chat --mcp "npx -y @modelcontextprotocol/server-filesystem /tmp/safe-dir"
+
+# Multiple servers, each namespaced. Syntax: "name=command args..."
+# Tools land in a shared registry as fs_read_file, demo_add, etc.
+reasonix chat \
+  --mcp "fs=npx -y @modelcontextprotocol/server-filesystem /tmp/safe" \
+  --mcp "demo=node --import tsx examples/mcp-server-demo.ts"
+
+# Global prefix (only honored when there's ONE anonymous server):
+reasonix chat \
+  --mcp "npx -y @modelcontextprotocol/server-filesystem /tmp" \
+  --mcp-prefix fs_
+
+# Same flag works with one-shot run:
+reasonix run "list files in /tmp/safe-dir" \
+  --mcp "npx -y @modelcontextprotocol/server-filesystem /tmp/safe-dir"
+```
+
+Each spec is shell-split (spaces separate args; use quotes for paths with
+spaces). Windows-friendly: backslashes pass through literally outside
+quotes, so `C:\path\to\dir` works. Tools get folded into the
+`ImmutablePrefix` for the model, and every call goes through Reasonix's
+Cache-First loop + tool-call repair (scavenge / flatten / storm)
+automatically.
+
+## Usage (library)
+
+```ts
+import {
+  McpClient,
+  StdioTransport,
+  bridgeMcpTools,
+  CacheFirstLoop,
+  DeepSeekClient,
+  ImmutablePrefix,
+} from "reasonix";
+
+// 1. Spawn + connect to an MCP server
+const transport = new StdioTransport({
+  command: "npx",
+  args: ["-y", "@modelcontextprotocol/server-filesystem", "/tmp/safe-dir"],
+});
+const mcp = new McpClient({ transport });
+await mcp.initialize();
+
+// 2. Bridge its tools into a Reasonix ToolRegistry
+const { registry } = await bridgeMcpTools(mcp, { namePrefix: "fs_" });
+
+// 3. Use them with the Cache-First Loop — same as any native tool
+const client = new DeepSeekClient();
+const loop = new CacheFirstLoop({
+  client,
+  prefix: new ImmutablePrefix({
+    system: "You can use the filesystem tools to help the user.",
+    toolSpecs: registry.specs(),
+  }),
+  tools: registry,
+});
+
+for await (const ev of loop.step("List the files in /tmp/safe-dir.")) {
+  if (ev.role === "assistant_final") console.log(ev.content);
+}
+
+// 4. Clean up
+await mcp.close();
+```
+
+The payoff: the filesystem server's tools now inherit Reasonix's
+cache-first prefix stability + repair (schema flatten, tool-call
+scavenge, call-storm break) without the MCP server knowing anything
+about it.
+
+## Wire protocol notes (stdio)
+
+- **Framing**: newline-delimited JSON. One JSON-RPC message per line,
+  UTF-8, no Content-Length header (that's LSP, not MCP stdio).
+- **Stderr**: forwarded to the parent's stderr. Servers often print
+  startup banners there; that's fine.
+- **Shutdown**: `close()` calls `child.stdin.end()` then SIGTERM if the
+  process hasn't exited.
+- **Malformed lines**: dropped silently. Some servers emit non-JSON
+  during startup; logging every dropped line would be noise.

src/mcp/catalog.ts

@@ -0,0 +1,79 @@
+/**
+ * Curated catalog of popular MCP servers.
+ *
+ * Hardcoded because (a) this list changes slowly — maybe monthly, (b)
+ * fetching it over the network would make `reasonix mcp list` flaky
+ * offline or behind a proxy. When it does change, update this file and
+ * ship a patch release.
+ *
+ * Inclusion criteria:
+ *   - actively maintained (official Anthropic repo OR widely used)
+ *   - stdio-compatible (Reasonix doesn't do SSE yet)
+ *   - installable with one `npx -y ...` command — zero manual setup
+ *   - has a clear value proposition in one short line
+ *
+ * Not included: servers that need API keys / OAuth / complex config.
+ * Those get their own docs once we have patterns for them.
+ */
+
+export interface CatalogEntry {
+  /** Short name, used as the namespace prefix when suggested. */
+  name: string;
+  /** One-line description shown in `reasonix mcp list`. */
+  summary: string;
+  /** npm package id (for `npx -y <pkg>`). */
+  package: string;
+  /** Extra args the user must supply (e.g. a directory path). */
+  userArgs?: string;
+  /** Notes the user needs to know — shown dimmed. */
+  note?: string;
+}
+
+// Every entry below is verified to exist on npm as of this release.
+// `fetch` and `sqlite` are deliberately *absent* — their reference
+// servers are Python-only (`pip install mcp-server-fetch`), so a Node
+// user running `npx -y @modelcontextprotocol/server-fetch` hits a 404
+// from the npm registry. We'd rather ship a smaller list that always
+// works than a longer list where two options silently 404 on the user.
+export const MCP_CATALOG: CatalogEntry[] = [
+  {
+    name: "filesystem",
+    summary: "read/write/search files inside a sandboxed directory",
+    package: "@modelcontextprotocol/server-filesystem",
+    userArgs: "<dir>",
+    note: "the directory is a hard sandbox — the server refuses access outside it",
+  },
+  {
+    name: "memory",
+    summary: "persistent key-value memory across sessions",
+    package: "@modelcontextprotocol/server-memory",
+  },
+  {
+    name: "github",
+    summary: "read issues, PRs, code search (needs GITHUB_PERSONAL_ACCESS_TOKEN)",
+    package: "@modelcontextprotocol/server-github",
+    note: "set GITHUB_PERSONAL_ACCESS_TOKEN in your env before spawning",
+  },
+  {
+    name: "puppeteer",
+    summary: "browser automation — take screenshots, click, type",
+    package: "@modelcontextprotocol/server-puppeteer",
+    note: "downloads Chromium on first run (~200 MB)",
+  },
+  {
+    name: "everything",
+    summary: "official test server — exercises every MCP feature",
+    package: "@modelcontextprotocol/server-everything",
+    note: "useful for debugging your Reasonix setup",
+  },
+];
+
+/**
+ * Build the `reasonix chat --mcp "..."` command line for a catalog entry.
+ * Returns a copy-pasteable fragment starting at `--mcp`.
+ */
+export function mcpCommandFor(entry: CatalogEntry): string {
+  const pkg = entry.package;
+  const tail = entry.userArgs ? ` ${entry.userArgs}` : "";
+  return `--mcp "${entry.name}=npx -y ${pkg}${tail}"`;
+}

src/mcp/client.ts

@@ -0,0 +1,336 @@
+/**
+ * MCP client — request/response correlation, initialize handshake,
+ * tools/list, tools/call. Built on top of a McpTransport so the same
+ * logic works against a real stdio server or an in-process fake.
+ */
+
+import type { McpTransport } from "./stdio.js";
+import {
+  type CallToolParams,
+  type CallToolResult,
+  type GetPromptParams,
+  type GetPromptResult,
+  type InitializeParams,
+  type InitializeResult,
+  type JsonRpcId,
+  type JsonRpcMessage,
+  type JsonRpcRequest,
+  type JsonRpcResponse,
+  type ListPromptsParams,
+  type ListPromptsResult,
+  type ListResourcesParams,
+  type ListResourcesResult,
+  type ListToolsResult,
+  MCP_PROTOCOL_VERSION,
+  type McpClientInfo,
+  type McpProgressHandler,
+  type ProgressNotificationParams,
+  type ReadResourceParams,
+  type ReadResourceResult,
+  isJsonRpcError,
+} from "./types.js";
+
+export interface McpClientOptions {
+  transport: McpTransport;
+  clientInfo?: McpClientInfo;
+  /** Per-request timeout. Default 60s. */
+  requestTimeoutMs?: number;
+}
+
+interface PendingRequest {
+  resolve: (value: unknown) => void;
+  reject: (err: Error) => void;
+  timeout: NodeJS.Timeout;
+}
+
+export class McpClient {
+  private readonly transport: McpTransport;
+  private readonly clientInfo: McpClientInfo;
+  private readonly requestTimeoutMs: number;
+  private readonly pending = new Map<JsonRpcId, PendingRequest>();
+  private nextId = 1;
+  private readerStarted = false;
+  private initialized = false;
+  private _serverCapabilities: InitializeResult["capabilities"] = {};
+  private _serverInfo: InitializeResult["serverInfo"] = { name: "", version: "" };
+  private _protocolVersion = "";
+  private _instructions: string | undefined;
+  // Progress-token → handler for notifications/progress routing. Tokens
+  // are minted per call when the caller supplies an onProgress
+  // callback; cleared when the final response lands (or the pending
+  // request rejects). No leaks — the `try/finally` in callTool
+  // guarantees cleanup even on timeout.
+  private readonly progressHandlers = new Map<string | number, McpProgressHandler>();
+  private nextProgressToken = 1;
+
+  constructor(opts: McpClientOptions) {
+    this.transport = opts.transport;
+    this.clientInfo = opts.clientInfo ?? { name: "reasonix", version: "0.3.0-dev" };
+    this.requestTimeoutMs = opts.requestTimeoutMs ?? 60_000;
+  }
+
+  /** Server's advertised capabilities, available after initialize(). */
+  get serverCapabilities(): InitializeResult["capabilities"] {
+    return this._serverCapabilities;
+  }
+
+  /** Server's self-reported name + version, available after initialize(). */
+  get serverInfo(): InitializeResult["serverInfo"] {
+    return this._serverInfo;
+  }
+
+  /** Protocol version the server agreed to during the handshake. */
+  get protocolVersion(): string {
+    return this._protocolVersion;
+  }
+
+  /** Optional free-form instructions the server provides at handshake. */
+  get serverInstructions(): string | undefined {
+    return this._instructions;
+  }
+
+  /**
+   * Complete the initialize → initialized handshake. Must be called
+   * before any other method (otherwise compliant servers reject).
+   */
+  async initialize(): Promise<InitializeResult> {
+    if (this.initialized) throw new Error("MCP client already initialized");
+    this.startReaderIfNeeded();
+    const result = await this.request<InitializeResult>("initialize", {
+      protocolVersion: MCP_PROTOCOL_VERSION,
+      // Advertise every method the client can consume so servers know
+      // they can send listChanged notifications etc. Sub-feature flags
+      // (e.g. `resources.subscribe`) are omitted — we don't implement
+      // those yet and the empty object means "method-level support, no
+      // sub-features."
+      capabilities: { tools: {}, resources: {}, prompts: {} },
+      clientInfo: this.clientInfo,
+    } satisfies InitializeParams);
+    this._serverCapabilities = result.capabilities ?? {};
+    this._serverInfo = result.serverInfo ?? { name: "", version: "" };
+    this._protocolVersion = result.protocolVersion ?? "";
+    this._instructions = result.instructions;
+    // Per spec: client sends notifications/initialized after receiving the
+    // initialize response. Only then is the connection live for other
+    // methods.
+    await this.transport.send({
+      jsonrpc: "2.0",
+      method: "notifications/initialized",
+    });
+    this.initialized = true;
+    return result;
+  }
+
+  /** List tools the server exposes. */
+  async listTools(): Promise<ListToolsResult> {
+    this.assertInitialized();
+    return this.request<ListToolsResult>("tools/list", {});
+  }
+
+  /**
+   * Invoke a tool by name. When `onProgress` is supplied, attaches a
+   * fresh progress token so the server can send incremental updates
+   * via `notifications/progress`; they're routed to the callback until
+   * the final response arrives (or the request times out, in which
+   * case the handler is simply dropped — no extra notification).
+   *
+   * When `signal` is supplied, aborting it:
+   *   1) fires `notifications/cancelled` to the server (MCP 2024-11-05
+   *      way of saying "forget this request, I no longer care"), and
+   *   2) rejects the pending promise immediately with an AbortError,
+   *      so the caller doesn't have to wait for the subprocess to
+   *      finish its in-flight file write or network request.
+   * The server MAY still emit a late response; we drop it in dispatch
+   * since the request id is gone from `pending`.
+   */
+  async callTool(
+    name: string,
+    args?: Record<string, unknown>,
+    opts: { onProgress?: McpProgressHandler; signal?: AbortSignal } = {},
+  ): Promise<CallToolResult> {
+    this.assertInitialized();
+    const params: CallToolParams = { name, arguments: args ?? {} };
+    let token: number | undefined;
+    if (opts.onProgress) {
+      token = this.nextProgressToken++;
+      this.progressHandlers.set(token, opts.onProgress);
+      params._meta = { progressToken: token };
+    }
+    try {
+      return await this.request<CallToolResult>("tools/call", params, opts.signal);
+    } finally {
+      if (token !== undefined) this.progressHandlers.delete(token);
+    }
+  }
+
+  /**
+   * List resources the server exposes. Supports a pagination cursor;
+   * callers interested in the full set should loop on `nextCursor`.
+   * Servers that don't support resources respond with method-not-found
+   * (−32601) — we surface that as a thrown Error so callers can gate
+   * on the `serverCapabilities.resources` field first.
+   */
+  async listResources(cursor?: string): Promise<ListResourcesResult> {
+    this.assertInitialized();
+    return this.request<ListResourcesResult>("resources/list", {
+      ...(cursor ? { cursor } : {}),
+    } satisfies ListResourcesParams);
+  }
+
+  /** Read the contents of a resource by URI. */
+  async readResource(uri: string): Promise<ReadResourceResult> {
+    this.assertInitialized();
+    return this.request<ReadResourceResult>("resources/read", {
+      uri,
+    } satisfies ReadResourceParams);
+  }
+
+  /** List prompt templates the server exposes. */
+  async listPrompts(cursor?: string): Promise<ListPromptsResult> {
+    this.assertInitialized();
+    return this.request<ListPromptsResult>("prompts/list", {
+      ...(cursor ? { cursor } : {}),
+    } satisfies ListPromptsParams);
+  }
+
+  /**
+   * Fetch a rendered prompt by name. `args` supplies values for any
+   * required template arguments; the server validates. Returns messages
+   * ready to prepend to the model's input.
+   */
+  async getPrompt(name: string, args?: Record<string, string>): Promise<GetPromptResult> {
+    this.assertInitialized();
+    return this.request<GetPromptResult>("prompts/get", {
+      name,
+      ...(args ? { arguments: args } : {}),
+    } satisfies GetPromptParams);
+  }
+
+  /** Close the transport and reject any outstanding requests. */
+  async close(): Promise<void> {
+    for (const [, pending] of this.pending) {
+      clearTimeout(pending.timeout);
+      pending.reject(new Error("MCP client closed"));
+    }
+    this.pending.clear();
+    await this.transport.close();
+  }
+
+  // ---------- internals ----------
+
+  private assertInitialized(): void {
+    if (!this.initialized) throw new Error("MCP client not initialized — call initialize() first");
+  }
+
+  private async request<R>(method: string, params: unknown, signal?: AbortSignal): Promise<R> {
+    const id = this.nextId++;
+    const frame: JsonRpcRequest = { jsonrpc: "2.0", id, method, params };
+    let abortHandler: (() => void) | null = null;
+    const promise = new Promise<R>((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.pending.delete(id);
+        if (abortHandler && signal) signal.removeEventListener("abort", abortHandler);
+        reject(
+          new Error(`MCP request ${method} (id=${id}) timed out after ${this.requestTimeoutMs}ms`),
+        );
+      }, this.requestTimeoutMs);
+      this.pending.set(id, {
+        resolve: resolve as (value: unknown) => void,
+        reject,
+        timeout,
+      });
+      // Wire up cancellation: when signal fires, send an MCP cancellation
+      // notification to the server (so it can stop whatever it was doing)
+      // and reject the caller immediately — no need to wait for the
+      // subprocess to finish its in-flight work. Late responses from the
+      // server are dropped by `dispatch` because the id is gone from
+      // `pending`.
+      if (signal) {
+        if (signal.aborted) {
+          this.pending.delete(id);
+          clearTimeout(timeout);
+          reject(new Error(`MCP request ${method} (id=${id}) aborted before send`));
+          return;
+        }
+        abortHandler = () => {
+          this.pending.delete(id);
+          clearTimeout(timeout);
+          void this.transport
+            .send({
+              jsonrpc: "2.0",
+              method: "notifications/cancelled",
+              params: { requestId: id, reason: "aborted by user" },
+            })
+            .catch(() => {
+              // Transport may already be closing — swallow; we still
+              // reject the caller below so they unblock.
+            });
+          reject(new Error(`MCP request ${method} (id=${id}) aborted by user`));
+        };
+        signal.addEventListener("abort", abortHandler, { once: true });
+      }
+    });
+    try {
+      await this.transport.send(frame);
+    } catch (err) {
+      this.pending.delete(id);
+      if (abortHandler && signal) signal.removeEventListener("abort", abortHandler);
+      throw err;
+    }
+    try {
+      return await promise;
+    } finally {
+      if (abortHandler && signal) signal.removeEventListener("abort", abortHandler);
+    }
+  }
+
+  private startReaderIfNeeded(): void {
+    if (this.readerStarted) return;
+    this.readerStarted = true;
+    // Fire-and-forget: the reader runs for the lifetime of the client.
+    void this.readLoop();
+  }
+
+  private async readLoop(): Promise<void> {
+    try {
+      for await (const msg of this.transport.messages()) {
+        this.dispatch(msg);
+      }
+    } catch (err) {
+      // Surface as rejections on all pending requests so nobody hangs.
+      for (const [, pending] of this.pending) {
+        clearTimeout(pending.timeout);
+        pending.reject(err as Error);
+      }
+      this.pending.clear();
+    }
+  }
+
+  private dispatch(msg: JsonRpcMessage): void {
+    // Notifications (no `id`): route by method. Progress notifications
+    // go to the per-call handler if one was registered; everything
+    // else is dropped silently (we don't yet handle tools/list_changed
+    // or resources/list_changed).
+    if (!("id" in msg) || msg.id === null || msg.id === undefined) {
+      if ("method" in msg && msg.method === "notifications/progress") {
+        const p = msg.params as ProgressNotificationParams | undefined;
+        if (!p || p.progressToken === undefined) return;
+        const handler = this.progressHandlers.get(p.progressToken);
+        if (!handler) return; // late notification after the call resolved
+        handler({ progress: p.progress, total: p.total, message: p.message });
+      }
+      return;
+    }
+    if (!("result" in msg) && !("error" in msg)) return; // it's a request from server
+    const pending = this.pending.get(msg.id);
+    if (!pending) return; // late response after timeout; drop
+    this.pending.delete(msg.id);
+    clearTimeout(pending.timeout);
+    const resp = msg as JsonRpcResponse;
+    if (isJsonRpcError(resp)) {
+      pending.reject(new Error(`MCP ${resp.error.code}: ${resp.error.message}`));
+    } else {
+      pending.resolve(resp.result);
+    }
+  }
+}

src/mcp/inspect.ts

@@ -0,0 +1,71 @@
+/**
+ * Gather a full inspection report from an initialized MCP client:
+ * server info, capabilities, tools, resources, prompts. Methods the
+ * server doesn't support come back as `{ supported: false }` instead
+ * of throwing, so a CLI or UI can render a consistent "what this
+ * server exposes" summary even against minimal implementations.
+ *
+ * Pure with respect to I/O beyond the passed-in client — the CLI
+ * layer owns argument parsing, connection setup, and printing.
+ */
+
+import type { McpClient } from "./client.js";
+import type { McpPrompt, McpResource, McpTool } from "./types.js";
+
+export interface InspectionReport {
+  protocolVersion: string;
+  serverInfo: { name: string; version: string };
+  capabilities: Record<string, unknown>;
+  instructions?: string;
+  tools: SectionResult<McpTool>;
+  resources: SectionResult<McpResource>;
+  prompts: SectionResult<McpPrompt>;
+}
+
+export type SectionResult<T> =
+  | { supported: true; items: T[] }
+  | { supported: false; reason: string };
+
+/**
+ * Run an inspection against a **already-initialized** client. Caller
+ * is responsible for `initialize()` before this and `close()` after.
+ * We keep this pure so unit tests can feed in a FakeMcpTransport and
+ * verify the aggregate shape without spinning up a real process.
+ */
+export async function inspectMcpServer(client: McpClient): Promise<InspectionReport> {
+  // We always *try* the three listings so the client learns whether a
+  // server without explicit capability flags still serves them —
+  // some servers omit capabilities but still respond to the methods.
+  const tools = await trySection<McpTool>(() => client.listTools().then((r) => r.tools));
+  const resources = await trySection<McpResource>(() =>
+    client.listResources().then((r) => r.resources),
+  );
+  const prompts = await trySection<McpPrompt>(() => client.listPrompts().then((r) => r.prompts));
+
+  return {
+    protocolVersion: client.protocolVersion || "(unknown)",
+    serverInfo: client.serverInfo,
+    capabilities: client.serverCapabilities ?? {},
+    instructions: client.serverInstructions,
+    tools,
+    resources,
+    prompts,
+  };
+}
+
+async function trySection<T>(load: () => Promise<T[]>): Promise<SectionResult<T>> {
+  try {
+    const items = await load();
+    return { supported: true, items };
+  } catch (err) {
+    const msg = (err as Error).message ?? String(err);
+    // -32601 is JSON-RPC "method not found" — the canonical response
+    // from a server that doesn't implement this family. Treat it as
+    // "not supported" rather than a hard error, so the CLI can render
+    // a clean summary instead of aborting on the first missing method.
+    if (/-32601/.test(msg) || /method not found/i.test(msg)) {
+      return { supported: false, reason: "method not found (-32601)" };
+    }
+    return { supported: false, reason: msg };
+  }
+}

src/mcp/registry.ts

@@ -0,0 +1,167 @@
+/**
+ * Bridge: register an MCP server's tools into a Reasonix ToolRegistry.
+ *
+ * This is the integration surface. Once done, `CacheFirstLoop` sees the
+ * MCP tools as if they were native — they inherit Cache-First + repair
+ * (scavenge / truncation / storm) automatically. That's the payoff: any
+ * MCP ecosystem tool, wrapped in Reasonix's Pillar 1 + Pillar 3 benefits.
+ */
+
+import { ToolRegistry } from "../tools.js";
+import type { JSONSchema } from "../types.js";
+import type { McpClient } from "./client.js";
+import type { CallToolResult, McpContentBlock } from "./types.js";
+
+export interface BridgeOptions {
+  /**
+   * Prefix prepended to every MCP tool name when registered. Defaults to
+   * empty (no prefix). Useful when bridging multiple servers into one
+   * registry and names collide — e.g. `fs` + `gh` both exposing `search`.
+   */
+  namePrefix?: string;
+  /** Registry to populate. Creates a fresh one if omitted. */
+  registry?: ToolRegistry;
+  /** Auto-flatten deep schemas (Pillar 3). Defaults to the registry's own default (true). */
+  autoFlatten?: boolean;
+  /**
+   * Per-tool-call result cap, in characters. If a tool returns more than
+   * this, the result is truncated and a `[…truncated N chars…]` marker is
+   * appended before the last KB so the model still sees a useful tail.
+   * Defaults to {@link DEFAULT_MAX_RESULT_CHARS}.
+   *
+   * Why this exists: DeepSeek V3's context is 131,072 tokens. A single
+   * `read_file` against a big source file can return >3 MB of text
+   * (~900k tokens) and permanently poison the session — every subsequent
+   * turn rebuilds the history and 400s. This cap is a floor. Users who
+   * legitimately want bigger payloads can raise it explicitly.
+   */
+  maxResultChars?: number;
+  /**
+   * Callback fired for every `notifications/progress` frame the server
+   * emits during any bridged tool call. Includes the registered
+   * (prefix-applied) tool name so a multi-server UI can attribute
+   * progress correctly. Absent → no `_meta.progressToken` is sent and
+   * the server won't emit progress for these calls.
+   */
+  onProgress?: (info: {
+    toolName: string;
+    progress: number;
+    total?: number;
+    message?: string;
+  }) => void;
+}
+
+/**
+ * 32,000 chars ≈ 8k English tokens, or ~16k CJK tokens. Small enough to
+ * fit comfortably in history even across 5–10 tool calls, large enough
+ * that most file reads and directory listings fit un-truncated.
+ */
+export const DEFAULT_MAX_RESULT_CHARS = 32_000;
+
+export interface BridgeResult {
+  registry: ToolRegistry;
+  /** Names actually registered (may differ from MCP names when a prefix is applied). */
+  registeredNames: string[];
+  /** Names the server listed but the bridge skipped (e.g. invalid schemas). */
+  skipped: Array<{ name: string; reason: string }>;
+}
+
+/**
+ * Walk a connected `McpClient`'s tools/list result, register each into a
+ * Reasonix `ToolRegistry`. Each registered `fn` proxies through the
+ * client's tools/call. Tool results are flattened into a string (joining
+ * text blocks with newlines, prefixing image blocks as placeholders) so
+ * they fit Reasonix's existing tool-dispatch contract.
+ */
+export async function bridgeMcpTools(
+  client: McpClient,
+  opts: BridgeOptions = {},
+): Promise<BridgeResult> {
+  const registry = opts.registry ?? new ToolRegistry({ autoFlatten: opts.autoFlatten });
+  const prefix = opts.namePrefix ?? "";
+  const maxResultChars = opts.maxResultChars ?? DEFAULT_MAX_RESULT_CHARS;
+  const result: BridgeResult = { registry, registeredNames: [], skipped: [] };
+
+  const listed = await client.listTools();
+  for (const mcpTool of listed.tools) {
+    if (!mcpTool.name) {
+      result.skipped.push({ name: "?", reason: "empty tool name" });
+      continue;
+    }
+    const registeredName = `${prefix}${mcpTool.name}`;
+    registry.register({
+      name: registeredName,
+      description: mcpTool.description ?? "",
+      parameters: mcpTool.inputSchema as JSONSchema,
+      fn: async (args: Record<string, unknown>, ctx) => {
+        const toolResult = await client.callTool(mcpTool.name, args, {
+          // Forward server-side progress frames to the bridge caller,
+          // tagged with the registered name so multi-server UIs can
+          // disambiguate. No-op when `onProgress` isn't configured —
+          // the client then also omits the _meta.progressToken and
+          // the server won't emit progress.
+          onProgress: opts.onProgress
+            ? (info) => opts.onProgress!({ toolName: registeredName, ...info })
+            : undefined,
+          // Thread the tool-dispatch AbortSignal all the way down to
+          // the MCP request so Esc truly cancels in flight — the
+          // client will emit notifications/cancelled AND reject the
+          // pending promise immediately, no "wait for subprocess".
+          signal: ctx?.signal,
+        });
+        return flattenMcpResult(toolResult, { maxChars: maxResultChars });
+      },
+    });
+    result.registeredNames.push(registeredName);
+  }
+  return result;
+}
+
+export interface FlattenOptions {
+  /** Cap the flattened string at this many characters. Default: no cap. */
+  maxChars?: number;
+}
+
+/**
+ * Turn an MCP CallToolResult into a string — the contract Reasonix's
+ * ToolRegistry.dispatch returns. We:
+ *   - join text blocks with newlines (most common case)
+ *   - stringify image blocks as placeholders (LLM can't use bytes anyway
+ *     in Reasonix's current surface; image support comes with multimodal
+ *     prompts later)
+ *   - prefix error results with "ERROR: " so the calling model sees the
+ *     failure clearly even through JSON mode
+ *   - optionally truncate to `maxChars` so a single oversized tool result
+ *     (e.g. a big `read_file`) can't poison the session by blowing past
+ *     the model's context window
+ */
+export function flattenMcpResult(result: CallToolResult, opts: FlattenOptions = {}): string {
+  const parts = result.content.map(blockToString);
+  const joined = parts.join("\n").trim();
+  const prefixed = result.isError ? `ERROR: ${joined || "(no error message from server)"}` : joined;
+  return opts.maxChars ? truncateForModel(prefixed, opts.maxChars) : prefixed;
+}
+
+/**
+ * Keep the head AND a short tail so the model sees both "what the tool
+ * started returning" and "how it ended". Head-only loses file endings
+ * (e.g. an error message appended at the bottom of a stack trace); the
+ * 1KB tail window covers that while costing almost nothing. Exported for
+ * tests and reuse by non-MCP tool adapters that want the same policy.
+ */
+export function truncateForModel(s: string, maxChars: number): string {
+  if (s.length <= maxChars) return s;
+  const tailBudget = Math.min(1024, Math.floor(maxChars * 0.1));
+  const headBudget = Math.max(0, maxChars - tailBudget);
+  const head = s.slice(0, headBudget);
+  const tail = s.slice(-tailBudget);
+  const dropped = s.length - head.length - tail.length;
+  return `${head}\n\n[…truncated ${dropped} chars — raise BridgeOptions.maxResultChars, or call the tool with a narrower scope (filter, head, pagination)…]\n\n${tail}`;
+}
+
+function blockToString(block: McpContentBlock): string {
+  if (block.type === "text") return block.text;
+  if (block.type === "image") return `[image ${block.mimeType}, ${block.data.length} chars base64]`;
+  // Unknown block type — preserve for diagnostics.
+  return `[unknown block: ${JSON.stringify(block)}]`;
+}

src/mcp/shell-split.ts

@@ -0,0 +1,72 @@
+/**
+ * Split a shell-style command string into argv, respecting single and
+ * double quotes. Intended for parsing the user's `--mcp "cmd args..."`
+ * flag — NOT a full shell parser (no variable expansion, no subshells,
+ * no globs, no `&&` / pipes).
+ *
+ * The tradeoff: users with paths containing spaces need to quote them
+ * (e.g. `--mcp 'npx -y pkg "/my path/here"'`), which is how they'd
+ * already quote them at the shell level.
+ *
+ * Throws on unterminated quotes — better than silently dropping half
+ * the command.
+ */
+export function shellSplit(input: string): string[] {
+  const tokens: string[] = [];
+  let cur = "";
+  let quote: '"' | "'" | null = null;
+  let i = 0;
+  const s = input;
+
+  while (i < s.length) {
+    const ch = s[i]!;
+
+    if (quote) {
+      if (ch === quote) {
+        quote = null;
+        i++;
+        continue;
+      }
+      // backslash escapes inside double quotes only
+      if (ch === "\\" && quote === '"' && i + 1 < s.length) {
+        cur += s[i + 1];
+        i += 2;
+        continue;
+      }
+      cur += ch;
+      i++;
+      continue;
+    }
+
+    if (ch === '"' || ch === "'") {
+      quote = ch as '"' | "'";
+      i++;
+      continue;
+    }
+
+    // Backslash escape ONLY applies inside double quotes (handled above).
+    // Outside quotes, backslashes pass through literally — otherwise
+    // Windows paths like `C:\path\to\exe` get mangled. POSIX users who
+    // want to escape a space outside quotes can use single quotes instead.
+
+    if (ch === " " || ch === "\t") {
+      if (cur.length > 0) {
+        tokens.push(cur);
+        cur = "";
+      }
+      i++;
+      continue;
+    }
+
+    cur += ch;
+    i++;
+  }
+
+  if (quote) {
+    throw new Error(
+      `shellSplit: unterminated ${quote === '"' ? "double" : "single"} quote in input`,
+    );
+  }
+  if (cur.length > 0) tokens.push(cur);
+  return tokens;
+}

src/mcp/spec.ts

@@ -0,0 +1,71 @@
+/**
+ * Parse the `--mcp` CLI argument into a transport-tagged spec.
+ *
+ * Accepted forms:
+ *   "name=command args..."      → stdio, namespaced (tools prefixed with `name_`)
+ *   "command args..."           → stdio, anonymous
+ *   "name=https://host/sse"     → SSE, namespaced
+ *   "https://host/sse"          → SSE, anonymous
+ *   ("http://" is also honored — useful for local dev servers.)
+ *
+ * The identifier regex before `=` is deliberately narrow
+ * (`[a-zA-Z_][a-zA-Z0-9_]*`) so Windows drive letters ("C:\\...") and
+ * other strings containing `=` or `:` don't accidentally trigger the
+ * namespace branch. If a user ever wants their command to literally start
+ * with `foo=...` as a bare command, they can wrap it in quotes inside the
+ * shell command string.
+ *
+ * Transport is selected solely by whether the body begins with `http://`
+ * or `https://`. Anything else is stdio — including ws:// (unsupported)
+ * which will surface later as a spawn error, keeping the rule local.
+ */
+
+import { shellSplit } from "./shell-split.js";
+
+export interface StdioMcpSpec {
+  transport: "stdio";
+  /** Namespace prefix applied to each registered tool, or null if anonymous. */
+  name: string | null;
+  /** Argv[0]. */
+  command: string;
+  /** Remaining argv. */
+  args: string[];
+}
+
+export interface SseMcpSpec {
+  transport: "sse";
+  name: string | null;
+  /** Fully qualified SSE endpoint URL. */
+  url: string;
+}
+
+export type McpSpec = StdioMcpSpec | SseMcpSpec;
+
+const NAME_PREFIX = /^([a-zA-Z_][a-zA-Z0-9_]*)=(.*)$/;
+const HTTP_URL = /^https?:\/\//i;
+
+export function parseMcpSpec(input: string): McpSpec {
+  const trimmed = input.trim();
+  if (!trimmed) {
+    throw new Error("empty MCP spec");
+  }
+
+  const nameMatch = NAME_PREFIX.exec(trimmed);
+  const name = nameMatch ? nameMatch[1]! : null;
+  const body = (nameMatch ? nameMatch[2]! : trimmed).trim();
+
+  if (!body) {
+    throw new Error(`MCP spec has name but no command: ${input}`);
+  }
+
+  if (HTTP_URL.test(body)) {
+    return { transport: "sse", name, url: body };
+  }
+
+  const argv = shellSplit(body);
+  if (argv.length === 0) {
+    throw new Error(`MCP spec has name but no command: ${input}`);
+  }
+  const [command, ...args] = argv;
+  return { transport: "stdio", name, command: command!, args };
+}

src/mcp/sse.ts

@@ -0,0 +1,194 @@
+/**
+ * HTTP+SSE transport for MCP (spec version 2024-11-05).
+ *
+ * Wire shape:
+ *   1. Client opens GET to the SSE URL with `Accept: text/event-stream`.
+ *   2. Server's first SSE event is `event: endpoint`, `data: <url>` — the
+ *      URL (relative or absolute) the client must POST JSON-RPC requests
+ *      to. All subsequent server → client messages arrive as `event: message`
+ *      SSE frames carrying a JSON-RPC response or server-initiated frame.
+ *   3. Client POSTs each outgoing JSON-RPC frame to the endpoint URL.
+ *      The POST response body is ignored — replies land on the SSE stream.
+ *
+ * This transport exists so Reasonix can talk to hosted/remote MCP servers
+ * (e.g. a company's internal knowledge server fronted by auth). Stdio
+ * covers local subprocesses; SSE covers everything else.
+ *
+ * Note: the newer "Streamable HTTP" transport (2025 spec) folds the POST
+ * and SSE streams onto a single endpoint. We stay on 2024-11-05 here —
+ * that's what `MCP_PROTOCOL_VERSION` advertises in the initialize handshake
+ * and what currently-published servers implement.
+ */
+
+import { createParser } from "eventsource-parser";
+import type { McpTransport } from "./stdio.js";
+import type { JsonRpcMessage } from "./types.js";
+
+export interface SseTransportOptions {
+  /** SSE endpoint URL, e.g. `https://mcp.example.com/sse`. */
+  url: string;
+  /** Extra headers sent on both the SSE GET and the JSON-RPC POSTs (e.g. `Authorization`). */
+  headers?: Record<string, string>;
+}
+
+/**
+ * Open an SSE stream to `url`, parse incoming events into JsonRpcMessages,
+ * POST outgoing frames to the endpoint URL the server advertises.
+ */
+export class SseTransport implements McpTransport {
+  private readonly url: string;
+  private readonly headers: Record<string, string>;
+  private readonly queue: JsonRpcMessage[] = [];
+  private readonly waiters: Array<(m: JsonRpcMessage | null) => void> = [];
+  private readonly controller = new AbortController();
+  private closed = false;
+  private postUrl: string | null = null;
+  private readonly endpointReady: Promise<string>;
+  private resolveEndpoint!: (url: string) => void;
+  private rejectEndpoint!: (err: Error) => void;
+
+  constructor(opts: SseTransportOptions) {
+    this.url = opts.url;
+    this.headers = opts.headers ?? {};
+    this.endpointReady = new Promise<string>((resolve, reject) => {
+      this.resolveEndpoint = resolve;
+      this.rejectEndpoint = reject;
+    });
+    // Swallow unhandled-rejection noise if nobody ever calls send().
+    this.endpointReady.catch(() => undefined);
+    void this.runStream();
+  }
+
+  async send(message: JsonRpcMessage): Promise<void> {
+    if (this.closed) throw new Error("MCP SSE transport is closed");
+    const postUrl = await this.endpointReady;
+    const res = await fetch(postUrl, {
+      method: "POST",
+      headers: { "content-type": "application/json", ...this.headers },
+      body: JSON.stringify(message),
+      signal: this.controller.signal,
+    });
+    // Drain body so the socket returns to the pool even if the server
+    // elected to write one. We explicitly don't parse it — responses
+    // arrive on the SSE channel.
+    await res.arrayBuffer().catch(() => undefined);
+    if (!res.ok) {
+      throw new Error(`MCP SSE POST ${postUrl} failed: ${res.status} ${res.statusText}`);
+    }
+  }
+
+  async *messages(): AsyncIterableIterator<JsonRpcMessage> {
+    while (true) {
+      if (this.queue.length > 0) {
+        yield this.queue.shift()!;
+        continue;
+      }
+      if (this.closed) return;
+      const next = await new Promise<JsonRpcMessage | null>((resolve) => {
+        this.waiters.push(resolve);
+      });
+      if (next === null) return;
+      yield next;
+    }
+  }
+
+  async close(): Promise<void> {
+    if (this.closed) return;
+    this.closed = true;
+    while (this.waiters.length > 0) this.waiters.shift()!(null);
+    // Reject any still-pending send() that was waiting for the endpoint.
+    this.rejectEndpoint(new Error("MCP SSE transport closed before endpoint was ready"));
+    try {
+      this.controller.abort();
+    } catch {
+      /* already aborted */
+    }
+  }
+
+  // ---------- internals ----------
+
+  private async runStream(): Promise<void> {
+    let res: Response;
+    try {
+      res = await fetch(this.url, {
+        method: "GET",
+        headers: { accept: "text/event-stream", ...this.headers },
+        signal: this.controller.signal,
+      });
+    } catch (err) {
+      this.failHandshake(`SSE connect to ${this.url} failed: ${(err as Error).message}`);
+      return;
+    }
+    if (!res.ok || !res.body) {
+      // Drain body to free the socket before giving up.
+      await res.body?.cancel().catch(() => undefined);
+      this.failHandshake(`SSE handshake ${this.url} → ${res.status} ${res.statusText}`);
+      return;
+    }
+
+    const parser = createParser({
+      onEvent: (ev) => this.handleEvent(ev.event ?? "message", ev.data),
+    });
+    const decoder = new TextDecoder();
+    try {
+      for await (const chunk of res.body as AsyncIterable<Uint8Array>) {
+        parser.feed(decoder.decode(chunk, { stream: true }));
+      }
+    } catch (err) {
+      if (!this.closed) {
+        this.pushError(`SSE stream error: ${(err as Error).message}`);
+      }
+    } finally {
+      this.markClosed();
+    }
+  }
+
+  private handleEvent(type: string, data: string): void {
+    if (type === "endpoint") {
+      if (this.postUrl) return; // ignore repeat announcements
+      try {
+        this.postUrl = new URL(data, this.url).toString();
+        this.resolveEndpoint(this.postUrl);
+      } catch (err) {
+        this.failHandshake(`SSE endpoint event had bad URL "${data}": ${(err as Error).message}`);
+      }
+      return;
+    }
+    if (type === "message") {
+      try {
+        const parsed = JSON.parse(data) as JsonRpcMessage;
+        this.pushMessage(parsed);
+      } catch {
+        // Malformed JSON-RPC on an SSE frame — drop it, same as stdio.
+      }
+      return;
+    }
+    // Unknown event types (server pings, custom extensions) — ignore.
+  }
+
+  private failHandshake(reason: string): void {
+    this.rejectEndpoint(new Error(reason));
+    this.pushError(reason);
+    this.markClosed();
+  }
+
+  private pushMessage(msg: JsonRpcMessage): void {
+    const waiter = this.waiters.shift();
+    if (waiter) waiter(msg);
+    else this.queue.push(msg);
+  }
+
+  private pushError(message: string): void {
+    this.pushMessage({
+      jsonrpc: "2.0",
+      id: null,
+      error: { code: -32000, message },
+    });
+  }
+
+  private markClosed(): void {
+    if (this.closed) return;
+    this.closed = true;
+    while (this.waiters.length > 0) this.waiters.shift()!(null);
+  }
+}

src/mcp/stdio.ts

@@ -0,0 +1,193 @@
+/**
+ * Stdio transport for MCP.
+ *
+ * MCP's stdio wire format is **newline-delimited JSON** (one JSON-RPC
+ * message per line). We spawn the server as a child process, write
+ * frames to its stdin, parse its stdout line-by-line as they arrive.
+ *
+ * Transport is abstracted behind an interface so unit tests can fake it
+ * with an in-process duplex pair — spawning real servers in unit tests
+ * is flaky and slow.
+ */
+
+import { type ChildProcess, spawn } from "node:child_process";
+import type { JsonRpcMessage } from "./types.js";
+
+/**
+ * A transport sends JSON-RPC messages upstream and surfaces messages
+ * arriving downstream via an async iterator. One instance per server
+ * connection.
+ */
+export interface McpTransport {
+  /** Send one JSON-RPC message. Resolves when the bytes are accepted. */
+  send(message: JsonRpcMessage): Promise<void>;
+  /** Async iterator over incoming messages. Ends when the connection closes. */
+  messages(): AsyncIterableIterator<JsonRpcMessage>;
+  /** Close the underlying resource (kill child process, close streams). */
+  close(): Promise<void>;
+}
+
+export interface StdioTransportOptions {
+  /** Argv to spawn. First element is the command. */
+  command: string;
+  args?: string[];
+  /** Env overlay — merged over process.env unless replaceEnv=true. */
+  env?: Record<string, string>;
+  /** When true, only the env above is visible to the child. Default false. */
+  replaceEnv?: boolean;
+  /** CWD for the child. Default: process.cwd(). */
+  cwd?: string;
+  /**
+   * Spawn through a shell. Default: true on win32 (needed to resolve
+   * `.cmd` wrappers like `npx.cmd`, `pnpm.cmd`), false elsewhere.
+   * Explicitly pass `false` to opt out on Windows; pass `true` to force
+   * it on POSIX (rarely needed).
+   */
+  shell?: boolean;
+}
+
+/**
+ * Spawn `command args...` as a child process and use its stdin/stdout as
+ * an MCP transport. Stderr is forwarded to the parent's stderr so server
+ * diagnostics are still visible.
+ */
+export class StdioTransport implements McpTransport {
+  private readonly child: ChildProcess;
+  private readonly queue: JsonRpcMessage[] = [];
+  private readonly waiters: Array<(m: JsonRpcMessage | null) => void> = [];
+  private closed = false;
+  private stdoutBuffer = "";
+
+  constructor(opts: StdioTransportOptions) {
+    const env = opts.replaceEnv ? { ...(opts.env ?? {}) } : { ...process.env, ...(opts.env ?? {}) };
+    // Windows wraps binaries as .cmd/.bat shims (npx.cmd, pnpm.cmd, …).
+    // child_process.spawn without shell:true can't resolve them, which
+    // breaks `--mcp "npx -y some-server"` — the most common MCP setup.
+    // Default shell:true on win32 and leave POSIX alone.
+    const shell = opts.shell ?? process.platform === "win32";
+
+    if (shell) {
+      // Node's shell:true + args[] triggers DEP0190 because it concatenates
+      // with spaces and doesn't quote args — unsafe if an arg contains
+      // shell metacharacters. We build a single command line ourselves,
+      // quoting ONLY the args (command stays bare so the shell's PATH /
+      // PATHEXT lookup finds `npx` → `npx.cmd` on Windows).
+      const line = [
+        opts.command,
+        ...(opts.args ?? []).map((a) => quoteArg(a, process.platform === "win32")),
+      ].join(" ");
+      this.child = spawn(line, [], {
+        env,
+        cwd: opts.cwd,
+        stdio: ["pipe", "pipe", "inherit"],
+        shell: true,
+      });
+    } else {
+      this.child = spawn(opts.command, opts.args ?? [], {
+        env,
+        cwd: opts.cwd,
+        stdio: ["pipe", "pipe", "inherit"],
+      });
+    }
+    this.child.stdout!.setEncoding("utf8");
+    this.child.stdout!.on("data", (chunk: string) => this.onStdout(chunk));
+    this.child.on("close", () => this.onClose());
+    this.child.on("error", (err) => {
+      // Surface spawn errors as a synthetic JsonRpcError so callers don't
+      // hang on a stream that never emits anything.
+      this.push({
+        jsonrpc: "2.0",
+        id: null,
+        error: { code: -32000, message: `transport error: ${err.message}` },
+      });
+    });
+  }
+
+  async send(message: JsonRpcMessage): Promise<void> {
+    if (this.closed) throw new Error("MCP transport is closed");
+    return new Promise((resolve, reject) => {
+      const line = `${JSON.stringify(message)}\n`;
+      this.child.stdin!.write(line, "utf8", (err) => {
+        if (err) reject(err);
+        else resolve();
+      });
+    });
+  }
+
+  async *messages(): AsyncIterableIterator<JsonRpcMessage> {
+    while (true) {
+      if (this.queue.length > 0) {
+        yield this.queue.shift()!;
+        continue;
+      }
+      if (this.closed) return;
+      const next = await new Promise<JsonRpcMessage | null>((resolve) => {
+        this.waiters.push(resolve);
+      });
+      if (next === null) return; // closed while we were waiting
+      yield next;
+    }
+  }
+
+  async close(): Promise<void> {
+    if (this.closed) return;
+    this.closed = true;
+    // Signal any pending waiters.
+    while (this.waiters.length > 0) this.waiters.shift()!(null);
+    try {
+      this.child.stdin!.end();
+    } catch {
+      /* already ended */
+    }
+    if (this.child.exitCode === null && !this.child.killed) {
+      this.child.kill("SIGTERM");
+    }
+  }
+
+  /** Parse incoming stdout chunks into NDJSON messages. */
+  private onStdout(chunk: string): void {
+    this.stdoutBuffer += chunk;
+    let newlineIdx: number;
+    // biome-ignore lint/suspicious/noAssignInExpressions: idiomatic loop shape
+    while ((newlineIdx = this.stdoutBuffer.indexOf("\n")) !== -1) {
+      const line = this.stdoutBuffer.slice(0, newlineIdx).trim();
+      this.stdoutBuffer = this.stdoutBuffer.slice(newlineIdx + 1);
+      if (!line) continue;
+      try {
+        const msg = JSON.parse(line) as JsonRpcMessage;
+        this.push(msg);
+      } catch {
+        // Malformed lines are dropped — some servers emit startup banners
+        // before the JSON-RPC loop begins. We surface the noise to stderr
+        // via the inherited stderr stream, not our event queue.
+      }
+    }
+  }
+
+  private onClose(): void {
+    this.closed = true;
+    while (this.waiters.length > 0) this.waiters.shift()!(null);
+  }
+
+  private push(msg: JsonRpcMessage): void {
+    const waiter = this.waiters.shift();
+    if (waiter) waiter(msg);
+    else this.queue.push(msg);
+  }
+}
+
+/**
+ * Quote a single argument for inclusion in a shell command line.
+ * On Windows (cmd.exe): wrap in double quotes, escape internal `"` as `""`,
+ * leave everything else alone. On POSIX: wrap in single quotes, escape
+ * internal `'` as `'\''`. Both handle spaces, wildcards, pipes, and all
+ * other metacharacters correctly.
+ */
+function quoteArg(s: string, windows: boolean): string {
+  if (!windows) {
+    // POSIX: single-quote, escape single quotes.
+    return `'${s.replace(/'/g, "'\\''")}'`;
+  }
+  // cmd.exe: double-quote, escape internal quotes by doubling.
+  return `"${s.replace(/"/g, '""')}"`;
+}

src/mcp/types.ts

@@ -0,0 +1,285 @@
+/**
+ * MCP (Model Context Protocol) type definitions.
+ *
+ * Hand-rolled rather than importing @modelcontextprotocol/sdk because:
+ *   - Reasonix's value-add isn't reimplementing the protocol, but *caching*
+ *     it. Owning the types lets us tune them for our integration (strip
+ *     fields we don't use, add the ones we do like Reasonix's prefixHash).
+ *   - Zero dependencies — consistent with how we wrote the DeepSeek client.
+ *   - If Anthropic bumps the SDK and introduces a breaking change, we're
+ *     insulated as long as we keep up with the spec itself.
+ *
+ * Spec reference: https://spec.modelcontextprotocol.io/ (2024-11-05 draft
+ * at time of writing). Reasonix models the subset it consumes: tools
+ * list/call, resources list/read, prompts list/get, plus the init
+ * handshake. Sampling and progress notifications remain deferred.
+ *
+ * Transport note: the wire format for stdio MCP is **newline-delimited
+ * JSON** (NDJSON), not the LSP-style Content-Length header framing that
+ * some readers might expect. One JSON-RPC message per line.
+ */
+
+// ---------- JSON-RPC 2.0 base ----------
+
+export type JsonRpcId = string | number;
+
+export interface JsonRpcRequest<P = unknown> {
+  jsonrpc: "2.0";
+  id: JsonRpcId;
+  method: string;
+  params?: P;
+}
+
+export interface JsonRpcNotification<P = unknown> {
+  jsonrpc: "2.0";
+  method: string;
+  params?: P;
+}
+
+export interface JsonRpcSuccess<R = unknown> {
+  jsonrpc: "2.0";
+  id: JsonRpcId;
+  result: R;
+}
+
+export interface JsonRpcError {
+  jsonrpc: "2.0";
+  id: JsonRpcId | null;
+  error: {
+    /** JSON-RPC standard codes: -32700 parse, -32600 invalid request, -32601 method not found, -32602 invalid params, -32603 internal. MCP also defines its own range. */
+    code: number;
+    message: string;
+    data?: unknown;
+  };
+}
+
+export type JsonRpcResponse<R = unknown> = JsonRpcSuccess<R> | JsonRpcError;
+
+export type JsonRpcMessage = JsonRpcRequest | JsonRpcNotification | JsonRpcSuccess | JsonRpcError;
+
+// ---------- MCP initialize ----------
+
+export interface McpClientInfo {
+  name: string;
+  version: string;
+}
+
+export interface McpClientCapabilities {
+  /** Empty object advertises support without any optional sub-features. */
+  tools?: Record<string, never>;
+  /** Advertised when the client can consume `resources/list` + `resources/read`. */
+  resources?: Record<string, never>;
+  /** Advertised when the client can consume `prompts/list` + `prompts/get`. */
+  prompts?: Record<string, never>;
+  // sampling would go here — deferred.
+}
+
+export interface InitializeParams {
+  protocolVersion: string;
+  capabilities: McpClientCapabilities;
+  clientInfo: McpClientInfo;
+}
+
+export interface InitializeResult {
+  protocolVersion: string;
+  serverInfo: { name: string; version: string };
+  capabilities: {
+    tools?: { listChanged?: boolean };
+    resources?: unknown;
+    prompts?: unknown;
+  };
+  instructions?: string;
+}
+
+// ---------- MCP tools ----------
+
+export interface McpToolSchema {
+  /** JSON Schema — compatible with Reasonix's tools.ts JSONSchema shape. */
+  type?: string;
+  properties?: Record<string, unknown>;
+  required?: string[];
+  [extra: string]: unknown;
+}
+
+export interface McpTool {
+  name: string;
+  description?: string;
+  /** MCP calls this `inputSchema`. Reasonix's `parameters` field is the same concept. */
+  inputSchema: McpToolSchema;
+}
+
+export interface ListToolsResult {
+  tools: McpTool[];
+  nextCursor?: string;
+}
+
+export interface CallToolParams {
+  name: string;
+  arguments?: Record<string, unknown>;
+  /**
+   * MCP's `_meta` envelope carries out-of-band protocol metadata.
+   * Setting `progressToken` here tells the server "send me progress
+   * notifications back using this token"; the server must then emit
+   * `notifications/progress` frames until the response arrives.
+   */
+  _meta?: { progressToken?: string | number };
+}
+
+/**
+ * Server → client notification emitted during a long-running request
+ * that the client subscribed to via `_meta.progressToken`. `progress`
+ * and `total` are typically matched units (files scanned, bytes
+ * processed, etc.); `total` may be missing when the server can't
+ * estimate the upper bound up front.
+ */
+export interface ProgressNotificationParams {
+  progressToken: string | number;
+  progress: number;
+  total?: number;
+  message?: string;
+}
+
+/** Values a `ProgressHandler` receives — `progressToken` is already matched away. */
+export interface McpProgressInfo {
+  progress: number;
+  total?: number;
+  message?: string;
+}
+
+export type McpProgressHandler = (info: McpProgressInfo) => void;
+
+export interface McpContentBlockText {
+  type: "text";
+  text: string;
+}
+
+export interface McpContentBlockImage {
+  type: "image";
+  data: string;
+  mimeType: string;
+}
+
+/** MCP result content is an array of typed blocks. Reasonix consumes only text for now — image blocks get stringified with a placeholder. */
+export type McpContentBlock = McpContentBlockText | McpContentBlockImage;
+
+export interface CallToolResult {
+  content: McpContentBlock[];
+  /** True = tool raised an error; the content describes it. */
+  isError?: boolean;
+}
+
+// ---------- MCP resources ----------
+
+/**
+ * A resource the server can expose — think "file the model can read."
+ * The URI is opaque to the client: servers may use `file://`, custom
+ * schemes, or bare strings. Reasonix doesn't interpret them.
+ */
+export interface McpResource {
+  uri: string;
+  name: string;
+  description?: string;
+  /** Hint for the content type (e.g. "text/markdown"). Purely informational. */
+  mimeType?: string;
+}
+
+export interface ListResourcesParams {
+  /** Pagination cursor from a previous listResources response. */
+  cursor?: string;
+}
+
+export interface ListResourcesResult {
+  resources: McpResource[];
+  nextCursor?: string;
+}
+
+export interface ReadResourceParams {
+  uri: string;
+}
+
+/**
+ * One resource can return multiple content blobs (e.g. the file + a
+ * side-car). `text` is the common case for UTF-8 content; `blob` is
+ * base64-encoded bytes for binary content. Servers populate exactly
+ * one of the two for each entry.
+ */
+export interface McpResourceContentsText {
+  uri: string;
+  mimeType?: string;
+  text: string;
+}
+
+export interface McpResourceContentsBlob {
+  uri: string;
+  mimeType?: string;
+  blob: string;
+}
+
+export type McpResourceContents = McpResourceContentsText | McpResourceContentsBlob;
+
+export interface ReadResourceResult {
+  contents: McpResourceContents[];
+}
+
+// ---------- MCP prompts ----------
+
+/**
+ * A parameterizable prompt template the server exposes. Clients fetch
+ * it with `prompts/get` and pass the result to the model as-is.
+ */
+export interface McpPromptArgument {
+  name: string;
+  description?: string;
+  required?: boolean;
+}
+
+export interface McpPrompt {
+  name: string;
+  description?: string;
+  arguments?: McpPromptArgument[];
+}
+
+export interface ListPromptsParams {
+  cursor?: string;
+}
+
+export interface ListPromptsResult {
+  prompts: McpPrompt[];
+  nextCursor?: string;
+}
+
+export interface GetPromptParams {
+  name: string;
+  arguments?: Record<string, string>;
+}
+
+/**
+ * MCP prompt messages are modeled after chat completions: role + content.
+ * Content can be a text block OR (per the spec) a resource/image block;
+ * Reasonix cares about text in v1, but surfaces the raw array so callers
+ * can render other kinds if they need to.
+ */
+export interface McpPromptMessage {
+  role: "user" | "assistant";
+  content: McpContentBlock | McpPromptResourceBlock;
+}
+
+export interface McpPromptResourceBlock {
+  type: "resource";
+  resource: McpResourceContents;
+}
+
+export interface GetPromptResult {
+  description?: string;
+  messages: McpPromptMessage[];
+}
+
+// ---------- convenience ----------
+
+/** Current MCP protocol version Reasonix is coded against. */
+export const MCP_PROTOCOL_VERSION = "2024-11-05";
+
+/** Type guard — success vs error response. */
+export function isJsonRpcError(msg: JsonRpcResponse): msg is JsonRpcError {
+  return "error" in msg;
+}

src/memory.ts

@@ -50,6 +50,17 @@ export class AppendOnlyLog {
     for (const m of messages) this.append(m);
   }
 
+  /**
+   * Bulk-replace entries. Intentionally named to be hard to reach for —
+   * this is the one mutation path that breaks the log's append-only
+   * spirit, reserved for compaction flows (`/compact`) and recovery
+   * where the caller has consciously decided to drop old history. Any
+   * other use is almost certainly wrong; append() is what you want.
+   */
+  compactInPlace(replacement: ChatMessage[]): void {
+    this._entries = [...replacement];
+  }
+
   get entries(): readonly ChatMessage[] {
     return this._entries;
   }

src/project-memory.ts

@@ -0,0 +1,99 @@
+/**
+ * Project memory — a user-authored `REASONIX.md` in the project root
+ * that gets pinned into the immutable-prefix system prompt.
+ *
+ * Design notes:
+ *
+ *   - The file lands in `ImmutablePrefix.system`, so the whole memory
+ *     block is hashed into the cache prefix fingerprint. Editing the
+ *     file invalidates the prefix; unchanged memory across sessions
+ *     keeps the DeepSeek prefix cache warm. That matches Pillar 1 —
+ *     memory is a deliberate, stable prefix, not per-turn drift.
+ *   - Only one source: the working-root `REASONIX.md`. No parent walk,
+ *     no `~/.reasonix/REASONIX.md`, no CLAUDE.md fallback. User-global
+ *     memory can come later; for v1 one file == one mental model.
+ *   - Truncated at 8 000 chars (≈ 2k tokens). `.gitignore` gets 2 000
+ *     because it's a constraint dump; memory gets more headroom because
+ *     it's deliberate instructions.
+ *   - Opt-out via `REASONIX_MEMORY=off|false|0`. No CLI flag — memory
+ *     is a file, `rm REASONIX.md` is the other opt-out.
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+export const PROJECT_MEMORY_FILE = "REASONIX.md";
+export const PROJECT_MEMORY_MAX_CHARS = 8000;
+
+export interface ProjectMemory {
+  /** Absolute path the memory was read from. */
+  path: string;
+  /** Post-truncation content (may include a "… (truncated N chars)" marker). */
+  content: string;
+  /** Original byte length before truncation. */
+  originalChars: number;
+  /** True iff `originalChars > PROJECT_MEMORY_MAX_CHARS`. */
+  truncated: boolean;
+}
+
+/**
+ * Read `REASONIX.md` from `rootDir`. Returns `null` when the file is
+ * missing, unreadable, or empty (whitespace-only counts as empty — an
+ * empty memory file shouldn't perturb the cache prefix).
+ */
+export function readProjectMemory(rootDir: string): ProjectMemory | null {
+  const path = join(rootDir, PROJECT_MEMORY_FILE);
+  if (!existsSync(path)) return null;
+  let raw: string;
+  try {
+    raw = readFileSync(path, "utf8");
+  } catch {
+    return null;
+  }
+  const trimmed = raw.trim();
+  if (!trimmed) return null;
+  const originalChars = trimmed.length;
+  const truncated = originalChars > PROJECT_MEMORY_MAX_CHARS;
+  const content = truncated
+    ? `${trimmed.slice(0, PROJECT_MEMORY_MAX_CHARS)}\n… (truncated ${
+        originalChars - PROJECT_MEMORY_MAX_CHARS
+      } chars)`
+    : trimmed;
+  return { path, content, originalChars, truncated };
+}
+
+/**
+ * Resolve whether project memory should be read. Default: on.
+ * `REASONIX_MEMORY=off|false|0` turns it off (CI, reproducing issues,
+ * intentional offline runs).
+ */
+export function memoryEnabled(): boolean {
+  const env = process.env.REASONIX_MEMORY;
+  if (env === "off" || env === "false" || env === "0") return false;
+  return true;
+}
+
+/**
+ * Return `basePrompt` with the project's `REASONIX.md` appended as a
+ * "Project memory" section. No-op when the file is absent, empty, or
+ * memory is disabled via env.
+ *
+ * The appended block is deterministic — identical input ⇒ identical
+ * output — so every session that opens against the same memory file
+ * gets the same prefix hash.
+ */
+export function applyProjectMemory(basePrompt: string, rootDir: string): string {
+  if (!memoryEnabled()) return basePrompt;
+  const mem = readProjectMemory(rootDir);
+  if (!mem) return basePrompt;
+  return `${basePrompt}
+
+# Project memory (REASONIX.md)
+
+The user pinned these notes about this project — treat them as authoritative context for every turn:
+
+\`\`\`
+${mem.content}
+\`\`\`
+`;
+}

src/repair/index.ts

@@ -46,9 +46,21 @@ export class ToolCallRepair {
     this.storm = new StormBreaker(opts.stormWindow ?? 6, opts.stormThreshold ?? 3);
   }
 
+  /**
+   * Drop the StormBreaker's sliding window of recent (name, args)
+   * signatures. Called at the start of every user turn — a fresh user
+   * message is a new intent, so carrying old repetition state into it
+   * would turn a valid "try again with different input" flow into a
+   * false-positive block.
+   */
+  resetStorm(): void {
+    this.storm.reset();
+  }
+
   process(
     declaredCalls: ToolCall[],
     reasoningContent: string | null,
+    content: string | null = null,
   ): { calls: ToolCall[]; report: RepairReport } {
     const report: RepairReport = {
       scavenged: 0,
@@ -58,7 +70,13 @@ export class ToolCallRepair {
     };
 
     // 1. Scavenge — only add calls whose (name,args) signature is novel.
-    const scavenged = scavengeToolCalls(reasoningContent, {
+    // Scan both channels: reasoning (where R1 leaks JSON calls into
+    // <think>) AND content (where it emits DSML markup in regular
+    // turns). Joined with a newline so the scanners see the blobs as
+    // independent bodies. Dedup below keeps us from inflating if the
+    // same call shows up in both — first seen wins.
+    const combined = [reasoningContent ?? "", content ?? ""].filter(Boolean).join("\n");
+    const scavenged = scavengeToolCalls(combined || null, {
       allowedNames: this.opts.allowedToolNames,
       maxCalls: this.opts.maxScavenge ?? 4,
     });

src/repair/scavenge.ts

@@ -30,7 +30,28 @@ export function scavengeToolCalls(
   const notes: string[] = [];
   const out: ToolCall[] = [];
 
-  for (const candidate of iterateJsonObjects(reasoningContent)) {
+  // Pattern A: DSML invoke blocks. R1 sometimes emits tool calls as
+  // its chat-template markup in the content channel instead of the
+  // proper `tool_calls` field. 0.4.3 stripped these from display;
+  // here we actually turn them back into proper ToolCalls so the
+  // model's intent isn't lost.
+  for (const invoke of iterateDsmlInvokes(reasoningContent)) {
+    if (out.length >= max) break;
+    if (!opts.allowedNames.has(invoke.name)) continue;
+    out.push({
+      function: {
+        name: invoke.name,
+        arguments: JSON.stringify(invoke.args),
+      },
+    });
+    notes.push(`scavenged DSML call: ${invoke.name}`);
+  }
+
+  // Pattern B: raw JSON objects (the original three shapes). Strip
+  // any DSML blocks we already processed so parameter JSON buried
+  // inside them doesn't get re-scavenged as a standalone call.
+  const nonDsml = stripDsmlBlocks(reasoningContent);
+  for (const candidate of iterateJsonObjects(nonDsml)) {
     if (out.length >= max) break;
     const call = coerceToToolCall(candidate, opts.allowedNames);
     if (call) {
@@ -41,6 +62,85 @@ export function scavengeToolCalls(
   return { calls: out, notes };
 }
 
+interface DsmlInvoke {
+  name: string;
+  args: Record<string, unknown>;
+}
+
+/**
+ * Yield DeepSeek DSML invoke blocks scavenged from text. R1's chat
+ * template uses these when the server-side tool-call serializer
+ * misfires — we see them verbatim in the content channel:
+ *
+ *   <｜DSML｜function_calls>
+ *     <｜DSML｜invoke name="filesystem_edit_file">
+ *       <｜DSML｜parameter name="path" string="true">F:/x.html</｜DSML｜parameter>
+ *       <｜DSML｜parameter name="edits" string="false">[…]</｜DSML｜parameter>
+ *     </｜DSML｜invoke>
+ *   </｜DSML｜function_calls>
+ *
+ * The wrapper class (｜ U+FF5C vs ASCII |) varies by model build, so
+ * we accept both. `string="true"` means the parameter value is a
+ * literal string; `string="false"` means it's JSON.
+ */
+/**
+ * Remove DSML invoke/function_calls blocks from text so the raw-JSON
+ * scanner below doesn't see parameter payloads as standalone calls.
+ * Mirrors the strip pass in `stripHallucinatedToolMarkup` but scoped
+ * to scavenge (we also want the `function_calls` wrapper gone —
+ * nothing useful to scavenge there).
+ */
+function stripDsmlBlocks(text: string): string {
+  let out = text;
+  out = out.replace(/<[｜|]DSML[｜|]function_calls>[\s\S]*?<\/?[｜|]DSML[｜|]function_calls>/g, "");
+  out = out.replace(/<[｜|]DSML[｜|]invoke\s+[^>]*>[\s\S]*?<\/[｜|]DSML[｜|]invoke>/g, "");
+  return out;
+}
+
+function* iterateDsmlInvokes(text: string): Generator<DsmlInvoke> {
+  // `｜` (U+FF5C) in practice; `|` (ASCII) as a fallback seen in a
+  // minority of builds. `[｜|]` inside the regex covers both.
+  const INVOKE_RE = /<[｜|]DSML[｜|]invoke\s+name="([^"]+)">([\s\S]*?)<\/[｜|]DSML[｜|]invoke>/g;
+  for (const match of text.matchAll(INVOKE_RE)) {
+    const name = match[1];
+    const body = match[2];
+    if (!name || body === undefined) continue;
+    yield { name, args: parseDsmlParameters(body) };
+  }
+}
+
+/**
+ * Parse the parameter children of a DSML invoke body into a plain
+ * object. We tolerate:
+ *   - `string="true"` → literal text; whitespace trimmed at the edges.
+ *   - `string="false"` → JSON-parsed; falls back to literal text if the
+ *     payload turns out to be malformed (better to hand a string
+ *     through than lose the parameter entirely).
+ *   - no `string="…"` attribute → treat as literal text (older/shorter
+ *     DSML shapes we haven't formally seen but want to handle).
+ */
+function parseDsmlParameters(body: string): Record<string, unknown> {
+  const PARAM_RE =
+    /<[｜|]DSML[｜|]parameter\s+name="([^"]+)"(?:\s+string="(true|false)")?\s*>([\s\S]*?)<\/[｜|]DSML[｜|]parameter>/g;
+  const args: Record<string, unknown> = {};
+  for (const m of body.matchAll(PARAM_RE)) {
+    const key = m[1];
+    const stringFlag = m[2];
+    const raw = (m[3] ?? "").trim();
+    if (!key) continue;
+    if (stringFlag === "false") {
+      try {
+        args[key] = JSON.parse(raw);
+        continue;
+      } catch {
+        // Fall through — keep as literal so the information isn't lost.
+      }
+    }
+    args[key] = raw;
+  }
+  return args;
+}
+
 /** Yield every top-level JSON object substring in `text`. */
 function* iterateJsonObjects(text: string): Generator<string> {
   for (let i = 0; i < text.length; i++) {

src/replay.ts

@@ -10,7 +10,14 @@
  */
 
 import { Usage } from "./client.js";
-import { type SessionSummary, type TurnStats, claudeEquivalentCost, costUsd } from "./telemetry.js";
+import {
+  type SessionSummary,
+  type TurnStats,
+  claudeEquivalentCost,
+  costUsd,
+  inputCostUsd,
+  outputCostUsd,
+} from "./telemetry.js";
 import { type ReadTranscriptResult, type TranscriptRecord, readTranscript } from "./transcript.js";
 
 /**
@@ -67,6 +74,12 @@ export interface ReplayStats extends SessionSummary {
   userTurns: number;
   /** Count of tool-role records (tool calls executed). */
   toolCalls: number;
+  /** Count of assistant_final records that carry a non-empty planState (harvest signal). */
+  harvestedTurns: number;
+  /** Sum of uncertainties across all harvested turns — a proxy for "how much did R1 hedge?" */
+  totalUncertainties: number;
+  /** Sum of subgoals across all harvested turns. */
+  totalSubgoals: number;
 }
 
 /**
@@ -84,6 +97,9 @@ export function computeReplayStats(records: TranscriptRecord[]): ReplayStats {
   const prefixHashes = new Set<string>();
   let userTurns = 0;
   let toolCalls = 0;
+  let harvestedTurns = 0;
+  let totalUncertainties = 0;
+  let totalSubgoals = 0;
 
   for (const rec of records) {
     if (rec.role === "user") userTurns++;
@@ -91,6 +107,11 @@ export function computeReplayStats(records: TranscriptRecord[]): ReplayStats {
     else if (rec.role === "assistant_final") {
       if (rec.model) models.add(rec.model);
       if (rec.prefixHash) prefixHashes.add(rec.prefixHash);
+      if (rec.planState) {
+        harvestedTurns++;
+        totalUncertainties += rec.planState.uncertainties.length;
+        totalSubgoals += rec.planState.subgoals.length;
+      }
       if (rec.usage && rec.model) {
         const u = new Usage(
           rec.usage.prompt_tokens ?? 0,
@@ -119,12 +140,17 @@ export function computeReplayStats(records: TranscriptRecord[]): ReplayStats {
     prefixHashes: [...prefixHashes],
     userTurns,
     toolCalls,
+    harvestedTurns,
+    totalUncertainties,
+    totalSubgoals,
     ...summarizeTurns(turns),
   };
 }
 
 function summarizeTurns(turns: TurnStats[]): SessionSummary {
   const totalCost = turns.reduce((s, t) => s + t.cost, 0);
+  const totalInput = turns.reduce((s, t) => s + inputCostUsd(t.model, t.usage), 0);
+  const totalOutput = turns.reduce((s, t) => s + outputCostUsd(t.model, t.usage), 0);
   const totalClaude = turns.reduce((s, t) => s + claudeEquivalentCost(t.usage), 0);
   let hit = 0;
   let miss = 0;
@@ -134,12 +160,16 @@ function summarizeTurns(turns: TurnStats[]): SessionSummary {
   }
   const cacheHitRatio = hit + miss > 0 ? hit / (hit + miss) : 0;
   const savingsVsClaude = totalClaude > 0 ? 1 - totalCost / totalClaude : 0;
+  const lastTurn = turns[turns.length - 1];
   return {
     turns: turns.length,
     totalCostUsd: round(totalCost, 6),
+    totalInputCostUsd: round(totalInput, 6),
+    totalOutputCostUsd: round(totalOutput, 6),
     claudeEquivalentUsd: round(totalClaude, 6),
     savingsVsClaudePct: round(savingsVsClaude * 100, 2),
     cacheHitRatio: round(cacheHitRatio, 4),
+    lastPromptTokens: lastTurn?.usage.promptTokens ?? 0,
   };
 }
 

src/session.ts

@@ -24,6 +24,7 @@ import {
   readdirSync,
   statSync,
   unlinkSync,
+  writeFileSync,
 } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
@@ -112,6 +113,26 @@ export function deleteSession(name: string): boolean {
   }
 }
 
+/**
+ * Overwrite the session file with a fresh message list. Used by
+ * `/compact` so the compacted in-memory log persists across restarts
+ * instead of being re-healed from a huge on-disk file every launch.
+ * We accept the brief non-atomic window between truncate and write —
+ * worst case: a concurrent crash loses the session, which is what
+ * `/forget` would have done anyway.
+ */
+export function rewriteSession(name: string, messages: ChatMessage[]): void {
+  const path = sessionPath(name);
+  mkdirSync(dirname(path), { recursive: true });
+  const body = messages.map((m) => JSON.stringify(m)).join("\n");
+  writeFileSync(path, body ? `${body}\n` : "", "utf8");
+  try {
+    chmodSync(path, 0o600);
+  } catch {
+    /* chmod not supported */
+  }
+}
+
 function countLines(path: string): number {
   try {
     const raw = readFileSync(path, "utf8");

src/skills.ts

@@ -0,0 +1,254 @@
+/**
+ * Skills — user-defined prompt packs pinned (by name) into the
+ * immutable prefix and loaded (by body) on demand.
+ *
+ * Two scopes mirror the user-memory layout:
+ *   - `project` → `<projectRoot>/.reasonix/skills/` (this repo only)
+ *   - `global`  → `~/.reasonix/skills/`            (every session)
+ *
+ * Project scope wins on a name collision. Deliberately NOT tied to
+ * any specific client's directory convention (`.claude/`, `.glm/`,
+ * etc.) — Reasonix is model-agnostic at the conversation layer, so
+ * coupling the skill filesystem to one vendor would break any user
+ * running a different backend.
+ *
+ * Accepted file layouts (both emit the same `Skill`):
+ *   - `{dir}/<name>/SKILL.md`   (preferred — lets a skill bundle
+ *                                additional assets alongside)
+ *   - `{dir}/<name>.md`         (flat, one-file shorthand)
+ *
+ * Frontmatter keys we read:
+ *   - `name`          — optional, defaults to the file / dir name
+ *   - `description`   — one-line index description (REQUIRED for listing)
+ *   - `allowed-tools` — parsed but UNUSED in v1 (see tools/skills.ts)
+ *
+ * Cache-First contract (Pillar 1):
+ *   - The PREFIX sees only names + descriptions (one line each).
+ *   - Bodies enter the APPEND-ONLY LOG lazily, via `run_skill` or
+ *     `/skill <name>` — never the prefix. That keeps the prefix hash
+ *     stable across skill additions to the body store.
+ */
+
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+
+export const SKILLS_DIRNAME = "skills";
+export const SKILL_FILE = "SKILL.md";
+/** Cap on the pinned skills-index block, mirrors memory-index cap. */
+export const SKILLS_INDEX_MAX_CHARS = 4000;
+/** Skill identifier shape — alnum + `_` + `-` + interior `.`, 1-64 chars. */
+const VALID_SKILL_NAME = /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,63}$/;
+
+export type SkillScope = "project" | "global";
+
+export interface Skill {
+  /** Canonical name — sanitized, matches the directory / filename stem. */
+  name: string;
+  /** One-line description shown in the pinned index. */
+  description: string;
+  /** Full markdown body (post-frontmatter). Loaded on demand. */
+  body: string;
+  /** Which scope this skill was loaded from. */
+  scope: SkillScope;
+  /** Absolute path to the SKILL.md (or {name}.md) file. */
+  path: string;
+  /** Raw `allowed-tools` field from frontmatter, if any. Unused in v1. */
+  allowedTools?: string;
+}
+
+export interface SkillStoreOptions {
+  /** Override `$HOME` — tests point this at a tmpdir. */
+  homeDir?: string;
+  /**
+   * Absolute project root. Required to surface project-scope skills;
+   * omit (e.g. in `reasonix chat` without `code`) and the store only
+   * reads the global scope.
+   */
+  projectRoot?: string;
+}
+
+/**
+ * Parse a `---` frontmatter block. Same minimal shape as user-memory:
+ * `key: value` lines, no quoting, no nesting. Returns `{}` data and the
+ * full input as body when no frontmatter fence is present — so hand-
+ * written files without frontmatter still surface (with empty desc).
+ */
+function parseFrontmatter(raw: string): { data: Record<string, string>; body: string } {
+  const lines = raw.split(/\r?\n/);
+  if (lines[0] !== "---") return { data: {}, body: raw };
+  const end = lines.indexOf("---", 1);
+  if (end < 0) return { data: {}, body: raw };
+  const data: Record<string, string> = {};
+  for (let i = 1; i < end; i++) {
+    const line = lines[i];
+    if (!line) continue;
+    const m = line.match(/^([a-zA-Z_][a-zA-Z0-9_-]*):\s*(.*)$/);
+    if (m?.[1]) data[m[1]] = (m[2] ?? "").trim();
+  }
+  return {
+    data,
+    body: lines
+      .slice(end + 1)
+      .join("\n")
+      .replace(/^\n+/, ""),
+  };
+}
+
+function isValidSkillName(name: string): boolean {
+  return VALID_SKILL_NAME.test(name);
+}
+
+export class SkillStore {
+  private readonly homeDir: string;
+  private readonly projectRoot: string | undefined;
+
+  constructor(opts: SkillStoreOptions = {}) {
+    this.homeDir = opts.homeDir ?? homedir();
+    this.projectRoot = opts.projectRoot ? resolve(opts.projectRoot) : undefined;
+  }
+
+  /** True iff this store was configured with a project root. */
+  hasProjectScope(): boolean {
+    return this.projectRoot !== undefined;
+  }
+
+  /**
+   * Root directories scanned, in priority order. Project scope first
+   * so a per-repo skill overrides a global one with the same name —
+   * users expect the local copy to win when both exist.
+   */
+  roots(): Array<{ dir: string; scope: SkillScope }> {
+    const out: Array<{ dir: string; scope: SkillScope }> = [];
+    if (this.projectRoot) {
+      out.push({
+        dir: join(this.projectRoot, ".reasonix", SKILLS_DIRNAME),
+        scope: "project",
+      });
+    }
+    out.push({ dir: join(this.homeDir, ".reasonix", SKILLS_DIRNAME), scope: "global" });
+    return out;
+  }
+
+  /**
+   * List every skill visible to this store. On name collisions the
+   * higher-priority root (project over global) wins. Sorted by name
+   * for stable prefix hashing.
+   */
+  list(): Skill[] {
+    const byName = new Map<string, Skill>();
+    for (const { dir, scope } of this.roots()) {
+      if (!existsSync(dir)) continue;
+      let entries: import("node:fs").Dirent[];
+      try {
+        entries = readdirSync(dir, { withFileTypes: true });
+      } catch {
+        continue;
+      }
+      for (const entry of entries) {
+        const skill = this.readEntry(dir, scope, entry);
+        if (!skill) continue;
+        if (!byName.has(skill.name)) byName.set(skill.name, skill);
+      }
+    }
+    return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
+  }
+
+  /** Resolve one skill by name. Returns `null` if not found or malformed. */
+  read(name: string): Skill | null {
+    if (!isValidSkillName(name)) return null;
+    for (const { dir, scope } of this.roots()) {
+      if (!existsSync(dir)) continue;
+      const dirCandidate = join(dir, name, SKILL_FILE);
+      if (existsSync(dirCandidate) && statSync(dirCandidate).isFile()) {
+        return this.parse(dirCandidate, name, scope);
+      }
+      const flatCandidate = join(dir, `${name}.md`);
+      if (existsSync(flatCandidate) && statSync(flatCandidate).isFile()) {
+        return this.parse(flatCandidate, name, scope);
+      }
+    }
+    return null;
+  }
+
+  private readEntry(dir: string, scope: SkillScope, entry: import("node:fs").Dirent): Skill | null {
+    if (entry.isDirectory()) {
+      if (!isValidSkillName(entry.name)) return null;
+      const file = join(dir, entry.name, SKILL_FILE);
+      if (!existsSync(file)) return null;
+      return this.parse(file, entry.name, scope);
+    }
+    if (entry.isFile() && entry.name.endsWith(".md")) {
+      const stem = entry.name.slice(0, -3);
+      if (!isValidSkillName(stem)) return null;
+      return this.parse(join(dir, entry.name), stem, scope);
+    }
+    return null;
+  }
+
+  private parse(path: string, stem: string, scope: SkillScope): Skill | null {
+    let raw: string;
+    try {
+      raw = readFileSync(path, "utf8");
+    } catch {
+      return null;
+    }
+    const { data, body } = parseFrontmatter(raw);
+    const name = data.name && isValidSkillName(data.name) ? data.name : stem;
+    return {
+      name,
+      description: (data.description ?? "").trim(),
+      body: body.trim(),
+      scope,
+      path,
+      allowedTools: data["allowed-tools"],
+    };
+  }
+}
+
+/**
+ * Build a single index line for one skill. Shape mirrors memory's
+ * `indexLine` — a bullet suitable for a markdown fenced block in the
+ * system prompt. Description is truncated to keep the full line under
+ * ~150 chars.
+ */
+function skillIndexLine(s: Pick<Skill, "name" | "description">): string {
+  const safeDesc = s.description.replace(/\n/g, " ").trim();
+  const max = 130 - s.name.length;
+  const clipped = safeDesc.length > max ? `${safeDesc.slice(0, Math.max(1, max - 1))}…` : safeDesc;
+  return clipped ? `- ${s.name} — ${clipped}` : `- ${s.name}`;
+}
+
+/**
+ * Append a `# Skills` block to `basePrompt` listing every discovered
+ * skill (name + description only). Bodies are NOT inlined — that's the
+ * whole point: the prefix stays short and cacheable; full content loads
+ * on demand via `run_skill` or `/skill <name>`.
+ *
+ * Emits nothing when no skills are discovered — keeps the prefix hash
+ * stable for users who don't use skills at all.
+ */
+export function applySkillsIndex(basePrompt: string, opts: SkillStoreOptions = {}): string {
+  const store = new SkillStore(opts);
+  const skills = store.list().filter((s) => s.description);
+  if (skills.length === 0) return basePrompt;
+  const lines = skills.map(skillIndexLine);
+  const joined = lines.join("\n");
+  const truncated =
+    joined.length > SKILLS_INDEX_MAX_CHARS
+      ? `${joined.slice(0, SKILLS_INDEX_MAX_CHARS)}\n… (truncated ${
+          joined.length - SKILLS_INDEX_MAX_CHARS
+        } chars)`
+      : joined;
+  return [
+    basePrompt,
+    "",
+    "# Skills — user-defined prompt packs",
+    "",
+    'One-liner index. Each skill is a self-contained instruction block (plus optional tool hints) the user or an earlier session saved. To load the full body, call `run_skill({ name: "<skill-name>" })` — the body is NOT in this prompt, only the name and description are. The user can also invoke a skill directly as `/skill <name>`.',
+    "",
+    "```",
+    truncated,
+    "```",
+  ].join("\n");
+}

src/telemetry.ts

@@ -12,6 +12,20 @@ export const DEEPSEEK_PRICING: Record<
 /** Reference Claude Sonnet 4.6 pricing (USD per 1M tokens). */
 export const CLAUDE_SONNET_PRICING = { input: 3.0, output: 15.0 };
 
+/**
+ * Maximum prompt-side context window per DeepSeek model, in tokens.
+ * Both V3 (`deepseek-chat`) and R1 (`deepseek-reasoner`) currently expose
+ * a 131,072-token prompt limit per the OpenAPI spec; completion caps
+ * differ but don't affect the prompt budget the StatsPanel shows.
+ */
+export const DEEPSEEK_CONTEXT_TOKENS: Record<string, number> = {
+  "deepseek-chat": 131_072,
+  "deepseek-reasoner": 131_072,
+};
+
+/** Fallback when the caller's model id isn't in the table — safe lower bound. */
+export const DEFAULT_CONTEXT_TOKENS = 131_072;
+
 export function costUsd(model: string, usage: Usage): number {
   const p = DEEPSEEK_PRICING[model];
   if (!p) return 0;
@@ -23,6 +37,24 @@ export function costUsd(model: string, usage: Usage): number {
   );
 }
 
+/** Input-side cost only (prompt, cache hit + miss). Used for the panel breakdown. */
+export function inputCostUsd(model: string, usage: Usage): number {
+  const p = DEEPSEEK_PRICING[model];
+  if (!p) return 0;
+  return (
+    (usage.promptCacheHitTokens * p.inputCacheHit +
+      usage.promptCacheMissTokens * p.inputCacheMiss) /
+    1_000_000
+  );
+}
+
+/** Output-side cost only (completion tokens). Used for the panel breakdown. */
+export function outputCostUsd(model: string, usage: Usage): number {
+  const p = DEEPSEEK_PRICING[model];
+  if (!p) return 0;
+  return (usage.completionTokens * p.output) / 1_000_000;
+}
+
 export function claudeEquivalentCost(usage: Usage): number {
   return (
     (usage.promptTokens * CLAUDE_SONNET_PRICING.input +
@@ -42,9 +74,26 @@ export interface TurnStats {
 export interface SessionSummary {
   turns: number;
   totalCostUsd: number;
+  /**
+   * Input-side (prompt) cost aggregated across the session. Split
+   * from totalCostUsd so the panel can render "cost $X (in $Y · out
+   * $Z)" — users asked for visibility into where the spend lands.
+   */
+  totalInputCostUsd: number;
+  /** Output-side (completion) cost aggregated across the session. */
+  totalOutputCostUsd: number;
+  /** @deprecated Claude reference; kept for benchmarks + replay compat, no longer surfaced in the TUI. */
   claudeEquivalentUsd: number;
+  /** @deprecated. Same as claudeEquivalentUsd — synthetic ratio, not a real measurement. */
   savingsVsClaudePct: number;
   cacheHitRatio: number;
+  /**
+   * Most recent turn's prompt-token count. Used by the TUI's context
+   * gauge: we can't know the next call's cost without making it, but
+   * the last turn's prompt tokens is the floor (next call is last
+   * prompt + user delta + any new tool outputs).
+   */
+  lastPromptTokens: number;
 }
 
 export class SessionStats {
@@ -76,6 +125,14 @@ export class SessionStats {
     return c > 0 ? 1 - this.totalCost / c : 0;
   }
 
+  get totalInputCost(): number {
+    return this.turns.reduce((sum, t) => sum + inputCostUsd(t.model, t.usage), 0);
+  }
+
+  get totalOutputCost(): number {
+    return this.turns.reduce((sum, t) => sum + outputCostUsd(t.model, t.usage), 0);
+  }
+
   get aggregateCacheHitRatio(): number {
     let hit = 0;
     let miss = 0;
@@ -88,12 +145,16 @@ export class SessionStats {
   }
 
   summary(): SessionSummary {
+    const last = this.turns[this.turns.length - 1];
     return {
       turns: this.turns.length,
       totalCostUsd: round(this.totalCost, 6),
+      totalInputCostUsd: round(this.totalInputCost, 6),
+      totalOutputCostUsd: round(this.totalOutputCost, 6),
       claudeEquivalentUsd: round(this.totalClaudeEquivalent, 6),
       savingsVsClaudePct: round(this.savingsVsClaude * 100, 2),
       cacheHitRatio: round(this.aggregateCacheHitRatio, 4),
+      lastPromptTokens: last?.usage.promptTokens ?? 0,
     };
   }
 }

src/tools.ts

@@ -1,11 +1,42 @@
 import { analyzeSchema, flattenSchema, nestArguments } from "./repair/flatten.js";
 import type { JSONSchema, ToolSpec } from "./types.js";
 
+/**
+ * Per-call context a tool `fn` can optionally consume. Today the only
+ * field is `signal`, plumbed through so long-running tools (MCP calls,
+ * HTTP requests) can abort when the user presses Esc. Omitted fields
+ * stay optional — tools written against the pre-0.4.9 signature keep
+ * working; they just ignore cancellation, which is fine for fast
+ * local work where "await finishes" happens before the next tick anyway.
+ */
+export interface ToolCallContext {
+  signal?: AbortSignal;
+}
+
 export interface ToolDefinition<A = any, R = any> {
   name: string;
   description?: string;
   parameters?: JSONSchema;
-  fn: (args: A) => R | Promise<R>;
+  /**
+   * Marks a tool as read-only: safe to invoke during plan mode. `true`
+   * for tools that only observe (read_file, list_directory, search, web
+   * fetch/search). Leave undefined / `false` for anything that can write,
+   * execute, or mutate state.
+   *
+   * The registry enforces this at dispatch: non-readonly tools called
+   * while `planMode` is on return a refusal string the model can
+   * learn from, instead of actually running.
+   */
+  readOnly?: boolean;
+  /**
+   * Dynamic read-only check for tools whose safety depends on arguments
+   * — `run_command` with an allowlisted argv is safe, `run_command
+   * rm -rf` isn't. Called with the parsed arguments; `true` means "treat
+   * as read-only for plan mode". Takes precedence over `readOnly` when
+   * both are set.
+   */
+  readOnlyCheck?: (args: A) => boolean;
+  fn: (args: A, ctx?: ToolCallContext) => R | Promise<R>;
 }
 
 interface InternalTool extends ToolDefinition {
@@ -30,11 +61,29 @@ export interface ToolRegistryOptions {
 export class ToolRegistry {
   private readonly _tools = new Map<string, InternalTool>();
   private readonly _autoFlatten: boolean;
+  /**
+   * When true, `dispatch` refuses any tool whose `readOnly` flag isn't
+   * set (and whose `readOnlyCheck` doesn't pass on the specific args).
+   * Drives `reasonix code`'s Plan Mode — the model can still explore
+   * via read tools but its writes and non-allowlisted shell calls are
+   * bounced until the user approves a submitted plan.
+   */
+  private _planMode = false;
 
   constructor(opts: ToolRegistryOptions = {}) {
     this._autoFlatten = opts.autoFlatten !== false;
   }
 
+  /** Enable / disable plan-mode enforcement at dispatch. */
+  setPlanMode(on: boolean): void {
+    this._planMode = Boolean(on);
+  }
+
+  /** True when the registry is currently refusing non-readonly calls. */
+  get planMode(): boolean {
+    return this._planMode;
+  }
+
   register<A, R>(def: ToolDefinition<A, R>): this {
     if (!def.name) throw new Error("tool requires a name");
     const internal: InternalTool = { ...(def as ToolDefinition) };
@@ -76,7 +125,11 @@ export class ToolRegistry {
     }));
   }
 
-  async dispatch(name: string, argumentsRaw: string | Record<string, unknown>): Promise<string> {
+  async dispatch(
+    name: string,
+    argumentsRaw: string | Record<string, unknown>,
+    opts: { signal?: AbortSignal } = {},
+  ): Promise<string> {
     const tool = this._tools.get(name);
     if (!tool) {
       return JSON.stringify({ error: `unknown tool: ${name}` });
@@ -104,17 +157,50 @@ export class ToolRegistry {
       args = nestArguments(args);
     }
 
+    // Plan-mode enforcement — runs AFTER arg parsing so a tool with a
+    // runtime `readOnlyCheck` can inspect the actual args (e.g.
+    // `run_command` is read-only iff the command matches its allowlist).
+    if (this._planMode && !isReadOnlyCall(tool, args)) {
+      return JSON.stringify({
+        error: `${name}: unavailable in plan mode — this is a read-only exploration phase. Use read_file / list_directory / search_files / directory_tree / web_search / allowlisted shell commands to investigate. Call submit_plan with your proposed plan when you're ready for the user's review.`,
+      });
+    }
+
     try {
-      const result = await tool.fn(args);
+      const result = await tool.fn(args, { signal: opts.signal });
       return typeof result === "string" ? result : JSON.stringify(result);
     } catch (err) {
+      const e = err as Error & { toToolResult?: () => unknown };
+      // Errors may opt into a richer tool-result shape by implementing
+      // `toToolResult()`. Used by `PlanProposedError` to smuggle the
+      // submitted plan text out to the UI without stuffing it into the
+      // error message (which the dispatcher truncates at no fixed limit,
+      // but keeping payloads structured is cleaner for UI parsing).
+      if (typeof e.toToolResult === "function") {
+        try {
+          return JSON.stringify(e.toToolResult());
+        } catch {
+          /* fall through to the default shape */
+        }
+      }
       return JSON.stringify({
-        error: `${(err as Error).name}: ${(err as Error).message}`,
+        error: `${e.name}: ${e.message}`,
       });
     }
   }
 }
 
+function isReadOnlyCall(tool: InternalTool, args: Record<string, unknown>): boolean {
+  if (tool.readOnlyCheck) {
+    try {
+      return Boolean(tool.readOnlyCheck(args as never));
+    } catch {
+      return false;
+    }
+  }
+  return tool.readOnly === true;
+}
+
 function hasDotKey(obj: Record<string, unknown>): boolean {
   for (const k of Object.keys(obj)) {
     if (k.includes(".")) return true;

src/tools/filesystem.ts

@@ -0,0 +1,450 @@
+/**
+ * Built-in filesystem tools for `reasonix code`.
+ *
+ * Why native instead of the official `@modelcontextprotocol/server-filesystem`:
+ *   - No subprocess overhead — every call is 50-200 ms cheaper.
+ *   - Schema shapes tuned for R1: `edit_file` takes a single
+ *     SEARCH/REPLACE string instead of `string="false"`-encoded
+ *     JSON arrays, which was the biggest single source of DSML
+ *     hallucinations in 0.4.x.
+ *   - Sandbox enforcement lives here so Reasonix can reason about
+ *     it (tests cover path-traversal, symlink-escape, and the
+ *     cwd-outside-root case) rather than trusting an external server.
+ *   - No `npx install` / network dependency in `reasonix code`.
+ *
+ * Tool names + argument shapes intentionally mirror the official
+ * filesystem server so R1's muscle memory carries over. The only
+ * intentional divergence is `edit_file`, noted above.
+ */
+
+import { promises as fs } from "node:fs";
+import * as pathMod from "node:path";
+import type { ToolRegistry } from "../tools.js";
+
+export interface FilesystemToolsOptions {
+  /** Absolute directory the tools may read/write. Paths outside this are refused. */
+  rootDir: string;
+  /**
+   * When `false`, register only read-side tools (read_file, list_directory,
+   * search_files, get_file_info, directory_tree). Useful for read-only
+   * workflows where the model should never mutate the tree. Default: true.
+   */
+  allowWriting?: boolean;
+  /**
+   * Cap for a single file read, in bytes. Prevents a stray `read_file`
+   * on a multi-GB blob from OOM'ing Node. 2 MB is enough for any realistic
+   * source file (the biggest single-file TypeScript project checked in to
+   * GitHub is ~500 KB); pass higher when working with data files.
+   */
+  maxReadBytes?: number;
+  /**
+   * Cap for total bytes returned from search_files / directory_tree /
+   * grep, so the model can't accidentally pull down the whole tree as
+   * one giant string. 256 KB by default.
+   */
+  maxListBytes?: number;
+}
+
+const DEFAULT_MAX_READ_BYTES = 2 * 1024 * 1024;
+const DEFAULT_MAX_LIST_BYTES = 256 * 1024;
+
+export function registerFilesystemTools(
+  registry: ToolRegistry,
+  opts: FilesystemToolsOptions,
+): ToolRegistry {
+  const rootDir = pathMod.resolve(opts.rootDir);
+  const allowWriting = opts.allowWriting !== false;
+  const maxReadBytes = opts.maxReadBytes ?? DEFAULT_MAX_READ_BYTES;
+  const maxListBytes = opts.maxListBytes ?? DEFAULT_MAX_LIST_BYTES;
+
+  /** Resolve path, enforce it's under rootDir, return absolute. */
+  const safePath = (raw: unknown): string => {
+    if (typeof raw !== "string" || raw.length === 0) {
+      throw new Error("path must be a non-empty string");
+    }
+    // Interpret relative paths against rootDir (the session's scope).
+    const resolved = pathMod.resolve(rootDir, raw);
+    const normRoot = pathMod.resolve(rootDir);
+    // Use relative() to catch any `..` segments that escape.
+    const rel = pathMod.relative(normRoot, resolved);
+    if (rel.startsWith("..") || pathMod.isAbsolute(rel)) {
+      throw new Error(`path escapes sandbox root (${normRoot}): ${raw}`);
+    }
+    return resolved;
+  };
+
+  registry.register({
+    name: "read_file",
+    description:
+      "Read a file under the sandbox root. Returns the full contents (truncated with a notice if larger than the per-call cap). Paths may be relative to the root or absolute-under-root.",
+    readOnly: true,
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Path to read (relative to rootDir or absolute)." },
+        head: { type: "integer", description: "If set, return only the first N lines." },
+        tail: { type: "integer", description: "If set, return only the last N lines." },
+      },
+      required: ["path"],
+    },
+    fn: async (args: { path: string; head?: number; tail?: number }) => {
+      const abs = safePath(args.path);
+      const stat = await fs.stat(abs);
+      if (stat.isDirectory()) {
+        throw new Error(`not a file: ${args.path} (it's a directory)`);
+      }
+      const raw = await fs.readFile(abs);
+      if (raw.length > maxReadBytes) {
+        const head = raw.slice(0, maxReadBytes).toString("utf8");
+        return `${head}\n\n[…truncated ${raw.length - maxReadBytes} bytes — file is ${raw.length} B, cap ${maxReadBytes} B. Retry with head/tail for targeted view.]`;
+      }
+      const text = raw.toString("utf8");
+      if (typeof args.head === "number" && args.head > 0) {
+        return text.split(/\r?\n/).slice(0, args.head).join("\n");
+      }
+      if (typeof args.tail === "number" && args.tail > 0) {
+        let lines = text.split(/\r?\n/);
+        // Most files end with a final '\n', which splits into an empty
+        // trailing string. Drop it before slicing so tail=2 returns the
+        // last two *real* lines, not "last line + empty".
+        if (lines.length > 0 && lines[lines.length - 1] === "") lines = lines.slice(0, -1);
+        return lines.slice(Math.max(0, lines.length - args.tail)).join("\n");
+      }
+      return text;
+    },
+  });
+
+  registry.register({
+    name: "list_directory",
+    description:
+      "List entries in a directory under the sandbox root. Returns one line per entry, marking directories with a trailing slash. Not recursive — use directory_tree for that.",
+    readOnly: true,
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Directory to list (default: root)." },
+      },
+    },
+    fn: async (args: { path?: string }) => {
+      const abs = safePath(args.path ?? ".");
+      const entries = await fs.readdir(abs, { withFileTypes: true });
+      const lines: string[] = [];
+      for (const e of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+        lines.push(e.isDirectory() ? `${e.name}/` : e.name);
+      }
+      return lines.join("\n") || "(empty directory)";
+    },
+  });
+
+  registry.register({
+    name: "directory_tree",
+    description:
+      "Recursively list entries in a directory. Shows indented tree structure with directories marked '/'. Caps output so a huge tree doesn't drown the context.",
+    readOnly: true,
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Root of the tree (default: sandbox root)." },
+        maxDepth: { type: "integer", description: "Max recursion depth (default 4)." },
+      },
+    },
+    fn: async (args: { path?: string; maxDepth?: number }) => {
+      const startAbs = safePath(args.path ?? ".");
+      const maxDepth = typeof args.maxDepth === "number" ? args.maxDepth : 4;
+      const lines: string[] = [];
+      let totalBytes = 0;
+      let truncated = false;
+      const walk = async (dir: string, depth: number): Promise<void> => {
+        if (truncated) return;
+        if (depth > maxDepth) return;
+        let entries: import("node:fs").Dirent[];
+        try {
+          entries = await fs.readdir(dir, { withFileTypes: true });
+        } catch {
+          return;
+        }
+        entries.sort((a, b) => a.name.localeCompare(b.name));
+        for (const e of entries) {
+          if (truncated) return;
+          const indent = "  ".repeat(depth);
+          const line = e.isDirectory() ? `${indent}${e.name}/` : `${indent}${e.name}`;
+          totalBytes += line.length + 1;
+          if (totalBytes > maxListBytes) {
+            lines.push(`  [… tree truncated at ${maxListBytes} bytes …]`);
+            truncated = true;
+            return;
+          }
+          lines.push(line);
+          if (e.isDirectory()) {
+            await walk(pathMod.join(dir, e.name), depth + 1);
+          }
+        }
+      };
+      await walk(startAbs, 0);
+      return lines.join("\n") || "(empty tree)";
+    },
+  });
+
+  registry.register({
+    name: "search_files",
+    description:
+      "Find files whose NAME matches a substring or regex. Case-insensitive. Walks the directory recursively under the sandbox root. Returns one path per line.",
+    readOnly: true,
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Directory to start the search at (default: root)." },
+        pattern: {
+          type: "string",
+          description: "Substring (or regex) to match against filenames.",
+        },
+      },
+      required: ["pattern"],
+    },
+    fn: async (args: { path?: string; pattern: string }) => {
+      const startAbs = safePath(args.path ?? ".");
+      const needle = args.pattern.toLowerCase();
+      // Try as regex first (permits users who want patterns); fall
+      // back to plain substring when it's not a valid regex. Flag `i`
+      // so matching is case-insensitive regardless of path.
+      let re: RegExp | null = null;
+      try {
+        re = new RegExp(args.pattern, "i");
+      } catch {
+        re = null;
+      }
+      const matches: string[] = [];
+      let totalBytes = 0;
+      const walk = async (dir: string): Promise<void> => {
+        let entries: import("node:fs").Dirent[];
+        try {
+          entries = await fs.readdir(dir, { withFileTypes: true });
+        } catch {
+          return;
+        }
+        for (const e of entries) {
+          const full = pathMod.join(dir, e.name);
+          const lower = e.name.toLowerCase();
+          const hit = re ? re.test(e.name) : lower.includes(needle);
+          if (hit) {
+            const rel = pathMod.relative(rootDir, full);
+            if (totalBytes + rel.length + 1 > maxListBytes) {
+              matches.push("[… search truncated — refine pattern …]");
+              return;
+            }
+            matches.push(rel);
+            totalBytes += rel.length + 1;
+          }
+          if (e.isDirectory()) await walk(full);
+        }
+      };
+      await walk(startAbs);
+      return matches.length === 0 ? "(no matches)" : matches.join("\n");
+    },
+  });
+
+  registry.register({
+    name: "get_file_info",
+    description:
+      "Stat a path under the sandbox root. Returns type (file|directory|symlink), size in bytes, mtime in ISO-8601.",
+    readOnly: true,
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string" },
+      },
+      required: ["path"],
+    },
+    fn: async (args: { path: string }) => {
+      const abs = safePath(args.path);
+      const st = await fs.lstat(abs);
+      const type = st.isDirectory() ? "directory" : st.isSymbolicLink() ? "symlink" : "file";
+      return JSON.stringify({
+        type,
+        size: st.size,
+        mtime: st.mtime.toISOString(),
+      });
+    },
+  });
+
+  if (!allowWriting) return registry;
+
+  registry.register({
+    name: "write_file",
+    description:
+      "Create or overwrite a file under the sandbox root with the given content. Parent directories are created as needed.",
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string" },
+        content: { type: "string" },
+      },
+      required: ["path", "content"],
+    },
+    fn: async (args: { path: string; content: string }) => {
+      const abs = safePath(args.path);
+      await fs.mkdir(pathMod.dirname(abs), { recursive: true });
+      await fs.writeFile(abs, args.content, "utf8");
+      return `wrote ${args.content.length} chars to ${pathMod.relative(rootDir, abs)}`;
+    },
+  });
+
+  registry.register({
+    name: "edit_file",
+    description:
+      "Apply a SEARCH/REPLACE edit to an existing file. `search` must match exactly (whitespace sensitive) — no regex. The match must be unique in the file; otherwise the edit is refused to avoid surprise rewrites.",
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string" },
+        search: { type: "string", description: "Exact text to find (must be unique)." },
+        replace: { type: "string", description: "Text to substitute in place of `search`." },
+      },
+      required: ["path", "search", "replace"],
+    },
+    fn: async (args: { path: string; search: string; replace: string }) => {
+      const abs = safePath(args.path);
+      const before = await fs.readFile(abs, "utf8");
+      if (args.search.length === 0) {
+        throw new Error("edit_file: search cannot be empty");
+      }
+      const firstIdx = before.indexOf(args.search);
+      if (firstIdx < 0) {
+        throw new Error(`edit_file: search text not found in ${pathMod.relative(rootDir, abs)}`);
+      }
+      const nextIdx = before.indexOf(args.search, firstIdx + 1);
+      if (nextIdx >= 0) {
+        throw new Error(
+          `edit_file: search text appears multiple times in ${pathMod.relative(rootDir, abs)} — include more context to disambiguate`,
+        );
+      }
+      const after =
+        before.slice(0, firstIdx) + args.replace + before.slice(firstIdx + args.search.length);
+      await fs.writeFile(abs, after, "utf8");
+      const rel = pathMod.relative(rootDir, abs);
+      const header = `edited ${rel} (${args.search.length}→${args.replace.length} chars)`;
+      // Starting line number of the search block in the original
+      // file. `split/length` on the prefix gives a 1-based line
+      // count where the match begins, matching git-diff's @@ -N,M
+      // +N,M @@ header convention.
+      const startLine = before.slice(0, firstIdx).split(/\r?\n/).length;
+      const diff = renderEditDiff(args.search, args.replace, startLine);
+      return `${header}\n${diff}`;
+    },
+  });
+
+  registry.register({
+    name: "create_directory",
+    description: "Create a directory (and any missing parents) under the sandbox root.",
+    parameters: {
+      type: "object",
+      properties: { path: { type: "string" } },
+      required: ["path"],
+    },
+    fn: async (args: { path: string }) => {
+      const abs = safePath(args.path);
+      await fs.mkdir(abs, { recursive: true });
+      return `created ${pathMod.relative(rootDir, abs)}/`;
+    },
+  });
+
+  registry.register({
+    name: "move_file",
+    description: "Rename/move a file or directory under the sandbox root.",
+    parameters: {
+      type: "object",
+      properties: {
+        source: { type: "string" },
+        destination: { type: "string" },
+      },
+      required: ["source", "destination"],
+    },
+    fn: async (args: { source: string; destination: string }) => {
+      const src = safePath(args.source);
+      const dst = safePath(args.destination);
+      await fs.mkdir(pathMod.dirname(dst), { recursive: true });
+      await fs.rename(src, dst);
+      return `moved ${pathMod.relative(rootDir, src)} → ${pathMod.relative(rootDir, dst)}`;
+    },
+  });
+
+  return registry;
+}
+
+/**
+ * Format an edit_file change as a proper line-level diff, styled
+ * like `git diff`. Starts with a unified-diff hunk header —
+ * `@@ -startLine,oldCount +startLine,newCount @@` — so the user
+ * can tell where in the file the change lands. Body uses LCS
+ * (longest common subsequence) to mark lines as removed (`-`),
+ * added (`+`), or unchanged context (` `). Users were getting
+ * hundreds of `-` followed by hundreds of `+` for tiny changes
+ * because the naive "dump both sides" format can't tell what
+ * actually moved vs. stayed — this fixes that and adds line-
+ * number context on top.
+ */
+function renderEditDiff(search: string, replace: string, startLine: number): string {
+  const a = search.split(/\r?\n/);
+  const b = replace.split(/\r?\n/);
+  const diff = lineDiff(a, b);
+  const hunk = `@@ -${startLine},${a.length} +${startLine},${b.length} @@`;
+  const body = diff.map((d) => `${d.op === " " ? " " : d.op} ${d.line}`).join("\n");
+  return `${hunk}\n${body}`;
+}
+
+/**
+ * Compute a line-level diff via classic LCS dynamic programming.
+ * Good enough for SEARCH/REPLACE blocks where both sides are
+ * typically under a few hundred lines — O(n*m) space + time. For
+ * huge blocks we'd want Myers' algorithm, but the caller already
+ * caps the inline-display size and `/tool N` shows the full result,
+ * so quadratic is fine in practice.
+ *
+ * Exported so tests can exercise the diff logic without spinning
+ * up the full tool dispatch path.
+ */
+export function lineDiff(
+  a: readonly string[],
+  b: readonly string[],
+): Array<{ op: "-" | "+" | " "; line: string }> {
+  const n = a.length;
+  const m = b.length;
+  // dp[i][j] = LCS length of a[0..i) and b[0..j).
+  const dp: number[][] = Array.from({ length: n + 1 }, () => new Array(m + 1).fill(0));
+  for (let i = 1; i <= n; i++) {
+    for (let j = 1; j <= m; j++) {
+      if (a[i - 1] === b[j - 1]) dp[i]![j] = dp[i - 1]![j - 1]! + 1;
+      else dp[i]![j] = Math.max(dp[i - 1]![j]!, dp[i]![j - 1]!);
+    }
+  }
+  // Backtrack to recover the op sequence.
+  const out: Array<{ op: "-" | "+" | " "; line: string }> = [];
+  let i = n;
+  let j = m;
+  while (i > 0 && j > 0) {
+    if (a[i - 1] === b[j - 1]) {
+      out.unshift({ op: " ", line: a[i - 1]! });
+      i--;
+      j--;
+    } else if ((dp[i - 1]![j] ?? 0) > (dp[i]![j - 1] ?? 0)) {
+      out.unshift({ op: "-", line: a[i - 1]! });
+      i--;
+    } else {
+      // Tie-break goes here (strictly less or equal): take the
+      // insertion first during backtrack so the final forward order
+      // renders removals BEFORE additions for a substitution —
+      // matches git-diff convention of `- old / + new`.
+      out.unshift({ op: "+", line: b[j - 1]! });
+      j--;
+    }
+  }
+  while (i > 0) {
+    out.unshift({ op: "-", line: a[i - 1]! });
+    i--;
+  }
+  while (j > 0) {
+    out.unshift({ op: "+", line: b[j - 1]! });
+    j--;
+  }
+  return out;
+}

src/tools/memory.ts

@@ -0,0 +1,180 @@
+/**
+ * `remember` / `forget` / `recall_memory` — tools that let the model
+ * read and write the user-memory store across sessions.
+ *
+ * Scope rules:
+ *   - `global`  — always available (no sandbox needed).
+ *   - `project` — requires a `projectRoot` on MemoryStore. In chat mode
+ *     (no sandbox), the tools still register but a `scope=project` call
+ *     returns a structured refusal so the model can try `global` instead.
+ *
+ * Memory changes are written eagerly but NOT re-loaded into the prefix
+ * mid-session (cache invariant). The user notices at `/new` or the next
+ * launch — or they can read fresh content via `recall_memory` which
+ * always hits disk.
+ */
+
+import type { ToolRegistry } from "../tools.js";
+import {
+  type MemoryScope,
+  MemoryStore,
+  type MemoryType,
+  sanitizeMemoryName,
+} from "../user-memory.js";
+
+export interface MemoryToolsOptions {
+  /** Sandbox root for the `project` scope. Omit for chat mode. */
+  projectRoot?: string;
+  /** Override `~/.reasonix` (tests). */
+  homeDir?: string;
+}
+
+export function registerMemoryTools(
+  registry: ToolRegistry,
+  opts: MemoryToolsOptions = {},
+): ToolRegistry {
+  const store = new MemoryStore({ homeDir: opts.homeDir, projectRoot: opts.projectRoot });
+  const hasProject = store.hasProjectScope();
+
+  registry.register({
+    name: "remember",
+    description:
+      "Save a memory for future sessions. Use when the user states a preference, corrects your approach, shares a non-obvious fact about this project, or explicitly asks you to remember something. Don't remember transient task state — only things worth recalling next session. The memory is written now but won't re-load into the system prompt until the next `/new` or launch.",
+    parameters: {
+      type: "object",
+      properties: {
+        type: {
+          type: "string",
+          enum: ["user", "feedback", "project", "reference"],
+          description:
+            "'user' = role/skills/prefs; 'feedback' = corrections or confirmed approaches; 'project' = facts/decisions about the current work; 'reference' = pointers to external systems the user uses.",
+        },
+        scope: {
+          type: "string",
+          enum: ["global", "project"],
+          description:
+            "'global' = applies across every project (preferences, tooling); 'project' = scoped to the current sandbox (decisions, local facts). Only available in `reasonix code`.",
+        },
+        name: {
+          type: "string",
+          description:
+            "filename-safe identifier, 3-40 chars, alnum + _ - . (no path separators, no leading dot).",
+        },
+        description: {
+          type: "string",
+          description: "One-line summary shown in MEMORY.md (under ~150 chars).",
+        },
+        content: {
+          type: "string",
+          description:
+            "Full memory body in markdown. For feedback/project types, structure as: rule/fact, then **Why:** line, then **How to apply:** line.",
+        },
+      },
+      required: ["type", "scope", "name", "description", "content"],
+    },
+    fn: async (args: {
+      type: MemoryType;
+      scope: MemoryScope;
+      name: string;
+      description: string;
+      content: string;
+    }) => {
+      if (args.scope === "project" && !hasProject) {
+        return JSON.stringify({
+          error:
+            "scope='project' is unavailable in this session (no sandbox root). Retry with scope='global', or ask the user to switch to `reasonix code` for project-scoped memory.",
+        });
+      }
+      try {
+        const path = store.write({
+          name: args.name,
+          type: args.type,
+          scope: args.scope,
+          description: args.description,
+          body: args.content,
+        });
+        const key = sanitizeMemoryName(args.name);
+        // The return text is load-bearing: it's the ONLY thing keeping
+        // the fact visible within the current session, because the
+        // prefix isn't re-hashed mid-session (Pillar 1). R1 reads this
+        // on its next turn — the wording is deliberately imperative so
+        // it doesn't get ignored in favor of explore-first behavior.
+        return [
+          `✓ REMEMBERED (${args.scope}/${key}): ${args.description}`,
+          "",
+          "TREAT THIS AS ESTABLISHED FACT for the rest of this session.",
+          "The user just told you — don't re-explore the filesystem to re-derive it.",
+          `(Saved to ${path}; pins into the system prompt on next /new or launch.)`,
+        ].join("\n");
+      } catch (err) {
+        return JSON.stringify({ error: `remember failed: ${(err as Error).message}` });
+      }
+    },
+  });
+
+  registry.register({
+    name: "forget",
+    description:
+      "Delete a memory file and remove it from MEMORY.md. Use when the user explicitly asks to forget something, or when a previously-remembered fact has become wrong. Irreversible — no tombstone.",
+    parameters: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "Memory name (the identifier used in `remember`)." },
+        scope: { type: "string", enum: ["global", "project"] },
+      },
+      required: ["name", "scope"],
+    },
+    fn: async (args: { name: string; scope: MemoryScope }) => {
+      if (args.scope === "project" && !hasProject) {
+        return JSON.stringify({
+          error: "scope='project' is unavailable in this session (no sandbox root).",
+        });
+      }
+      try {
+        const existed = store.delete(args.scope, args.name);
+        return existed
+          ? `forgot (${args.scope}/${sanitizeMemoryName(args.name)}). Re-load on next /new or launch.`
+          : `no such memory: ${args.scope}/${args.name} (nothing to forget).`;
+      } catch (err) {
+        return JSON.stringify({ error: `forget failed: ${(err as Error).message}` });
+      }
+    },
+  });
+
+  registry.register({
+    name: "recall_memory",
+    description:
+      "Read the full body of a memory file when its MEMORY.md one-liner (already in the system prompt) isn't enough detail. Most of the time the index suffices — only call this when the user's question genuinely requires the full context.",
+    readOnly: true,
+    parameters: {
+      type: "object",
+      properties: {
+        name: { type: "string" },
+        scope: { type: "string", enum: ["global", "project"] },
+      },
+      required: ["name", "scope"],
+    },
+    fn: async (args: { name: string; scope: MemoryScope }) => {
+      if (args.scope === "project" && !hasProject) {
+        return JSON.stringify({
+          error: "scope='project' is unavailable in this session (no sandbox root).",
+        });
+      }
+      try {
+        const entry = store.read(args.scope, args.name);
+        return [
+          `# ${entry.name}  (${entry.scope}/${entry.type}, created ${entry.createdAt || "?"})`,
+          entry.description ? `> ${entry.description}` : "",
+          "",
+          entry.body,
+        ]
+          .filter(Boolean)
+          .join("\n");
+      } catch (err) {
+        return JSON.stringify({ error: `recall failed: ${(err as Error).message}` });
+      }
+    },
+  });
+
+  return registry;
+}

src/tools/plan.ts

@@ -0,0 +1,101 @@
+/**
+ * Plan Mode — read-only exploration phase for `reasonix code`.
+ *
+ * Shape (mirrors claude-code's plan/act split, adapted for Reasonix):
+ *
+ *   1. User types `/plan` → registry switches to plan-mode enforcement
+ *      (write tools refused at dispatch; reads + allowlisted shell
+ *      still work).
+ *   2. Model explores, then calls `submit_plan` with a markdown plan.
+ *   3. `submit_plan` throws `PlanProposedError`, which the TUI renders
+ *      as a picker: Approve / Refine / Cancel.
+ *   4. Approve → registry leaves plan mode, a synthetic user message
+ *      "The plan has been approved. Implement it now." is pushed into
+ *      the loop so the next turn executes.
+ *
+ * The read-only enforcement lives in `ToolRegistry.dispatch` via
+ * `readOnly` / `readOnlyCheck`; this file only ships the `submit_plan`
+ * escape hatch and the error type that carries the plan out of the
+ * registry without stuffing it into the message.
+ *
+ * We do not change `ImmutablePrefix.toolSpecs` when plan mode toggles —
+ * that would break Pillar 1's prefix cache. Instead the same full spec
+ * list stays pinned, and the registry enforces mode at dispatch time.
+ * The refusal string teaches the model the rule; cache hits stay
+ * intact.
+ */
+
+import type { ToolRegistry } from "../tools.js";
+
+/**
+ * Thrown by `submit_plan` when plan mode is active, carrying the plan
+ * text the TUI will render for the user's approval.
+ *
+ * Implements the `toToolResult` protocol so `ToolRegistry.dispatch`
+ * serializes the full plan into the tool-result JSON (not just the
+ * error message). The TUI parses `{ error, plan }` from the tool event
+ * and mounts the `PlanConfirm` picker.
+ */
+export class PlanProposedError extends Error {
+  readonly plan: string;
+  constructor(plan: string) {
+    super(
+      "PlanProposedError: plan submitted. STOP calling tools now — the TUI has shown the plan to the user. Wait for their next message; it will either approve (you'll then implement the plan), request a refinement (you should explore more and submit an updated plan), or cancel (drop the plan and ask what they want instead). Don't call any tools in the meantime.",
+    );
+    this.name = "PlanProposedError";
+    this.plan = plan;
+  }
+
+  /**
+   * Structured tool-result shape. Consumed by the TUI to extract the
+   * plan without regex-scraping the error message.
+   */
+  toToolResult(): { error: string; plan: string } {
+    return { error: `${this.name}: ${this.message}`, plan: this.plan };
+  }
+}
+
+export interface PlanToolOptions {
+  /**
+   * Optional side-channel callback fired when the model submits a plan.
+   * The TUI uses this to preview the plan in real time (the tool-result
+   * event is also emitted; this is just earlier and friendlier to
+   * test harnesses that don't want to parse JSON).
+   */
+  onPlanSubmitted?: (plan: string) => void;
+}
+
+export function registerPlanTool(registry: ToolRegistry, opts: PlanToolOptions = {}): ToolRegistry {
+  registry.register({
+    name: "submit_plan",
+    description:
+      "Submit a concrete plan to the user for review before executing. Use this for tasks that warrant a review gate — multi-file refactors, architecture changes, anything that would be expensive or confusing to undo. Skip it for small fixes (one-line typo, obvious bug with a clear fix) — just make the change. The user will either approve (you then implement it), ask for refinement, or cancel. If the user has already enabled /plan mode, writes are blocked at dispatch and you MUST use this. Write the plan as markdown with a one-line summary, a bulleted list of files to touch and what will change, and any risks or open questions.",
+    readOnly: true,
+    parameters: {
+      type: "object",
+      properties: {
+        plan: {
+          type: "string",
+          description:
+            "Markdown-formatted plan. Lead with a one-sentence summary. Then a file-by-file breakdown of what you'll change and why. Flag any risks or open questions at the end so the user can weigh in before you start.",
+        },
+      },
+      required: ["plan"],
+    },
+    fn: async (args: { plan: string }) => {
+      const plan = (args?.plan ?? "").trim();
+      if (!plan) {
+        throw new Error("submit_plan: empty plan — write a markdown plan and try again.");
+      }
+      // Always fire the picker, not just inside plan mode. Plan mode's
+      // role is the *stronger* constraint — it forces you into read-only
+      // until you submit. Outside plan mode, submit_plan is your own
+      // call: use it when the task is large enough to deserve a review
+      // gate (multi-file refactors, architecture changes, anything
+      // that would be expensive to undo), skip it for small fixes.
+      opts.onPlanSubmitted?.(plan);
+      throw new PlanProposedError(plan);
+    },
+  });
+  return registry;
+}

src/tools/shell.ts

@@ -0,0 +1,509 @@
+/**
+ * Native shell tool — lets the model run commands inside the sandbox
+ * root so it can actually verify its own work (run tests, check git
+ * status, inspect a lockfile, etc.). Without this the coding-mode
+ * loop is "write code, hope it works, ask the user to run it" —
+ * defeats the purpose.
+ *
+ * Safety model:
+ *   - Commands run with `cwd` pinned to the registered root. No
+ *     path traversal via the command itself is enforced (users can
+ *     `cat ../outside.txt`); the trust boundary is the directory
+ *     you opened Reasonix from.
+ *   - Commands are matched against a read-only / testing allowlist.
+ *     Allowlisted commands execute immediately and return stdout +
+ *     stderr merged. Everything else throws with a clear message —
+ *     the UI translates that into an `/apply`-style confirm gate so
+ *     the user sees the exact command before it runs.
+ *   - Default timeout: 60s. Output cap: matches tool-result budget.
+ *   - Every command that DOES run is spawned with `shell: false` and
+ *     a tokenized argv — no string-to-shell interpolation, so the
+ *     model can't accidentally construct a chained `rm` via quoting.
+ *
+ * This is intentionally narrower than what Claude Code / Aider ship:
+ * we gate more commands behind confirmation by default. Users who
+ * trust the model can widen the allowlist by instantiating their
+ * own tool registry.
+ */
+
+import { type SpawnOptions, spawn } from "node:child_process";
+import { existsSync, statSync } from "node:fs";
+import * as pathMod from "node:path";
+import type { ToolRegistry } from "../tools.js";
+
+export interface ShellToolsOptions {
+  /** Directory to run commands in. Must be an absolute path. */
+  rootDir: string;
+  /** Seconds before an individual command is killed. Default: 60. */
+  timeoutSec?: number;
+  /**
+   * Per-command stdout+stderr cap in characters. Default: 32_000 to
+   * match the tool-result budget.
+   */
+  maxOutputChars?: number;
+  /**
+   * Extra command-name prefixes the user explicitly trusts. Added on
+   * top of the built-in allowlist. Examples: `["my-ci-script", "lint"]`.
+   *
+   * Accepts either a fixed array (captured once at registration) or a
+   * getter called on every dispatch. The getter form is load-bearing:
+   * when the TUI's `ShellConfirm` writes a new prefix to config mid-
+   * session, the running `run_command` must pick it up immediately —
+   * otherwise the same command gets re-prompted until the next launch.
+   */
+  extraAllowed?: readonly string[] | (() => readonly string[]);
+  /**
+   * When true, skip the allowlist entirely and auto-run every command.
+   * Off by default — this is an escape hatch for non-interactive use
+   * (CI, benchmarks) where a human can't be in the loop to confirm.
+   */
+  allowAll?: boolean;
+}
+
+const DEFAULT_TIMEOUT_SEC = 60;
+const DEFAULT_MAX_OUTPUT_CHARS = 32_000;
+
+/**
+ * Command prefixes we consider safe to run without asking the user.
+ * Rule of thumb: read-only reports, or test runners whose failure mode
+ * is "exit 1 with output." Nothing that can rewrite state, escalate,
+ * or touch the network.
+ */
+const BUILTIN_ALLOWLIST: ReadonlyArray<string> = [
+  // Repo inspection
+  "git status",
+  "git diff",
+  "git log",
+  "git show",
+  "git blame",
+  "git branch",
+  "git remote",
+  "git rev-parse",
+  "git config --get",
+  // Filesystem inspection
+  "ls",
+  "pwd",
+  "cat",
+  "head",
+  "tail",
+  "wc",
+  "file",
+  "tree",
+  "find",
+  "grep",
+  "rg",
+  // Language version probes
+  "node --version",
+  "node -v",
+  "npm --version",
+  "npx --version",
+  "python --version",
+  "python3 --version",
+  "cargo --version",
+  "go version",
+  "rustc --version",
+  "deno --version",
+  "bun --version",
+  // Test runners (non-destructive by convention)
+  "npm test",
+  "npm run test",
+  "npx vitest run",
+  "npx vitest",
+  "npx jest",
+  "pytest",
+  "python -m pytest",
+  "cargo test",
+  "cargo check",
+  "cargo clippy",
+  "go test",
+  "go vet",
+  "deno test",
+  "bun test",
+  // Linters / typecheckers (read-only by convention)
+  "npm run lint",
+  "npm run typecheck",
+  "npx tsc --noEmit",
+  "npx biome check",
+  "npx eslint",
+  "npx prettier --check",
+  "ruff",
+  "mypy",
+];
+
+/**
+ * Tokenize a shell-ish command string into argv. Handles single/double
+ * quoting; rejects unclosed quotes. Does NOT expand env vars, globs,
+ * backticks, or `$(…)` — the goal is to prevent the model from
+ * accidentally (or not) sneaking arbitrary shells past the allowlist
+ * via concatenation. Exported for testing.
+ */
+export function tokenizeCommand(cmd: string): string[] {
+  const out: string[] = [];
+  let cur = "";
+  let quote: '"' | "'" | null = null;
+  for (let i = 0; i < cmd.length; i++) {
+    const ch = cmd[i]!;
+    if (quote) {
+      if (ch === quote) {
+        quote = null;
+      } else if (ch === "\\" && quote === '"' && i + 1 < cmd.length) {
+        cur += cmd[++i];
+      } else {
+        cur += ch;
+      }
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      continue;
+    }
+    if (ch === " " || ch === "\t") {
+      if (cur.length > 0) {
+        out.push(cur);
+        cur = "";
+      }
+      continue;
+    }
+    cur += ch;
+  }
+  if (quote) throw new Error(`unclosed ${quote} in command`);
+  if (cur.length > 0) out.push(cur);
+  return out;
+}
+
+/**
+ * Return true when `cmd` matches an allowlisted prefix. Exported for
+ * testing. Match is on the space-normalized leading tokens so
+ * `git   status  -s ` and `git status` both match `git status`.
+ */
+export function isAllowed(cmd: string, extra: readonly string[] = []): boolean {
+  const normalized = cmd.trim().replace(/\s+/g, " ");
+  const allowlist = [...BUILTIN_ALLOWLIST, ...extra];
+  for (const prefix of allowlist) {
+    if (normalized === prefix) return true;
+    if (normalized.startsWith(`${prefix} `)) return true;
+  }
+  return false;
+}
+
+export interface RunCommandResult {
+  exitCode: number | null;
+  /** Combined stdout+stderr, truncated to `maxOutputChars` with a marker. */
+  output: string;
+  /** True when the process was killed for exceeding `timeoutSec`. */
+  timedOut: boolean;
+}
+
+export async function runCommand(
+  cmd: string,
+  opts: {
+    cwd: string;
+    timeoutSec?: number;
+    maxOutputChars?: number;
+    signal?: AbortSignal;
+  },
+): Promise<RunCommandResult> {
+  const argv = tokenizeCommand(cmd);
+  if (argv.length === 0) throw new Error("run_command: empty command");
+  const timeoutMs = (opts.timeoutSec ?? DEFAULT_TIMEOUT_SEC) * 1000;
+  const maxChars = opts.maxOutputChars ?? DEFAULT_MAX_OUTPUT_CHARS;
+
+  const spawnOpts: SpawnOptions = {
+    cwd: opts.cwd,
+    shell: false, // no shell-expansion — see header comment
+    windowsHide: true,
+    env: process.env,
+  };
+
+  // Windows: two layered fixes on top of shell:false —
+  //   1. Resolve bare command names via PATH × PATHEXT (CreateProcess
+  //      ignores PATHEXT, so `npm` alone misses `npm.cmd`).
+  //   2. Node 21.7.3+ (CVE-2024-27980) refuses to spawn `.cmd`/`.bat`
+  //      directly even with shell:false and safe args — throws
+  //      EINVAL at invocation time. Wrap those via `cmd.exe /d /s /c`
+  //      with verbatim args + manual quoting, so shell metacharacters
+  //      in arguments stay literal.
+  // Unix path is unchanged.
+  const { bin, args, spawnOverrides } = prepareSpawn(argv);
+  const effectiveSpawnOpts = { ...spawnOpts, ...spawnOverrides };
+
+  return await new Promise<RunCommandResult>((resolve, reject) => {
+    let child: import("node:child_process").ChildProcess;
+    try {
+      child = spawn(bin, args, effectiveSpawnOpts);
+    } catch (err) {
+      reject(err);
+      return;
+    }
+    let buf = "";
+    let timedOut = false;
+    const killTimer = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGKILL");
+    }, timeoutMs);
+    const onAbort = () => child.kill("SIGKILL");
+    opts.signal?.addEventListener("abort", onAbort, { once: true });
+
+    const onData = (chunk: Buffer | string) => {
+      buf += chunk.toString();
+      // Soft cap: we let the process keep running (killing early could
+      // hide a real failure), but we stop growing the buffer past 2×
+      // the cap so a chatty test can't OOM us.
+      if (buf.length > maxChars * 2) buf = `${buf.slice(0, maxChars * 2)}`;
+    };
+    child.stdout?.on("data", onData);
+    child.stderr?.on("data", onData);
+    child.on("error", (err) => {
+      clearTimeout(killTimer);
+      opts.signal?.removeEventListener("abort", onAbort);
+      reject(err);
+    });
+    child.on("close", (code) => {
+      clearTimeout(killTimer);
+      opts.signal?.removeEventListener("abort", onAbort);
+      const output =
+        buf.length > maxChars
+          ? `${buf.slice(0, maxChars)}\n\n[… truncated ${buf.length - maxChars} chars …]`
+          : buf;
+      resolve({ exitCode: code, output, timedOut });
+    });
+  });
+}
+
+/**
+ * Test/override hooks for {@link resolveExecutable}. Omitting any field
+ * falls through to the real process globals — the runtime call path
+ * uses defaults; tests inject `platform` + `env` + `isFile` to exercise
+ * Windows-specific lookup from a Linux CI runner without touching
+ * actual fs.
+ */
+export interface ResolveExecutableOptions {
+  platform?: NodeJS.Platform;
+  env?: { PATH?: string; PATHEXT?: string };
+  /** Predicate swapped in by tests to avoid creating real files. */
+  isFile?: (path: string) => boolean;
+  /** Path.join used for the lookup. Defaults to Windows semantics on Windows. */
+  pathDelimiter?: string;
+}
+
+/**
+ * Resolve a bare command name (e.g. `npm`) to its on-disk path via
+ * PATH × PATHEXT on Windows. Returns the input unchanged on non-Windows
+ * platforms, when the input is already a path (contains `/`, `\`, or is
+ * absolute), or when no match is found in PATH × PATHEXT (caller gets a
+ * natural ENOENT from spawn, which surfaces cleanly).
+ *
+ * Why this exists: `child_process.spawn` with `shell: false` invokes
+ * Windows `CreateProcess`, which does not honor `PATHEXT` and does not
+ * search for `.cmd` / `.bat` wrappers. Node-ecosystem tools ship as
+ * `npm.cmd`, `npx.cmd`, `yarn.cmd`, etc., so a bare `npm` fails with
+ * ENOENT under `shell: false`. Flipping to `shell: true` would work
+ * but reintroduces shell-expansion (pipes, redirects, chained cmds)
+ * that the tool was explicitly designed to forbid. This resolver
+ * threads the needle.
+ */
+export function resolveExecutable(cmd: string, opts: ResolveExecutableOptions = {}): string {
+  const platform = opts.platform ?? process.platform;
+  if (platform !== "win32") return cmd;
+  if (!cmd) return cmd;
+  // Already a path fragment — spawn handles these natively.
+  if (cmd.includes("/") || cmd.includes("\\") || pathMod.isAbsolute(cmd)) return cmd;
+  // If the model wrote `npm.cmd` explicitly, respect that verbatim.
+  if (pathMod.extname(cmd)) return cmd;
+
+  const env = opts.env ?? process.env;
+  const pathExt = (env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD")
+    .split(";")
+    .map((e) => e.trim())
+    .filter(Boolean);
+  const delimiter = opts.pathDelimiter ?? (platform === "win32" ? ";" : pathMod.delimiter);
+  const pathDirs = (env.PATH ?? "").split(delimiter).filter(Boolean);
+  const isFile = opts.isFile ?? defaultIsFile;
+
+  for (const dir of pathDirs) {
+    for (const ext of pathExt) {
+      // Force win32 join so CI tests that pass `platform: "win32"`
+      // from a Linux runner get backslash-joined paths; the real-
+      // Windows runtime path lands here too and gets the correct
+      // separator regardless of where pathMod defaults.
+      const full = pathMod.win32.join(dir, cmd + ext);
+      if (isFile(full)) return full;
+    }
+  }
+  return cmd;
+}
+
+function defaultIsFile(full: string): boolean {
+  try {
+    return existsSync(full) && statSync(full).isFile();
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Prepare `(bin, args, spawnOpts)` for the runCommand spawn call,
+ * applying Windows-specific workarounds for (a) PATHEXT lookup and
+ * (b) the CVE-2024-27980 prohibition on direct `.cmd`/`.bat` spawns.
+ *
+ * Exported so tests can assert the transformation without booting an
+ * actual child process.
+ */
+export function prepareSpawn(
+  argv: readonly string[],
+  opts: ResolveExecutableOptions = {},
+): { bin: string; args: string[]; spawnOverrides: SpawnOptions } {
+  const head = argv[0] ?? "";
+  const tail = argv.slice(1);
+  const platform = opts.platform ?? process.platform;
+  const resolved = resolveExecutable(head, opts);
+
+  if (platform !== "win32") {
+    return { bin: resolved, args: [...tail], spawnOverrides: {} };
+  }
+
+  // `.cmd` / `.bat` wrappers require cmd.exe on post-CVE Node.
+  if (/\.(cmd|bat)$/i.test(resolved)) {
+    const cmdline = [resolved, ...tail].map(quoteForCmdExe).join(" ");
+    return {
+      bin: "cmd.exe",
+      args: ["/d", "/s", "/c", cmdline],
+      // windowsVerbatimArguments prevents Node from re-quoting the /c
+      // payload — we've already composed an exact cmd.exe command
+      // line. Without this Node wraps our already-quoted string in
+      // another round of quotes and cmd.exe can't parse it.
+      spawnOverrides: { windowsVerbatimArguments: true },
+    };
+  }
+
+  // Bare command names that PATH × PATHEXT couldn't resolve to an
+  // on-disk file — these are almost always cmd.exe built-ins (`dir`,
+  // `echo`, `type`, `ver`, `vol`, `where`, `help`, …) which don't
+  // exist as standalone executables. Direct spawn crashes with ENOENT;
+  // routing through cmd.exe lets the built-in resolve, and if it's
+  // genuinely unknown the user gets the standard "'foo' is not
+  // recognized" message instead of a raw spawn failure.
+  if (isBareWindowsName(resolved) && resolved === head) {
+    const cmdline = [head, ...tail].map(quoteForCmdExe).join(" ");
+    return {
+      bin: "cmd.exe",
+      args: ["/d", "/s", "/c", cmdline],
+      spawnOverrides: { windowsVerbatimArguments: true },
+    };
+  }
+
+  return { bin: resolved, args: [...tail], spawnOverrides: {} };
+}
+
+/**
+ * True when `s` looks like a bare executable name — no path separator,
+ * no drive letter, no extension. Such names on Windows, when absent
+ * from PATH × PATHEXT, are almost always cmd.exe built-ins.
+ */
+function isBareWindowsName(s: string): boolean {
+  if (!s) return false;
+  if (s.includes("/") || s.includes("\\")) return false;
+  if (pathMod.isAbsolute(s)) return false;
+  if (pathMod.extname(s)) return false;
+  return true;
+}
+
+/**
+ * Quote an argument so cmd.exe parses it back as a single token. We
+ * always wrap in double quotes when the arg contains whitespace or
+ * any cmd.exe metacharacter, doubling embedded quotes per cmd.exe's
+ * `""` escape rule. Bare alphanumeric args pass through unquoted for
+ * readability in logs.
+ *
+ * Exported for test coverage of the quoting semantics.
+ */
+export function quoteForCmdExe(arg: string): string {
+  if (arg === "") return '""';
+  if (!/[\s"&|<>^%(),;!]/.test(arg)) return arg;
+  return `"${arg.replace(/"/g, '""')}"`;
+}
+
+/** Error thrown by `run_command` when the command isn't allowlisted. */
+export class NeedsConfirmationError extends Error {
+  readonly command: string;
+  constructor(command: string) {
+    super(
+      `run_command: "${command}" needs the user's approval before it runs. STOP calling tools now — the TUI has already prompted the user to press y (run) or n (deny). Wait for their next message; it will either be the command's output (if they approved) or an instruction to continue without it (if they denied). Don't retry the command or call other shell commands in the meantime.`,
+    );
+    this.name = "NeedsConfirmationError";
+    this.command = command;
+  }
+}
+
+export function registerShellTools(registry: ToolRegistry, opts: ShellToolsOptions): ToolRegistry {
+  const rootDir = pathMod.resolve(opts.rootDir);
+  const timeoutSec = opts.timeoutSec ?? DEFAULT_TIMEOUT_SEC;
+  const maxOutputChars = opts.maxOutputChars ?? DEFAULT_MAX_OUTPUT_CHARS;
+  // Resolved on every dispatch so newly-persisted "always allow"
+  // prefixes take effect inside the session that added them, not just
+  // on the next launch. Static arrays are wrapped into a constant
+  // getter so the call site below is uniform.
+  const getExtraAllowed: () => readonly string[] =
+    typeof opts.extraAllowed === "function"
+      ? opts.extraAllowed
+      : (() => {
+          const snapshot = opts.extraAllowed ?? [];
+          return () => snapshot;
+        })();
+  const allowAll = opts.allowAll ?? false;
+
+  registry.register({
+    name: "run_command",
+    description:
+      "Run a shell command in the project root and return its combined stdout+stderr. Common read-only inspection and test/lint/typecheck commands run immediately; anything that could mutate state, install dependencies, or touch the network is refused until the user confirms it in the TUI. Prefer this over asking the user to run a command manually — after edits, run the project's tests to verify.",
+    // Plan-mode gate: allow allowlisted commands through (git status,
+    // cargo check, ls, grep …) so the model can actually investigate
+    // during planning. Anything that would otherwise trigger a
+    // confirmation prompt is treated as "not read-only" and bounced.
+    readOnlyCheck: (args: { command?: unknown }) => {
+      if (allowAll) return true;
+      const cmd = typeof args?.command === "string" ? args.command.trim() : "";
+      if (!cmd) return false;
+      return isAllowed(cmd, getExtraAllowed());
+    },
+    parameters: {
+      type: "object",
+      properties: {
+        command: {
+          type: "string",
+          description:
+            "Full command line. Tokenized with POSIX-ish quoting; no shell expansion, no pipes, no redirects.",
+        },
+        timeoutSec: {
+          type: "integer",
+          description: `Override the default ${timeoutSec}s timeout for a single command.`,
+        },
+      },
+      required: ["command"],
+    },
+    fn: async (args: { command: string; timeoutSec?: number }, ctx) => {
+      const cmd = args.command.trim();
+      if (!cmd) throw new Error("run_command: empty command");
+      if (!allowAll && !isAllowed(cmd, getExtraAllowed())) {
+        throw new NeedsConfirmationError(cmd);
+      }
+      const effectiveTimeout = Math.max(1, Math.min(600, args.timeoutSec ?? timeoutSec));
+      const result = await runCommand(cmd, {
+        cwd: rootDir,
+        timeoutSec: effectiveTimeout,
+        maxOutputChars,
+        signal: ctx?.signal,
+      });
+      return formatCommandResult(cmd, result);
+    },
+  });
+
+  return registry;
+}
+
+export function formatCommandResult(cmd: string, r: RunCommandResult): string {
+  const header = r.timedOut
+    ? `$ ${cmd}\n[killed after timeout]`
+    : `$ ${cmd}\n[exit ${r.exitCode ?? "?"}]`;
+  return r.output ? `${header}\n${r.output}` : header;
+}

src/tools/skills.ts

@@ -0,0 +1,92 @@
+/**
+ * `run_skill` — load one user skill's body into the conversation.
+ *
+ * The Skills index (names + one-liners) is pinned in the system prompt
+ * by `applySkillsIndex`. That's enough context for the model to decide
+ * *which* skill to invoke, but the body is NOT in the prefix — calling
+ * this tool is how the body enters the turn. The tool result is the
+ * full markdown instruction block; the model reads it and continues
+ * the normal tool-use loop to follow whatever the skill prescribes.
+ *
+ * v1 deliberately ignores each skill's `allowed-tools` frontmatter:
+ * Reasonix's tool namespace (`filesystem`, `shell`, `web`) doesn't
+ * align with Claude Code's (`Read`, `Bash`, `Grep`) so a literal pass
+ * would give wrong answers. Skills written for Claude Code still run —
+ * the model reads the prose instructions and picks our equivalents.
+ */
+
+import { SkillStore } from "../skills.js";
+import type { ToolRegistry } from "../tools.js";
+
+export interface SkillToolsOptions {
+  /** Override `$HOME` — tests set this to a tmpdir. */
+  homeDir?: string;
+  /**
+   * Absolute project root — enables discovery of project-scope skills
+   * under `<projectRoot>/.reasonix/skills/`. Omit for chat mode (global
+   * scope only).
+   */
+  projectRoot?: string;
+}
+
+export function registerSkillTools(
+  registry: ToolRegistry,
+  opts: SkillToolsOptions = {},
+): ToolRegistry {
+  const store = new SkillStore({ homeDir: opts.homeDir, projectRoot: opts.projectRoot });
+
+  registry.register({
+    name: "run_skill",
+    description:
+      "Load the full body of a user-defined skill into this conversation. Call when the pinned Skills index (in the system prompt) lists a skill whose description matches what's being asked. Returns the skill's markdown instructions — read them and continue the loop, calling whatever filesystem / shell / web tools the skill's prose requires. Skills are user content; follow their instructions, but keep Reasonix's own safety rules (no destructive ops without confirmation, etc.).",
+    readOnly: true,
+    parameters: {
+      type: "object",
+      properties: {
+        name: {
+          type: "string",
+          description:
+            "Skill identifier as it appears in the pinned Skills index (e.g. 'review', 'security-review'). Case-sensitive.",
+        },
+        arguments: {
+          type: "string",
+          description:
+            "Optional free-form arguments the caller wants the skill to act on. Forwarded verbatim as an 'Arguments:' line appended to the skill body; the skill's own instructions decide how to consume them.",
+        },
+      },
+      required: ["name"],
+    },
+    fn: async (args: { name?: unknown; arguments?: unknown }) => {
+      const name = typeof args.name === "string" ? args.name.trim() : "";
+      if (!name) {
+        return JSON.stringify({ error: "run_skill requires a 'name' argument" });
+      }
+      const skill = store.read(name);
+      if (!skill) {
+        const available = store
+          .list()
+          .map((s) => s.name)
+          .join(", ");
+        return JSON.stringify({
+          error: `unknown skill: ${JSON.stringify(name)}`,
+          available: available || "(none — user has not defined any skills)",
+        });
+      }
+      const rawArgs = typeof args.arguments === "string" ? args.arguments.trim() : "";
+      const header = [
+        `# Skill: ${skill.name}`,
+        skill.description ? `> ${skill.description}` : "",
+        `(scope: ${skill.scope} · ${skill.path})`,
+      ]
+        .filter(Boolean)
+        .join("\n");
+      const argsBlock = rawArgs ? `\n\nArguments: ${rawArgs}` : "";
+      // The body is handed to the model verbatim. No truncation — the
+      // user authored it, we trust their length choice. The append-only
+      // log pays the token cost exactly once per invocation.
+      return `${header}\n\n${skill.body}${argsBlock}`;
+    },
+  });
+
+  return registry;
+}

src/tools/web.ts

@@ -0,0 +1,301 @@
+/**
+ * Built-in web search + fetch tools.
+ *
+ *   - `web_search(query, topK?)` — Mojeek's public search page. No API
+ *     key, no signup. We originally shipped this backed by DuckDuckGo's
+ *     HTML endpoint, but DDG started serving anti-bot interstitials
+ *     (HTTP 202 with a challenge page) for every unauthenticated POST.
+ *     Mojeek runs its own independent index, is bot-friendly, and
+ *     returns parseable HTML.
+ *   - `web_fetch(url)` — HTTP GET + naïve HTML-to-text extraction.
+ *
+ * Both are registered by default on `reasonix chat` / `reasonix code`;
+ * set `search: false` in config (or `REASONIX_SEARCH=off`) to turn
+ * them off. The model decides when to call them based on the query —
+ * no slash command required.
+ */
+
+import type { ToolRegistry } from "../tools.js";
+
+export interface SearchResult {
+  title: string;
+  url: string;
+  snippet: string;
+}
+
+export interface PageContent {
+  url: string;
+  title?: string;
+  text: string;
+  /** True when the extracted text was clipped to fit the cap. */
+  truncated: boolean;
+}
+
+export interface WebFetchOptions {
+  /** Max bytes of extracted text. Defaults to 32_000 to match tool-result cap. */
+  maxChars?: number;
+  /** Timeout in ms. Defaults to 15_000. */
+  timeoutMs?: number;
+  signal?: AbortSignal;
+}
+
+export interface WebSearchOptions {
+  topK?: number;
+  signal?: AbortSignal;
+}
+
+const DEFAULT_FETCH_MAX_CHARS = 32_000;
+const DEFAULT_FETCH_TIMEOUT_MS = 15_000;
+const DEFAULT_TOPK = 5;
+// Real-browser UA. Servers like Mojeek are bot-friendly but still gate
+// obvious scraper UAs; a stock Chrome string avoids the fast-path block.
+const USER_AGENT =
+  "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36";
+const MOJEEK_ENDPOINT = "https://www.mojeek.com/search";
+
+/**
+ * Search the public web via Mojeek. Returns up to `topK` ranked
+ * results with title, url, snippet.
+ *
+ * Mojeek is an independent index (not a Google/Bing front-end) which
+ * means coverage on niche or very recent topics can be thinner, but
+ * it's reliable from scripts and doesn't gate on cookies or sessions.
+ * If the response has 0 results we distinguish "truly empty" from
+ * "layout changed or blocked" so the caller isn't left guessing.
+ */
+export async function webSearch(
+  query: string,
+  opts: WebSearchOptions = {},
+): Promise<SearchResult[]> {
+  const topK = Math.max(1, Math.min(10, opts.topK ?? DEFAULT_TOPK));
+  const resp = await fetch(`${MOJEEK_ENDPOINT}?q=${encodeURIComponent(query)}`, {
+    headers: {
+      "User-Agent": USER_AGENT,
+      Accept: "text/html,application/xhtml+xml,application/xml;q=0.9",
+      "Accept-Language": "en-US,en;q=0.9",
+    },
+    signal: opts.signal,
+    redirect: "follow",
+  });
+  if (!resp.ok) throw new Error(`web_search ${resp.status}`);
+  const html = await resp.text();
+  const results = parseMojeekResults(html).slice(0, topK);
+  if (results.length === 0) {
+    if (/no results found|did not match any documents/i.test(html)) return [];
+    if (/captcha|verify you are human|access denied|forbidden/i.test(html)) {
+      throw new Error("web_search: Mojeek anti-bot page — rate-limited or blocked");
+    }
+    throw new Error(
+      `web_search: 0 results but response doesn't look like a real empty page (${html.length} chars, first 120: ${html.slice(0, 120).replace(/\s+/g, " ")})`,
+    );
+  }
+  return results;
+}
+
+/**
+ * Extract results from a Mojeek search page.
+ *
+ * Mojeek's stable shape (as of April 2026):
+ *   <a … class="ob" href="URL"> … breadcrumb … </a>
+ *   <h2><a class="title" href="URL">Title</a></h2>
+ *   <p class="s">snippet text …</p>
+ *
+ * We do two tolerant passes — title anchors, then snippet paragraphs —
+ * and pair them positionally. Attribute order inside a tag varies
+ * between versions, so each pass captures the whole element and we
+ * re-extract href / inner text with a second regex. Exported for
+ * unit testing against a fixture.
+ */
+export function parseMojeekResults(html: string): SearchResult[] {
+  const titles: string[] = [];
+  const titleAnchorRe = /<a\b[^>]*\bclass="title"[^>]*>[\s\S]*?<\/a>/g;
+  let m: RegExpExecArray | null;
+  while (true) {
+    m = titleAnchorRe.exec(html);
+    if (m === null) break;
+    titles.push(m[0]);
+  }
+
+  const snippets: string[] = [];
+  const snippetRe = /<p\b[^>]*\bclass="s"[^>]*>([\s\S]*?)<\/p>/g;
+  while (true) {
+    m = snippetRe.exec(html);
+    if (m === null) break;
+    snippets.push(m[1] ?? "");
+  }
+
+  const hrefRe = /href="([^"]+)"/;
+  const innerRe = /<a\b[^>]*>([\s\S]*?)<\/a>/;
+  const results: SearchResult[] = [];
+  for (let i = 0; i < titles.length; i++) {
+    const anchor = titles[i]!;
+    const hrefMatch = anchor.match(hrefRe);
+    const innerMatch = anchor.match(innerRe);
+    if (!hrefMatch?.[1]) continue;
+    results.push({
+      title: decodeHtmlEntities(stripHtml(innerMatch?.[1] ?? "")).trim(),
+      url: hrefMatch[1],
+      snippet: decodeHtmlEntities(stripHtml(snippets[i] ?? ""))
+        .replace(/\s+/g, " ")
+        .trim(),
+    });
+  }
+  return results;
+}
+
+/**
+ * Download a URL, strip HTML down to readable text, return it. Times
+ * out at 15s, caps extracted text at 32k chars to fit the tool-result
+ * budget.
+ */
+export async function webFetch(url: string, opts: WebFetchOptions = {}): Promise<PageContent> {
+  const maxChars = opts.maxChars ?? DEFAULT_FETCH_MAX_CHARS;
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_FETCH_TIMEOUT_MS;
+  const ctl = new AbortController();
+  const timer = setTimeout(() => ctl.abort(), timeoutMs);
+  // Forward the caller's abort too so an Esc during a long fetch is respected.
+  const cancel = () => ctl.abort();
+  opts.signal?.addEventListener("abort", cancel, { once: true });
+  let resp: Response;
+  try {
+    resp = await fetch(url, {
+      headers: { "User-Agent": USER_AGENT, Accept: "text/html,text/plain,*/*" },
+      signal: ctl.signal,
+      redirect: "follow",
+    });
+  } finally {
+    clearTimeout(timer);
+    opts.signal?.removeEventListener("abort", cancel);
+  }
+  if (!resp.ok) throw new Error(`web_fetch ${resp.status} for ${url}`);
+  const contentType = resp.headers.get("content-type") ?? "";
+  const raw = await resp.text();
+  const title = extractTitle(raw);
+  const text = contentType.includes("text/html") ? htmlToText(raw) : raw;
+  const truncated = text.length > maxChars;
+  const finalText = truncated
+    ? `${text.slice(0, maxChars)}\n\n[… truncated ${text.length - maxChars} chars …]`
+    : text;
+  return { url, title, text: finalText, truncated };
+}
+
+/**
+ * Strip HTML to readable text. Removes scripts/styles/nav/footer/aside
+ * blocks first, then tags, then collapses whitespace. Not a Readability
+ * clone — purpose-built to keep the extracted text small enough for the
+ * tool-result budget while preserving paragraph breaks.
+ */
+export function htmlToText(html: string): string {
+  let s = html;
+  s = s.replace(/<script[\s\S]*?<\/script>/gi, "");
+  s = s.replace(/<style[\s\S]*?<\/style>/gi, "");
+  s = s.replace(/<noscript[\s\S]*?<\/noscript>/gi, "");
+  s = s.replace(/<nav[\s\S]*?<\/nav>/gi, "");
+  s = s.replace(/<footer[\s\S]*?<\/footer>/gi, "");
+  s = s.replace(/<aside[\s\S]*?<\/aside>/gi, "");
+  s = s.replace(/<svg[\s\S]*?<\/svg>/gi, "");
+  // Preserve paragraph breaks by turning common block tags into newlines.
+  s = s.replace(/<\/?(p|div|br|h[1-6]|li|tr|section|article)\b[^>]*>/gi, "\n");
+  s = s.replace(/<[^>]+>/g, "");
+  s = decodeHtmlEntities(s);
+  s = s.replace(/[ \t]+/g, " ");
+  s = s.replace(/\n[ \t]+/g, "\n");
+  s = s.replace(/\n{3,}/g, "\n\n");
+  return s.trim();
+}
+
+function stripHtml(s: string): string {
+  return s.replace(/<[^>]+>/g, "");
+}
+
+function decodeHtmlEntities(s: string): string {
+  return s
+    .replace(/&nbsp;/g, " ")
+    .replace(/&amp;/g, "&")
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&quot;/g, '"')
+    .replace(/&#39;/g, "'");
+}
+
+function extractTitle(html: string): string | undefined {
+  const m = html.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
+  if (!m?.[1]) return undefined;
+  return m[1].replace(/\s+/g, " ").trim() || undefined;
+}
+
+export interface WebToolsOptions {
+  /** Default top-K for `web_search` when the model doesn't specify. */
+  defaultTopK?: number;
+  /** Byte cap for `web_fetch` extracted text. */
+  maxFetchChars?: number;
+}
+
+/**
+ * Register `web_search` + `web_fetch` on a ToolRegistry. The model
+ * invokes them automatically when a question needs current info —
+ * no slash command from the user is required.
+ */
+export function registerWebTools(registry: ToolRegistry, opts: WebToolsOptions = {}): ToolRegistry {
+  const defaultTopK = opts.defaultTopK ?? DEFAULT_TOPK;
+  const maxFetchChars = opts.maxFetchChars ?? DEFAULT_FETCH_MAX_CHARS;
+
+  registry.register({
+    name: "web_search",
+    description:
+      "Search the public web. Returns ranked results with title, url, and snippet. Use this when the question needs information more current than your training data, when you're unsure of a factual detail, or when the user asks about a specific webpage/library/release you haven't seen.",
+    readOnly: true,
+    parameters: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "Natural-language search query." },
+        topK: {
+          type: "integer",
+          description: `Number of results to return (1..10). Default ${defaultTopK}.`,
+        },
+      },
+      required: ["query"],
+    },
+    fn: async (args: { query: string; topK?: number }, ctx) => {
+      const results = await webSearch(args.query, {
+        topK: args.topK ?? defaultTopK,
+        signal: ctx?.signal,
+      });
+      return formatSearchResults(args.query, results);
+    },
+  });
+
+  registry.register({
+    name: "web_fetch",
+    description:
+      "Download a URL and return its visible text content (HTML pages get scripts/styles/nav stripped). Truncated at the tool-result cap. Use after web_search when a snippet isn't enough.",
+    readOnly: true,
+    parameters: {
+      type: "object",
+      properties: {
+        url: { type: "string", description: "Absolute http:// or https:// URL." },
+      },
+      required: ["url"],
+    },
+    fn: async (args: { url: string }, ctx) => {
+      if (!/^https?:\/\//i.test(args.url)) {
+        throw new Error("web_fetch: url must start with http:// or https://");
+      }
+      const page = await webFetch(args.url, { maxChars: maxFetchChars, signal: ctx?.signal });
+      const header = page.title ? `${page.title}\n${page.url}` : page.url;
+      return `${header}\n\n${page.text}`;
+    },
+  });
+
+  return registry;
+}
+
+export function formatSearchResults(query: string, results: SearchResult[]): string {
+  const lines: string[] = [`query: ${query}`, `\nresults (${results.length}):`];
+  results.forEach((r, i) => {
+    lines.push(`\n${i + 1}. ${r.title}`);
+    lines.push(`   ${r.url}`);
+    if (r.snippet) lines.push(`   ${r.snippet}`);
+  });
+  return lines.join("\n");
+}

src/transcript.ts

@@ -17,6 +17,7 @@
  */
 
 import { type WriteStream, createWriteStream, readFileSync } from "node:fs";
+import type { TypedPlanState } from "./harvest.js";
 import type { LoopEvent } from "./loop.js";
 import type { RawUsage } from "./types.js";
 
@@ -45,6 +46,13 @@ export interface TranscriptRecord {
    * stability, not to a different system prompt.
    */
   prefixHash?: string;
+  /**
+   * Structured plan state extracted by the Pillar 2 harvester. Present on
+   * assistant_final records when harvest was enabled and produced non-empty
+   * state. Omitted entirely when harvest is off or produced nothing —
+   * absence means "no data", not "empty plan".
+   */
+  planState?: TypedPlanState;
   /** Optional error message (role === "error"). */
   error?: string;
 }
@@ -92,6 +100,16 @@ export function recordFromLoopEvent(
   if (ev.toolName !== undefined) rec.tool = ev.toolName;
   if (ev.toolArgs !== undefined) rec.args = ev.toolArgs;
   if (ev.error !== undefined) rec.error = ev.error;
+  // Only persist non-empty plan state — empty harvest output is indistinguishable
+  // from "harvest was off" for replay purposes, and saves transcript bytes.
+  if (ev.planState && !isPlanStateEmptyShape(ev.planState)) {
+    rec.planState = {
+      subgoals: [...ev.planState.subgoals],
+      hypotheses: [...ev.planState.hypotheses],
+      uncertainties: [...ev.planState.uncertainties],
+      rejectedPaths: [...ev.planState.rejectedPaths],
+    };
+  }
   if (ev.stats) {
     rec.usage = {
       prompt_tokens: ev.stats.usage.promptTokens,
@@ -152,6 +170,15 @@ export function readTranscript(path: string): ReadTranscriptResult {
   return parseTranscript(raw);
 }
 
+function isPlanStateEmptyShape(s: TypedPlanState): boolean {
+  return (
+    s.subgoals.length === 0 &&
+    s.hypotheses.length === 0 &&
+    s.uncertainties.length === 0 &&
+    s.rejectedPaths.length === 0
+  );
+}
+
 export function parseTranscript(raw: string): ReadTranscriptResult {
   const out: ReadTranscriptResult = { meta: null, records: [] };
   for (const line of raw.split(/\r?\n/)) {

src/user-memory.ts

@@ -0,0 +1,395 @@
+/**
+ * User memory — `~/.reasonix/memory/` markdown notes pinned into the
+ * immutable-prefix system prompt across sessions.
+ *
+ * Two scopes:
+ *   - `global`  → `~/.reasonix/memory/global/`         (cross-project)
+ *   - `project` → `~/.reasonix/memory/<hash>/`          (per sandbox root)
+ *
+ * Each scope has an always-loaded `MEMORY.md` index plus zero-or-more
+ * `<name>.md` detail files loaded on demand via `recall_memory`.
+ *
+ * Distinct from `src/project-memory.ts` (REASONIX.md) in purpose:
+ *   REASONIX.md        is committable, team-shared project memory.
+ *   ~/.reasonix/memory is user-private memory, never committed.
+ */
+
+import { createHash } from "node:crypto";
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { applyProjectMemory, memoryEnabled } from "./project-memory.js";
+import { applySkillsIndex } from "./skills.js";
+
+export const USER_MEMORY_DIR = "memory";
+export const MEMORY_INDEX_FILE = "MEMORY.md";
+/** Cap on the index file content loaded into the prefix, per scope. */
+export const MEMORY_INDEX_MAX_CHARS = 4000;
+
+export type MemoryType = "user" | "feedback" | "project" | "reference";
+export type MemoryScope = "global" | "project";
+
+export interface MemoryEntry {
+  name: string;
+  type: MemoryType;
+  scope: MemoryScope;
+  description: string;
+  body: string;
+  /** ISO date string (YYYY-MM-DD). */
+  createdAt: string;
+}
+
+export interface MemoryStoreOptions {
+  /** Override `~/.reasonix` — tests set this to a tmpdir. */
+  homeDir?: string;
+  /** Absolute sandbox root. Required to use `scope: "project"`. */
+  projectRoot?: string;
+}
+
+export interface WriteInput {
+  name: string;
+  type: MemoryType;
+  scope: MemoryScope;
+  description: string;
+  body: string;
+}
+
+const VALID_NAME = /^[a-zA-Z0-9_-][a-zA-Z0-9_.-]{1,38}[a-zA-Z0-9]$/;
+
+/**
+ * Throws on filename injection attempts (`../foo`, `foo/bar`, leading
+ * dots, etc.). Allowed: 3-40 chars, alnum + `_` + `-` + interior `.`.
+ */
+export function sanitizeMemoryName(raw: string): string {
+  const trimmed = String(raw ?? "").trim();
+  if (!VALID_NAME.test(trimmed)) {
+    throw new Error(
+      `invalid memory name: ${JSON.stringify(raw)} — must be 3-40 chars, alnum/_/-, no path separators`,
+    );
+  }
+  return trimmed;
+}
+
+/** Stable 16-hex-char hash of an absolute sandbox root path. */
+export function projectHash(rootDir: string): string {
+  const abs = resolve(rootDir);
+  return createHash("sha1").update(abs).digest("hex").slice(0, 16);
+}
+
+function scopeDir(opts: { homeDir: string; scope: MemoryScope; projectRoot?: string }): string {
+  if (opts.scope === "global") {
+    return join(opts.homeDir, USER_MEMORY_DIR, "global");
+  }
+  if (!opts.projectRoot) {
+    throw new Error("scope=project requires a projectRoot on MemoryStore");
+  }
+  return join(opts.homeDir, USER_MEMORY_DIR, projectHash(opts.projectRoot));
+}
+
+function ensureDir(p: string): void {
+  if (!existsSync(p)) mkdirSync(p, { recursive: true });
+}
+
+/**
+ * Parse a `---` frontmatter block off the top of a markdown string.
+ * Tolerates missing frontmatter, returning `{}` for data and the full
+ * string as body. Only recognizes the simple `key: value` shape — no
+ * quoting, no multi-line, no YAML features. Matches what we emit.
+ */
+function parseFrontmatter(raw: string): { data: Record<string, string>; body: string } {
+  const lines = raw.split(/\r?\n/);
+  if (lines[0] !== "---") return { data: {}, body: raw };
+  const end = lines.indexOf("---", 1);
+  if (end < 0) return { data: {}, body: raw };
+  const data: Record<string, string> = {};
+  for (let i = 1; i < end; i++) {
+    const line = lines[i];
+    if (!line) continue;
+    const m = line.match(/^([a-zA-Z_][a-zA-Z0-9_-]*):\s*(.*)$/);
+    if (m?.[1]) data[m[1]] = (m[2] ?? "").trim();
+  }
+  return {
+    data,
+    body: lines
+      .slice(end + 1)
+      .join("\n")
+      .replace(/^\n+/, ""),
+  };
+}
+
+function formatFrontmatter(e: WriteInput & { createdAt: string }): string {
+  return [
+    "---",
+    `name: ${e.name}`,
+    `description: ${e.description.replace(/\n/g, " ")}`,
+    `type: ${e.type}`,
+    `scope: ${e.scope}`,
+    `created: ${e.createdAt}`,
+    "---",
+    "",
+  ].join("\n");
+}
+
+function todayIso(): string {
+  const d = new Date();
+  return d.toISOString().slice(0, 10);
+}
+
+/**
+ * A `MEMORY.md` index line for one entry. One-liner, under ~150 chars.
+ * `description` is truncated if it would push past the soft limit.
+ */
+function indexLine(e: Pick<MemoryEntry, "name" | "description">): string {
+  const safeDesc = e.description.replace(/\n/g, " ").trim();
+  const max = 130 - e.name.length;
+  const clipped = safeDesc.length > max ? `${safeDesc.slice(0, Math.max(1, max - 1))}…` : safeDesc;
+  return `- [${e.name}](${e.name}.md) — ${clipped}`;
+}
+
+export class MemoryStore {
+  private readonly homeDir: string;
+  private readonly projectRoot: string | undefined;
+
+  constructor(opts: MemoryStoreOptions = {}) {
+    this.homeDir = opts.homeDir ?? join(homedir(), ".reasonix");
+    this.projectRoot = opts.projectRoot ? resolve(opts.projectRoot) : undefined;
+  }
+
+  /** Directory this store writes `scope` files into, creating it if needed. */
+  dir(scope: MemoryScope): string {
+    const d = scopeDir({ homeDir: this.homeDir, scope, projectRoot: this.projectRoot });
+    ensureDir(d);
+    return d;
+  }
+
+  /** Absolute path to a memory file (no existence check). */
+  pathFor(scope: MemoryScope, name: string): string {
+    return join(this.dir(scope), `${sanitizeMemoryName(name)}.md`);
+  }
+
+  /** True iff this store is configured with a project scope available. */
+  hasProjectScope(): boolean {
+    return this.projectRoot !== undefined;
+  }
+
+  /**
+   * Read the `MEMORY.md` index for a scope. Returns post-cap content
+   * (with a truncation marker if clipped), or `null` when absent / empty.
+   */
+  loadIndex(
+    scope: MemoryScope,
+  ): { content: string; originalChars: number; truncated: boolean } | null {
+    if (scope === "project" && !this.projectRoot) return null;
+    const file = join(
+      scopeDir({ homeDir: this.homeDir, scope, projectRoot: this.projectRoot }),
+      MEMORY_INDEX_FILE,
+    );
+    if (!existsSync(file)) return null;
+    let raw: string;
+    try {
+      raw = readFileSync(file, "utf8");
+    } catch {
+      return null;
+    }
+    const trimmed = raw.trim();
+    if (!trimmed) return null;
+    const originalChars = trimmed.length;
+    const truncated = originalChars > MEMORY_INDEX_MAX_CHARS;
+    const content = truncated
+      ? `${trimmed.slice(0, MEMORY_INDEX_MAX_CHARS)}\n… (truncated ${originalChars - MEMORY_INDEX_MAX_CHARS} chars)`
+      : trimmed;
+    return { content, originalChars, truncated };
+  }
+
+  /** Read one memory file's body (frontmatter stripped). Throws if missing. */
+  read(scope: MemoryScope, name: string): MemoryEntry {
+    const file = this.pathFor(scope, name);
+    if (!existsSync(file)) {
+      throw new Error(`memory not found: scope=${scope} name=${name}`);
+    }
+    const raw = readFileSync(file, "utf8");
+    const { data, body } = parseFrontmatter(raw);
+    return {
+      name: data.name ?? name,
+      type: (data.type as MemoryType) ?? "project",
+      scope: (data.scope as MemoryScope) ?? scope,
+      description: data.description ?? "",
+      body: body.trim(),
+      createdAt: data.created ?? "",
+    };
+  }
+
+  /**
+   * List every memory in this store. Scans both scopes (skips project
+   * scope if unconfigured). Silently skips malformed files; the index
+   * must stay queryable even if one file is hand-edited into nonsense.
+   */
+  list(): MemoryEntry[] {
+    const out: MemoryEntry[] = [];
+    const scopes: MemoryScope[] = this.projectRoot ? ["global", "project"] : ["global"];
+    for (const scope of scopes) {
+      const dir = scopeDir({ homeDir: this.homeDir, scope, projectRoot: this.projectRoot });
+      if (!existsSync(dir)) continue;
+      let entries: string[];
+      try {
+        entries = readdirSync(dir);
+      } catch {
+        continue;
+      }
+      for (const entry of entries) {
+        if (entry === MEMORY_INDEX_FILE) continue;
+        if (!entry.endsWith(".md")) continue;
+        const name = entry.slice(0, -3);
+        try {
+          out.push(this.read(scope, name));
+        } catch {
+          // malformed file — skip rather than fail the whole list
+        }
+      }
+    }
+    return out;
+  }
+
+  /**
+   * Write a new memory (or overwrite existing). Creates the scope dir,
+   * writes the `.md` file, and regenerates `MEMORY.md`. Returns the
+   * absolute path written to.
+   */
+  write(input: WriteInput): string {
+    if (input.scope === "project" && !this.projectRoot) {
+      throw new Error("cannot write project-scoped memory: no projectRoot configured");
+    }
+    const name = sanitizeMemoryName(input.name);
+    const desc = String(input.description ?? "").trim();
+    if (!desc) throw new Error("memory description cannot be empty");
+    const body = String(input.body ?? "").trim();
+    if (!body) throw new Error("memory body cannot be empty");
+    const entry: WriteInput & { createdAt: string } = {
+      ...input,
+      name,
+      description: desc,
+      body,
+      createdAt: todayIso(),
+    };
+    const dir = this.dir(input.scope);
+    const file = join(dir, `${name}.md`);
+    const content = `${formatFrontmatter(entry)}${body}\n`;
+    writeFileSync(file, content, "utf8");
+    this.regenerateIndex(input.scope);
+    return file;
+  }
+
+  /** Delete one memory + its index line. No-op if the file is already gone. */
+  delete(scope: MemoryScope, rawName: string): boolean {
+    if (scope === "project" && !this.projectRoot) {
+      throw new Error("cannot delete project-scoped memory: no projectRoot configured");
+    }
+    const file = this.pathFor(scope, rawName);
+    if (!existsSync(file)) return false;
+    unlinkSync(file);
+    this.regenerateIndex(scope);
+    return true;
+  }
+
+  /**
+   * Rebuild `MEMORY.md` from the `.md` files currently in the scope dir.
+   * Called after every write/delete. Sorted by name for stable prefix
+   * hashing — two stores with the same set of files produce byte-identical
+   * MEMORY.md content, keeping the cache prefix reproducible.
+   */
+  private regenerateIndex(scope: MemoryScope): void {
+    const dir = scopeDir({ homeDir: this.homeDir, scope, projectRoot: this.projectRoot });
+    if (!existsSync(dir)) return;
+    let files: string[];
+    try {
+      files = readdirSync(dir);
+    } catch {
+      return;
+    }
+    const mdFiles = files
+      .filter((f) => f !== MEMORY_INDEX_FILE && f.endsWith(".md"))
+      .sort((a, b) => a.localeCompare(b));
+    const indexPath = join(dir, MEMORY_INDEX_FILE);
+    if (mdFiles.length === 0) {
+      if (existsSync(indexPath)) unlinkSync(indexPath);
+      return;
+    }
+    const lines: string[] = [];
+    for (const f of mdFiles) {
+      const name = f.slice(0, -3);
+      try {
+        const entry = this.read(scope, name);
+        lines.push(indexLine({ name: entry.name || name, description: entry.description }));
+      } catch {
+        // Malformed: still surface it in the index so the user notices.
+        lines.push(`- [${name}](${name}.md) — (malformed, check frontmatter)`);
+      }
+    }
+    writeFileSync(indexPath, `${lines.join("\n")}\n`, "utf8");
+  }
+}
+
+/**
+ * Append `MEMORY_GLOBAL` and (optionally) `MEMORY_PROJECT` blocks to
+ * `basePrompt`. Omits a block entirely when its index is absent — an
+ * empty tag would add bytes to the prefix hash without content.
+ * Respects `REASONIX_MEMORY=off` via `memoryEnabled()` from
+ * `project-memory.ts`.
+ */
+export function applyUserMemory(
+  basePrompt: string,
+  opts: { homeDir?: string; projectRoot?: string } = {},
+): string {
+  if (!memoryEnabled()) return basePrompt;
+  const store = new MemoryStore(opts);
+  const global = store.loadIndex("global");
+  const project = store.hasProjectScope() ? store.loadIndex("project") : null;
+  if (!global && !project) return basePrompt;
+  const parts: string[] = [basePrompt];
+  if (global) {
+    parts.push(
+      "",
+      "# User memory — global (~/.reasonix/memory/global/MEMORY.md)",
+      "",
+      "Cross-project facts and preferences the user has told you in prior sessions. TREAT AS AUTHORITATIVE — don't re-verify via filesystem or web. One-liners index detail files; call `recall_memory` for full bodies only when the one-liner isn't enough.",
+      "",
+      "```",
+      global.content,
+      "```",
+    );
+  }
+  if (project) {
+    parts.push(
+      "",
+      "# User memory — this project",
+      "",
+      "Per-project facts the user established in prior sessions (not committed to the repo). TREAT AS AUTHORITATIVE. Same recall pattern as global memory.",
+      "",
+      "```",
+      project.content,
+      "```",
+    );
+  }
+  return parts.join("\n");
+}
+
+/**
+ * Compose every lazy-loaded prefix block in one call: REASONIX.md,
+ * user memory (global + project), and the skills index. Drop-in
+ * replacement for `applyProjectMemory` at CLI entry points. Stacking
+ * order is stable — the prefix hash only changes when block *content*
+ * changes, not when this helper is called a second time with the same
+ * filesystem state.
+ */
+export function applyMemoryStack(basePrompt: string, rootDir: string): string {
+  const withProject = applyProjectMemory(basePrompt, rootDir);
+  const withMemory = applyUserMemory(withProject, { projectRoot: rootDir });
+  return applySkillsIndex(withMemory, { projectRoot: rootDir });
+}

src/version.ts

@@ -0,0 +1,209 @@
+/**
+ * Version module.
+ *
+ * Two jobs:
+ *
+ *   1. Expose `VERSION` sourced from the real `package.json` so the
+ *      constant never drifts from what npm publishes. Works in dev
+ *      (`tsx src/...`) AND after `tsup` bundles to `dist/` — both
+ *      layouts sit two levels below the manifest, so a short
+ *      walk-up finds it.
+ *
+ *   2. Offer an opt-in `getLatestVersion()` that hits the npm
+ *      registry with a bounded timeout and a 24-hour on-disk
+ *      cache at `~/.reasonix/version-cache.json`. Returns `null`
+ *      on any failure — offline / restricted-network launches
+ *      should stay silent rather than nag the user.
+ *
+ * The CLI wires `getLatestVersion` asynchronously at App mount
+ * (never in a hot path) and renders the outcome in the stats
+ * panel when there's a newer published version.
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+/** npm registry endpoint for the `latest` dist-tag of this package. */
+const REGISTRY_URL = "https://registry.npmjs.org/reasonix/latest";
+
+/** TTL for the on-disk cache entry. 24h keeps noise low; users who
+ * want a fresh check can run `reasonix update` which passes
+ * `force: true`. */
+export const LATEST_CACHE_TTL_MS = 24 * 60 * 60 * 1000;
+
+/** Network timeout. Short — we never block the UI waiting on this. */
+export const LATEST_FETCH_TIMEOUT_MS = 2_000;
+
+/**
+ * Walk up from the current source file looking for the `reasonix`
+ * package.json. Works for:
+ *   - dev: `src/version.ts` → `F:/Reasonix/package.json` (2 levels up)
+ *   - built: `dist/index.js` → `F:/Reasonix/package.json` (2 levels up)
+ *   - global install: `.../node_modules/reasonix/dist/index.js` → `.../reasonix/package.json`
+ *
+ * The `name === "reasonix"` guard is a cheap safety net against
+ * picking up the nearest *other* package.json if we're ever loaded
+ * as a dependency and the layout is unusual.
+ */
+function readPackageVersion(): string {
+  try {
+    let dir = dirname(fileURLToPath(import.meta.url));
+    for (let i = 0; i < 6; i++) {
+      const p = join(dir, "package.json");
+      if (existsSync(p)) {
+        const pkg = JSON.parse(readFileSync(p, "utf8"));
+        if (pkg?.name === "reasonix" && typeof pkg.version === "string") {
+          return pkg.version;
+        }
+      }
+      const parent = dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+  } catch {
+    /* fall through to fallback */
+  }
+  return "0.0.0-dev";
+}
+
+export const VERSION: string = readPackageVersion();
+
+interface VersionCacheEntry {
+  version: string;
+  /** Epoch millis the entry was written. Drives TTL comparisons. */
+  checkedAt: number;
+}
+
+function cachePath(homeDirOverride?: string): string {
+  return join(homeDirOverride ?? homedir(), ".reasonix", "version-cache.json");
+}
+
+function readCache(homeDirOverride?: string): VersionCacheEntry | null {
+  try {
+    const raw = readFileSync(cachePath(homeDirOverride), "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed.version === "string" && typeof parsed.checkedAt === "number") {
+      return parsed;
+    }
+  } catch {
+    /* missing or malformed → no cached entry */
+  }
+  return null;
+}
+
+function writeCache(entry: VersionCacheEntry, homeDirOverride?: string): void {
+  try {
+    const p = cachePath(homeDirOverride);
+    mkdirSync(dirname(p), { recursive: true });
+    writeFileSync(p, JSON.stringify(entry), "utf8");
+  } catch {
+    /* cache is best-effort — a failed write just means we'll re-fetch
+     * next launch. No reason to surface this to the user. */
+  }
+}
+
+export interface GetLatestVersionOptions {
+  /** Ignore the cached entry and always fetch fresh. Used by `reasonix update`. */
+  force?: boolean;
+  /** Registry URL override (tests). */
+  registryUrl?: string;
+  /** Home-directory override (tests). */
+  homeDir?: string;
+  /** Fetch implementation override (tests). Defaults to `globalThis.fetch`. */
+  fetchImpl?: typeof fetch;
+  /** TTL override (tests). */
+  ttlMs?: number;
+  /** Network timeout override (tests). */
+  timeoutMs?: number;
+}
+
+/**
+ * Resolve the latest published `reasonix` version from the npm registry.
+ *
+ * Returns `null` on any network / parse failure. Callers treat `null`
+ * as "don't know, don't nag the user." The cache entry is only
+ * written on a successful fetch — a bad registry response won't
+ * poison the cache.
+ */
+export async function getLatestVersion(opts: GetLatestVersionOptions = {}): Promise<string | null> {
+  const ttl = opts.ttlMs ?? LATEST_CACHE_TTL_MS;
+  if (!opts.force) {
+    const cached = readCache(opts.homeDir);
+    if (cached && Date.now() - cached.checkedAt < ttl) return cached.version;
+  }
+
+  const fetchImpl = opts.fetchImpl ?? globalThis.fetch;
+  if (!fetchImpl) return null;
+  const url = opts.registryUrl ?? REGISTRY_URL;
+  const timeout = opts.timeoutMs ?? LATEST_FETCH_TIMEOUT_MS;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeout);
+  try {
+    const res = await fetchImpl(url, {
+      signal: controller.signal,
+      headers: { accept: "application/json" },
+    });
+    if (!res.ok) return null;
+    const body = (await res.json()) as { version?: unknown };
+    if (typeof body.version !== "string") return null;
+    writeCache({ version: body.version, checkedAt: Date.now() }, opts.homeDir);
+    return body.version;
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+/**
+ * Semver compare. Returns a negative number when `a < b`, positive
+ * when `a > b`, zero when equal.
+ *
+ * Minimal pre-release handling: when the CORE (`x.y.z`) parts match,
+ * any version WITH a suffix (`-rc.1`, `-alpha.4`) compares LOWER
+ * than the bare version. That matches npm's dist-tag semantics —
+ * `reasonix@latest` resolves to a real release, not a pre-release.
+ *
+ * We're deliberately not pulling in `semver` (~50KB). The three
+ * cases we care about are: current > latest (future build, no
+ * prompt), current < latest (prompt), current === latest (no prompt).
+ */
+export function compareVersions(a: string, b: string): number {
+  const [aCore = "0", aPre = ""] = a.split("-", 2);
+  const [bCore = "0", bPre = ""] = b.split("-", 2);
+  const aParts = aCore.split(".").map((p) => Number.parseInt(p, 10) || 0);
+  const bParts = bCore.split(".").map((p) => Number.parseInt(p, 10) || 0);
+  for (let i = 0; i < 3; i++) {
+    const diff = (aParts[i] ?? 0) - (bParts[i] ?? 0);
+    if (diff !== 0) return diff;
+  }
+  if (!aPre && !bPre) return 0;
+  if (!aPre) return 1;
+  if (!bPre) return -1;
+  return aPre < bPre ? -1 : aPre > bPre ? 1 : 0;
+}
+
+/**
+ * Heuristic: did this process launch via `npx` / `pnpm dlx` instead
+ * of a global install? The update command takes different advice in
+ * each case — a global install can `npm i -g reasonix@latest`, while
+ * npx just needs its cache to roll over on next launch.
+ *
+ * Signals checked, in order:
+ *   - `process.argv[1]` contains `_npx` (npm's ephemeral dir name)
+ *   - `process.argv[1]` contains `.pnpm` + `dlx`
+ *   - `npm_config_user_agent` contains `npx/`
+ *
+ * Any one hit → npx. False negatives are safe (worst case we suggest
+ * `npm i -g` to an npx user, which is a valid way to upgrade too).
+ */
+export function isNpxInstall(): boolean {
+  const bin = process.argv[1] ?? "";
+  if (/[/\\]_npx[/\\]/.test(bin)) return true;
+  if (/[/\\]\.pnpm[/\\]/.test(bin) && /dlx/i.test(bin)) return true;
+  const ua = process.env.npm_config_user_agent ?? "";
+  if (ua.includes("npx/")) return true;
+  return false;
+}

tests/code-prompt.test.ts

@@ -0,0 +1,49 @@
+/**
+ * Tests for `codeSystemPrompt` — the .gitignore injection helper.
+ * Pure I/O at the edge, so filesystem-backed tests using a temp dir.
+ */
+
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { CODE_SYSTEM_PROMPT, codeSystemPrompt } from "../src/code/prompt.js";
+
+describe("codeSystemPrompt", () => {
+  let root: string;
+  beforeEach(() => {
+    root = mkdtempSync(join(tmpdir(), "reasonix-prompt-"));
+  });
+  afterEach(() => {
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  it("returns the base prompt unchanged when no .gitignore exists", () => {
+    expect(codeSystemPrompt(root)).toBe(CODE_SYSTEM_PROMPT);
+  });
+
+  it("appends the .gitignore content as a fenced block", () => {
+    writeFileSync(join(root, ".gitignore"), "node_modules/\ndist/\n.env\n", "utf8");
+    const out = codeSystemPrompt(root);
+    expect(out.length).toBeGreaterThan(CODE_SYSTEM_PROMPT.length);
+    expect(out).toMatch(/# Project \.gitignore/);
+    expect(out).toContain("node_modules/");
+    expect(out).toContain(".env");
+  });
+
+  it("truncates a .gitignore larger than 2000 chars", () => {
+    const huge = `${"# comment ".repeat(500)}\n`; // ~5000 chars
+    writeFileSync(join(root, ".gitignore"), huge, "utf8");
+    const out = codeSystemPrompt(root);
+    expect(out).toMatch(/truncated \d+ chars/);
+    // The prompt (base + truncated + fences) is bounded, not 5000+.
+    expect(out.length).toBeLessThan(CODE_SYSTEM_PROMPT.length + 2300);
+  });
+
+  it("reminds the model to skip dependency / build / VCS dirs", () => {
+    // We don't enumerate specific names in the prompt anymore (too
+    // ecosystem-biased); the principle is stated generically and the
+    // pinned .gitignore block is the authoritative denylist.
+    expect(CODE_SYSTEM_PROMPT).toMatch(/dependency.*build.*VCS|skip/i);
+  });
+});

tests/config.test.ts

@@ -3,11 +3,14 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, it } from "vitest";
 import {
+  addProjectShellAllowed,
   isPlausibleKey,
   loadApiKey,
+  loadProjectShellAllowed,
   readConfig,
   redactKey,
   saveApiKey,
+  searchEnabled,
   writeConfig,
 } from "../src/config.js";
 
@@ -15,12 +18,15 @@ describe("config", () => {
   let dir: string;
   let path: string;
   const originalEnv = process.env.DEEPSEEK_API_KEY;
+  const originalSearch = process.env.REASONIX_SEARCH;
 
   beforeEach(() => {
     dir = mkdtempSync(join(tmpdir(), "reasonix-test-"));
     path = join(dir, "config.json");
     // biome-ignore lint/performance/noDelete: the string "undefined" leaks into process.env otherwise
     delete process.env.DEEPSEEK_API_KEY;
+    // biome-ignore lint/performance/noDelete: same reason
+    delete process.env.REASONIX_SEARCH;
   });
 
   afterEach(() => {
@@ -31,6 +37,12 @@ describe("config", () => {
     } else {
       process.env.DEEPSEEK_API_KEY = originalEnv;
     }
+    if (originalSearch === undefined) {
+      // biome-ignore lint/performance/noDelete: same reason
+      delete process.env.REASONIX_SEARCH;
+    } else {
+      process.env.REASONIX_SEARCH = originalSearch;
+    }
   });
 
   it("readConfig returns {} when file is missing", () => {
@@ -79,4 +91,79 @@ describe("config", () => {
     expect(redactKey("short")).toBe("****");
     expect(redactKey("")).toBe("");
   });
+
+  it("round-trips the full ReasonixConfig (preset, mcp, session, setupCompleted)", () => {
+    writeConfig(
+      {
+        apiKey: "sk-test123abcdefghijkl",
+        preset: "smart",
+        mcp: [
+          "filesystem=npx -y @modelcontextprotocol/server-filesystem /tmp/safe",
+          "memory=npx -y @modelcontextprotocol/server-memory",
+        ],
+        session: "work",
+        setupCompleted: true,
+      },
+      path,
+    );
+    const loaded = readConfig(path);
+    expect(loaded.preset).toBe("smart");
+    expect(loaded.mcp).toHaveLength(2);
+    expect(loaded.session).toBe("work");
+    expect(loaded.setupCompleted).toBe(true);
+  });
+
+  it("session: null in the config means the user opted out of persistence", () => {
+    writeConfig({ apiKey: "sk-xxxxxxxxxxxxxxxxxxxx", session: null }, path);
+    const loaded = readConfig(path);
+    expect(loaded.session).toBeNull();
+  });
+
+  it("searchEnabled defaults to true with no config and no env", () => {
+    expect(searchEnabled(path)).toBe(true);
+  });
+
+  it("searchEnabled honours `search: false` in the config file", () => {
+    writeConfig({ apiKey: "sk-test123abcdefghijkl", search: false }, path);
+    expect(searchEnabled(path)).toBe(false);
+  });
+
+  it("searchEnabled honours REASONIX_SEARCH=off/false/0", () => {
+    process.env.REASONIX_SEARCH = "off";
+    expect(searchEnabled(path)).toBe(false);
+    process.env.REASONIX_SEARCH = "false";
+    expect(searchEnabled(path)).toBe(false);
+    process.env.REASONIX_SEARCH = "0";
+    expect(searchEnabled(path)).toBe(false);
+  });
+
+  it("searchEnabled stays true for unrelated env values", () => {
+    process.env.REASONIX_SEARCH = "on";
+    expect(searchEnabled(path)).toBe(true);
+  });
+
+  it("env off beats config true", () => {
+    writeConfig({ apiKey: "sk-test123abcdefghijkl", search: true }, path);
+    process.env.REASONIX_SEARCH = "off";
+    expect(searchEnabled(path)).toBe(false);
+  });
+
+  it("loadProjectShellAllowed returns [] when nothing stored", () => {
+    expect(loadProjectShellAllowed("/some/project", path)).toEqual([]);
+  });
+
+  it("addProjectShellAllowed persists and dedups per project", () => {
+    addProjectShellAllowed("/a", "npm install", path);
+    addProjectShellAllowed("/a", "git commit", path);
+    addProjectShellAllowed("/a", "npm install", path); // dedup
+    addProjectShellAllowed("/b", "cargo add", path);
+    expect(loadProjectShellAllowed("/a", path)).toEqual(["npm install", "git commit"]);
+    expect(loadProjectShellAllowed("/b", path)).toEqual(["cargo add"]);
+  });
+
+  it("addProjectShellAllowed ignores empty / whitespace prefixes", () => {
+    addProjectShellAllowed("/a", "", path);
+    addProjectShellAllowed("/a", "   ", path);
+    expect(loadProjectShellAllowed("/a", path)).toEqual([]);
+  });
 });

tests/diff.test.ts

@@ -195,6 +195,55 @@ describe("renderers", () => {
     expect(md).toMatch(/## Turn-by-turn/);
     expect(md).toMatch(/cache hit/);
   });
+
+  it("omits the harvest row when neither side has plan state (zero visual noise for no-harvest runs)", () => {
+    const a = [mkAssistant(1, "ok")];
+    const b = [mkAssistant(1, "ok")];
+    const report = diffTranscripts(
+      { label: "A", parsed: mkParsed(a) },
+      { label: "B", parsed: mkParsed(b) },
+    );
+    expect(renderSummaryTable(report)).not.toMatch(/harvest/);
+    expect(renderMarkdown(report)).not.toMatch(/harvest/);
+  });
+
+  it("includes the harvest row when at least one side has plan state", () => {
+    const harvestedA: TranscriptRecord = {
+      ts: "t",
+      turn: 1,
+      role: "assistant_final",
+      content: "with harvest",
+      model: "deepseek-reasoner",
+      prefixHash: "stable",
+      usage: {
+        prompt_tokens: 100,
+        completion_tokens: 10,
+        total_tokens: 110,
+        prompt_cache_hit_tokens: 90,
+        prompt_cache_miss_tokens: 10,
+      },
+      cost: 0.0001,
+      planState: {
+        subgoals: ["s1", "s2"],
+        hypotheses: [],
+        uncertainties: ["u1"],
+        rejectedPaths: [],
+      },
+    };
+    const bareB = mkAssistant(1, "without harvest");
+    const report = diffTranscripts(
+      { label: "A", parsed: mkParsed([harvestedA]) },
+      { label: "B", parsed: mkParsed([bareB]) },
+    );
+    const table = renderSummaryTable(report);
+    expect(table).toMatch(/harvest turns/);
+    expect(table).toMatch(/subgoals/);
+    expect(table).toMatch(/uncertainties/);
+
+    const md = renderMarkdown(report);
+    expect(md).toMatch(/harvest turns/);
+    expect(md).toMatch(/harvest subgoals/);
+  });
 });
 
 describe("divergence navigation (TUI)", () => {

tests/edit-blocks.test.ts

@@ -0,0 +1,265 @@
+/**
+ * Unit tests for SEARCH/REPLACE parsing + application.
+ *
+ * Filesystem tests use a fresh temp dir per test so they don't collide
+ * or leak across runs.
+ */
+
+import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import {
+  applyEditBlock,
+  applyEditBlocks,
+  parseEditBlocks,
+  restoreSnapshots,
+  snapshotBeforeEdits,
+} from "../src/code/edit-blocks.js";
+
+describe("parseEditBlocks", () => {
+  it("parses a single block", () => {
+    const text = [
+      "Here is the edit:",
+      "",
+      "src/foo.ts",
+      "<<<<<<< SEARCH",
+      "const x = 1;",
+      "=======",
+      "const x = 2;",
+      ">>>>>>> REPLACE",
+    ].join("\n");
+    const blocks = parseEditBlocks(text);
+    expect(blocks).toHaveLength(1);
+    expect(blocks[0]).toMatchObject({
+      path: "src/foo.ts",
+      search: "const x = 1;",
+      replace: "const x = 2;",
+    });
+  });
+
+  it("parses multiple blocks in one response", () => {
+    const text = [
+      "src/a.ts",
+      "<<<<<<< SEARCH",
+      "old_a",
+      "=======",
+      "new_a",
+      ">>>>>>> REPLACE",
+      "",
+      "src/b.ts",
+      "<<<<<<< SEARCH",
+      "old_b",
+      "=======",
+      "new_b",
+      ">>>>>>> REPLACE",
+    ].join("\n");
+    const blocks = parseEditBlocks(text);
+    expect(blocks).toHaveLength(2);
+    expect(blocks[0]!.path).toBe("src/a.ts");
+    expect(blocks[1]!.path).toBe("src/b.ts");
+  });
+
+  it("handles multi-line SEARCH and REPLACE bodies", () => {
+    const text = [
+      "src/foo.ts",
+      "<<<<<<< SEARCH",
+      "line one",
+      "line two",
+      "line three",
+      "=======",
+      "line one modified",
+      "NEW line",
+      "line three",
+      ">>>>>>> REPLACE",
+    ].join("\n");
+    const [block] = parseEditBlocks(text);
+    expect(block!.search).toBe("line one\nline two\nline three");
+    expect(block!.replace).toBe("line one modified\nNEW line\nline three");
+  });
+
+  it("recognizes an empty SEARCH (new-file sentinel)", () => {
+    const text = [
+      "src/new.ts",
+      "<<<<<<< SEARCH",
+      "=======",
+      "brand new file",
+      ">>>>>>> REPLACE",
+    ].join("\n");
+    const [block] = parseEditBlocks(text);
+    expect(block!.search).toBe("");
+    expect(block!.replace).toBe("brand new file");
+  });
+
+  it("returns an empty list when there are no blocks", () => {
+    expect(parseEditBlocks("just prose, no edits here")).toEqual([]);
+  });
+
+  it("ignores stray 7-char runs that aren't part of a real block", () => {
+    // A JS file that happens to contain the marker string in an unrelated context.
+    const text = 'const note = "<<<<<<< not an edit block";\nmore prose';
+    expect(parseEditBlocks(text)).toEqual([]);
+  });
+});
+
+describe("applyEditBlock", () => {
+  let root: string;
+  beforeEach(() => {
+    root = mkdtempSync(join(tmpdir(), "reasonix-edit-"));
+  });
+  afterEach(() => {
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  it("applies a simple replacement", () => {
+    writeFileSync(join(root, "a.txt"), "hello world\n", "utf8");
+    const result = applyEditBlock(
+      { path: "a.txt", search: "hello", replace: "goodbye", offset: 0 },
+      root,
+    );
+    expect(result.status).toBe("applied");
+    expect(readFileSync(join(root, "a.txt"), "utf8")).toBe("goodbye world\n");
+  });
+
+  it("creates a new file when SEARCH is empty and file doesn't exist", () => {
+    const result = applyEditBlock(
+      { path: "new/nested/file.ts", search: "", replace: "export const x = 1;\n", offset: 0 },
+      root,
+    );
+    expect(result.status).toBe("created");
+    expect(existsSync(join(root, "new/nested/file.ts"))).toBe(true);
+    expect(readFileSync(join(root, "new/nested/file.ts"), "utf8")).toBe("export const x = 1;\n");
+  });
+
+  it("reports not-found when SEARCH doesn't match", () => {
+    writeFileSync(join(root, "a.txt"), "hello world\n", "utf8");
+    const result = applyEditBlock(
+      { path: "a.txt", search: "NOT THERE", replace: "x", offset: 0 },
+      root,
+    );
+    expect(result.status).toBe("not-found");
+    // File unchanged.
+    expect(readFileSync(join(root, "a.txt"), "utf8")).toBe("hello world\n");
+  });
+
+  it("reports file-missing when SEARCH is non-empty and file absent", () => {
+    const result = applyEditBlock(
+      { path: "missing.txt", search: "something", replace: "x", offset: 0 },
+      root,
+    );
+    expect(result.status).toBe("file-missing");
+  });
+
+  it("refuses paths that escape rootDir", () => {
+    const result = applyEditBlock(
+      { path: "../escape.txt", search: "", replace: "boom", offset: 0 },
+      root,
+    );
+    expect(result.status).toBe("path-escape");
+    expect(existsSync(join(root, "..", "escape.txt"))).toBe(false);
+  });
+
+  it("replaces only the first occurrence when SEARCH appears twice", () => {
+    writeFileSync(join(root, "a.txt"), "foo bar foo\n", "utf8");
+    const result = applyEditBlock(
+      { path: "a.txt", search: "foo", replace: "FOO", offset: 0 },
+      root,
+    );
+    expect(result.status).toBe("applied");
+    // First "foo" replaced, second left alone.
+    expect(readFileSync(join(root, "a.txt"), "utf8")).toBe("FOO bar foo\n");
+  });
+});
+
+describe("snapshotBeforeEdits + restoreSnapshots", () => {
+  let root: string;
+  beforeEach(() => {
+    root = mkdtempSync(join(tmpdir(), "reasonix-undo-"));
+  });
+  afterEach(() => {
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  it("restores a modified file to its pre-edit content", () => {
+    writeFileSync(join(root, "a.txt"), "original\n", "utf8");
+    const block = { path: "a.txt", search: "original", replace: "CHANGED", offset: 0 };
+    const snaps = snapshotBeforeEdits([block], root);
+    applyEditBlocks([block], root);
+    expect(readFileSync(join(root, "a.txt"), "utf8")).toBe("CHANGED\n");
+
+    const undoResults = restoreSnapshots(snaps, root);
+    expect(undoResults).toHaveLength(1);
+    expect(undoResults[0]!.status).toBe("applied");
+    expect(readFileSync(join(root, "a.txt"), "utf8")).toBe("original\n");
+  });
+
+  it("deletes a file that was newly created by the edit", () => {
+    const block = { path: "fresh.ts", search: "", replace: "new content", offset: 0 };
+    const snaps = snapshotBeforeEdits([block], root);
+    applyEditBlocks([block], root);
+    expect(existsSync(join(root, "fresh.ts"))).toBe(true);
+
+    restoreSnapshots(snaps, root);
+    expect(existsSync(join(root, "fresh.ts"))).toBe(false);
+  });
+
+  it("de-duplicates per path even when a batch has multiple blocks for the same file", () => {
+    writeFileSync(join(root, "a.txt"), "one two three\n", "utf8");
+    const blocks = [
+      { path: "a.txt", search: "one", replace: "ONE", offset: 0 },
+      { path: "a.txt", search: "two", replace: "TWO", offset: 10 },
+    ];
+    const snaps = snapshotBeforeEdits(blocks, root);
+    expect(snaps).toHaveLength(1); // not 2 — same file
+    expect(snaps[0]!.prevContent).toBe("one two three\n");
+  });
+
+  it("restores multiple files in a single batch independently", () => {
+    writeFileSync(join(root, "a.txt"), "aa\n", "utf8");
+    writeFileSync(join(root, "b.txt"), "bb\n", "utf8");
+    const blocks = [
+      { path: "a.txt", search: "aa", replace: "AAA", offset: 0 },
+      { path: "b.txt", search: "bb", replace: "BBB", offset: 10 },
+    ];
+    const snaps = snapshotBeforeEdits(blocks, root);
+    applyEditBlocks(blocks, root);
+
+    restoreSnapshots(snaps, root);
+    expect(readFileSync(join(root, "a.txt"), "utf8")).toBe("aa\n");
+    expect(readFileSync(join(root, "b.txt"), "utf8")).toBe("bb\n");
+  });
+
+  it("refuses to restore a snapshot whose path escapes rootDir", () => {
+    const fakeSnap = [{ path: "../escape.txt", prevContent: "boom" }];
+    const results = restoreSnapshots(fakeSnap, root);
+    expect(results[0]!.status).toBe("path-escape");
+    expect(existsSync(join(root, "..", "escape.txt"))).toBe(false);
+  });
+});
+
+describe("applyEditBlocks (batch)", () => {
+  let root: string;
+  beforeEach(() => {
+    root = mkdtempSync(join(tmpdir(), "reasonix-edit-"));
+  });
+  afterEach(() => {
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  it("applies a two-file batch; each result is independent", () => {
+    writeFileSync(join(root, "a.txt"), "alpha\n", "utf8");
+    writeFileSync(join(root, "b.txt"), "bravo\n", "utf8");
+    const results = applyEditBlocks(
+      [
+        { path: "a.txt", search: "alpha", replace: "ALPHA", offset: 0 },
+        { path: "b.txt", search: "NOPE", replace: "X", offset: 10 },
+      ],
+      root,
+    );
+    expect(results).toHaveLength(2);
+    expect(results[0]!.status).toBe("applied");
+    expect(results[1]!.status).toBe("not-found");
+    expect(readFileSync(join(root, "a.txt"), "utf8")).toBe("ALPHA\n");
+    expect(readFileSync(join(root, "b.txt"), "utf8")).toBe("bravo\n"); // untouched
+  });
+});

tests/filesystem-tools.test.ts

@@ -0,0 +1,343 @@
+import { promises as fs } from "node:fs";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { ToolRegistry } from "../src/tools.js";
+import { lineDiff, registerFilesystemTools } from "../src/tools/filesystem.js";
+
+describe("filesystem tools (built-in, sandbox-enforced)", () => {
+  let root: string;
+  let tools: ToolRegistry;
+
+  beforeEach(async () => {
+    root = await mkdtemp(join(tmpdir(), "reasonix-fs-"));
+    tools = new ToolRegistry();
+    registerFilesystemTools(tools, { rootDir: root });
+    await fs.writeFile(join(root, "hello.txt"), "line 1\nline 2\nline 3\n");
+    await fs.mkdir(join(root, "src"), { recursive: true });
+    await fs.writeFile(join(root, "src", "index.ts"), "export const x = 1;\n");
+    await fs.writeFile(join(root, "src", "util.ts"), "export const y = 2;\n");
+  });
+
+  afterEach(async () => {
+    await rm(root, { recursive: true, force: true });
+  });
+
+  describe("read_file", () => {
+    it("reads the full contents", async () => {
+      const out = await tools.dispatch("read_file", JSON.stringify({ path: "hello.txt" }));
+      expect(out).toContain("line 1");
+      expect(out).toContain("line 3");
+    });
+
+    it("honors head=N to return only the first N lines", async () => {
+      const out = await tools.dispatch("read_file", JSON.stringify({ path: "hello.txt", head: 2 }));
+      expect(out).toBe("line 1\nline 2");
+    });
+
+    it("honors tail=N", async () => {
+      const out = await tools.dispatch("read_file", JSON.stringify({ path: "hello.txt", tail: 2 }));
+      expect(out).toContain("line 2");
+      expect(out).toContain("line 3");
+      expect(out).not.toContain("line 1");
+    });
+
+    it("rejects paths outside the sandbox root", async () => {
+      const out = await tools.dispatch(
+        "read_file",
+        JSON.stringify({ path: "../../../etc/passwd" }),
+      );
+      expect(out).toMatch(/escapes sandbox/);
+    });
+
+    it("rejects absolute paths outside root", async () => {
+      const out = await tools.dispatch("read_file", JSON.stringify({ path: "/etc/passwd" }));
+      expect(out).toMatch(/escapes sandbox/);
+    });
+
+    it("returns a truncation notice when file exceeds maxReadBytes", async () => {
+      const tiny = new ToolRegistry();
+      registerFilesystemTools(tiny, { rootDir: root, maxReadBytes: 10 });
+      const out = await tiny.dispatch("read_file", JSON.stringify({ path: "hello.txt" }));
+      expect(out).toMatch(/truncated/);
+    });
+
+    it("refuses to read a directory as a file", async () => {
+      const out = await tools.dispatch("read_file", JSON.stringify({ path: "src" }));
+      expect(out).toMatch(/not a file/);
+    });
+  });
+
+  describe("list_directory / directory_tree", () => {
+    it("list_directory shows entries with trailing slash for dirs", async () => {
+      const out = await tools.dispatch("list_directory", JSON.stringify({ path: "." }));
+      expect(out).toContain("hello.txt");
+      expect(out).toContain("src/");
+    });
+
+    it("directory_tree recurses", async () => {
+      const out = await tools.dispatch("directory_tree", JSON.stringify({ path: "." }));
+      expect(out).toContain("hello.txt");
+      expect(out).toContain("src/");
+      expect(out).toContain("index.ts");
+      expect(out).toContain("util.ts");
+    });
+
+    it("directory_tree respects maxDepth", async () => {
+      const out = await tools.dispatch(
+        "directory_tree",
+        JSON.stringify({ path: ".", maxDepth: 0 }),
+      );
+      // With depth 0 we list the top level only — no descent into src/.
+      expect(out).toContain("src/");
+      expect(out).not.toContain("index.ts");
+    });
+  });
+
+  describe("search_files", () => {
+    it("finds matching filenames recursively", async () => {
+      const out = await tools.dispatch("search_files", JSON.stringify({ pattern: "index" }));
+      expect(out).toContain("index.ts");
+    });
+
+    it("is case-insensitive", async () => {
+      const out = await tools.dispatch("search_files", JSON.stringify({ pattern: "HELLO" }));
+      expect(out).toContain("hello.txt");
+    });
+
+    it("reports no-matches cleanly", async () => {
+      const out = await tools.dispatch("search_files", JSON.stringify({ pattern: "nothing123" }));
+      expect(out).toBe("(no matches)");
+    });
+  });
+
+  describe("get_file_info", () => {
+    it("returns type + size + mtime as JSON", async () => {
+      const out = await tools.dispatch("get_file_info", JSON.stringify({ path: "hello.txt" }));
+      const parsed = JSON.parse(out);
+      expect(parsed.type).toBe("file");
+      expect(parsed.size).toBeGreaterThan(0);
+      expect(parsed.mtime).toMatch(/\d{4}-\d{2}-\d{2}/);
+    });
+
+    it("reports directories", async () => {
+      const out = await tools.dispatch("get_file_info", JSON.stringify({ path: "src" }));
+      expect(JSON.parse(out).type).toBe("directory");
+    });
+  });
+
+  describe("write_file", () => {
+    it("creates a new file with contents", async () => {
+      const out = await tools.dispatch(
+        "write_file",
+        JSON.stringify({ path: "new.md", content: "hi" }),
+      );
+      expect(out).toMatch(/wrote 2 chars/);
+      const disk = await fs.readFile(join(root, "new.md"), "utf8");
+      expect(disk).toBe("hi");
+    });
+
+    it("creates parent directories as needed", async () => {
+      await tools.dispatch("write_file", JSON.stringify({ path: "a/b/c/deep.txt", content: "x" }));
+      const disk = await fs.readFile(join(root, "a", "b", "c", "deep.txt"), "utf8");
+      expect(disk).toBe("x");
+    });
+
+    it("rejects writes outside the sandbox", async () => {
+      const out = await tools.dispatch(
+        "write_file",
+        JSON.stringify({ path: "../escape.txt", content: "bad" }),
+      );
+      expect(out).toMatch(/escapes sandbox/);
+    });
+  });
+
+  describe("edit_file (flat SEARCH/REPLACE — the anti-DSML shape)", () => {
+    it("replaces a unique search string", async () => {
+      await fs.writeFile(join(root, "a.txt"), "foo bar baz");
+      const out = await tools.dispatch(
+        "edit_file",
+        JSON.stringify({ path: "a.txt", search: "bar", replace: "QUX" }),
+      );
+      expect(out).toMatch(/edited/);
+      const disk = await fs.readFile(join(root, "a.txt"), "utf8");
+      expect(disk).toBe("foo QUX baz");
+    });
+
+    it("includes a git-style @@ -N,M +N,M @@ hunk header with the real starting line", async () => {
+      // File has 4 pre-existing lines; SEARCH starts at line 3.
+      // Expected hunk header: @@ -3,1 +3,2 @@ (1 old line → 2 new).
+      await fs.writeFile(join(root, "a.txt"), "alpha\nbeta\nTARGET\ntail\n");
+      const out = await tools.dispatch(
+        "edit_file",
+        JSON.stringify({ path: "a.txt", search: "TARGET", replace: "TARGET\nextra" }),
+      );
+      expect(out).toMatch(/@@ -3,1 \+3,2 @@/);
+    });
+
+    it("returns a proper LCS diff with context lines, not just - old / + new", async () => {
+      // The user-reported case: SEARCH is a single line, REPLACE keeps
+      // that line and adds three more below it. A naive dump-both-sides
+      // would show "- line\n+ line\n+ new1\n+ new2\n+ new3" (redundant
+      // `-` for the unchanged line). Proper LCS shows the first line
+      // as context (` `) and only the additions as `+`.
+      await fs.writeFile(
+        join(root, "a.txt"),
+        "const a = doc.getElementById('a');\nconst b = doc.getElementById('b');",
+      );
+      const search = "const a = doc.getElementById('a');";
+      const replace = [
+        "const a = doc.getElementById('a');",
+        "const b2 = doc.getElementById('b2');",
+        "const c = doc.getElementById('c');",
+      ].join("\n");
+      const out = await tools.dispatch(
+        "edit_file",
+        JSON.stringify({ path: "a.txt", search, replace }),
+      );
+      // The unchanged first line appears as context (space-prefixed),
+      // NOT as a `-` / `+` pair.
+      expect(out).toContain("  const a = doc.getElementById('a');");
+      // The new lines are `+` prefixed.
+      expect(out).toContain("+ const b2 = doc.getElementById('b2');");
+      expect(out).toContain("+ const c = doc.getElementById('c');");
+      // No line should appear as both `-` and `+` for the preserved
+      // one — that was the old broken behavior.
+      const minuses = out.split("\n").filter((l) => l.startsWith("- "));
+      expect(minuses.some((l) => l.includes("getElementById('a')"))).toBe(false);
+    });
+
+    it("refuses when the search text is not found", async () => {
+      await fs.writeFile(join(root, "a.txt"), "foo bar");
+      const out = await tools.dispatch(
+        "edit_file",
+        JSON.stringify({ path: "a.txt", search: "baz", replace: "x" }),
+      );
+      expect(out).toMatch(/not found/);
+    });
+
+    it("refuses when the search text appears multiple times", async () => {
+      await fs.writeFile(join(root, "a.txt"), "cat cat cat");
+      const out = await tools.dispatch(
+        "edit_file",
+        JSON.stringify({ path: "a.txt", search: "cat", replace: "dog" }),
+      );
+      expect(out).toMatch(/multiple times/);
+      // File unchanged.
+      const disk = await fs.readFile(join(root, "a.txt"), "utf8");
+      expect(disk).toBe("cat cat cat");
+    });
+
+    it("refuses an empty search", async () => {
+      await fs.writeFile(join(root, "a.txt"), "x");
+      const out = await tools.dispatch(
+        "edit_file",
+        JSON.stringify({ path: "a.txt", search: "", replace: "y" }),
+      );
+      expect(out).toMatch(/search cannot be empty/);
+    });
+  });
+
+  describe("create_directory + move_file", () => {
+    it("create_directory is idempotent (mkdir -p)", async () => {
+      const a = await tools.dispatch("create_directory", JSON.stringify({ path: "d/e/f" }));
+      expect(a).toMatch(/created/);
+      const b = await tools.dispatch("create_directory", JSON.stringify({ path: "d/e/f" }));
+      expect(b).toMatch(/created/);
+      const st = await fs.stat(join(root, "d", "e", "f"));
+      expect(st.isDirectory()).toBe(true);
+    });
+
+    it("move_file renames", async () => {
+      const out = await tools.dispatch(
+        "move_file",
+        JSON.stringify({ source: "hello.txt", destination: "bye.txt" }),
+      );
+      expect(out).toMatch(/moved/);
+      const disk = await fs.readFile(join(root, "bye.txt"), "utf8");
+      expect(disk).toContain("line 1");
+      await expect(fs.stat(join(root, "hello.txt"))).rejects.toThrow();
+    });
+
+    it("move_file into a new subdir creates the parent", async () => {
+      await tools.dispatch(
+        "move_file",
+        JSON.stringify({ source: "hello.txt", destination: "archive/old.txt" }),
+      );
+      const disk = await fs.readFile(join(root, "archive", "old.txt"), "utf8");
+      expect(disk).toContain("line 1");
+    });
+  });
+
+  describe("allowWriting=false (read-only mode)", () => {
+    it("skips registering write_file / edit_file / create_directory / move_file", async () => {
+      const ro = new ToolRegistry();
+      registerFilesystemTools(ro, { rootDir: root, allowWriting: false });
+      expect(ro.has("read_file")).toBe(true);
+      expect(ro.has("list_directory")).toBe(true);
+      expect(ro.has("write_file")).toBe(false);
+      expect(ro.has("edit_file")).toBe(false);
+      expect(ro.has("create_directory")).toBe(false);
+      expect(ro.has("move_file")).toBe(false);
+    });
+  });
+});
+
+describe("lineDiff — LCS line-level diff used by edit_file", () => {
+  it("pure insertion: common prefix as context, new lines as +", () => {
+    const d = lineDiff(["a"], ["a", "b", "c"]);
+    expect(d).toEqual([
+      { op: " ", line: "a" },
+      { op: "+", line: "b" },
+      { op: "+", line: "c" },
+    ]);
+  });
+
+  it("pure deletion: kept lines as context, dropped as -", () => {
+    const d = lineDiff(["a", "b", "c"], ["a"]);
+    expect(d).toEqual([
+      { op: " ", line: "a" },
+      { op: "-", line: "b" },
+      { op: "-", line: "c" },
+    ]);
+  });
+
+  it("substitution: line-in-line-out without touching neighbors", () => {
+    const d = lineDiff(["a", "old", "c"], ["a", "new", "c"]);
+    // "a" and "c" stay as context; "old" → "new" is a -/+ pair.
+    expect(d.map((o) => o.op).join("")).toBe(" -+ ");
+    expect(d.map((o) => o.line)).toEqual(["a", "old", "new", "c"]);
+  });
+
+  it("identical arrays produce pure context (no +/- ops)", () => {
+    const lines = ["a", "b", "c"];
+    const d = lineDiff(lines, lines);
+    expect(d.every((o) => o.op === " ")).toBe(true);
+  });
+
+  it("empty search → all replace lines are added", () => {
+    const d = lineDiff([], ["x", "y"]);
+    expect(d).toEqual([
+      { op: "+", line: "x" },
+      { op: "+", line: "y" },
+    ]);
+  });
+
+  it("handles the user's real case: one-line search → multi-line replace with the line preserved", () => {
+    const search = [
+      "const prestigePointsGainElement = doc.getElementById('prestige-points-gain');",
+    ];
+    const replace = [
+      "const prestigePointsGainElement = doc.getElementById('prestige-points-gain');",
+      "const bonusClickElement = doc.getElementById('bonus-click');",
+      "const bonusCpsElement = doc.getElementById('bonus-cps');",
+    ];
+    const d = lineDiff(search, replace);
+    // First line is context — not a -/+ redundant pair.
+    expect(d[0]!.op).toBe(" ");
+    expect(d[0]!.line).toContain("prestigePointsGainElement");
+    // The rest are pure additions.
+    expect(d.slice(1).every((o) => o.op === "+")).toBe(true);
+  });
+});

tests/harvest-bench.test.ts

@@ -0,0 +1,177 @@
+/**
+ * Checker tests for the harvest eval harness.
+ *
+ * Unlike the bench runner tests (which cover plumbing without API calls),
+ * these test the pass/fail verdict logic — the part that determines
+ * whether a real run's data is credible. A broken checker silently
+ * produces wrong numbers, so the tests here are worth every line.
+ */
+
+import { describe, expect, it } from "vitest";
+import { TASKS } from "../benchmarks/harvest/tasks.js";
+
+function taskById(id: string) {
+  const t = TASKS.find((x) => x.id === id);
+  if (!t) throw new Error(`no task ${id}`);
+  return t;
+}
+
+describe("harvest-bench: mod7_list checker", () => {
+  const task = taskById("mod7_list");
+
+  it("passes on the exact 29-element set in a plain comma list", () => {
+    const list = [
+      2, 4, 9, 11, 16, 18, 23, 25, 30, 32, 37, 39, 44, 46, 51, 53, 58, 60, 65, 67, 72, 74, 79, 81,
+      86, 88, 93, 95, 100,
+    ];
+    const reply = `Thinking... blah blah.\nAnswer: ${list.join(", ")}`;
+    expect(task.check(reply).verdict).toBe("pass");
+  });
+
+  it("passes when ranges like 2-4 are expanded", () => {
+    // cheat: give the set as short ranges — checker should expand them
+    const reply =
+      "Answer: 2, 4, 9, 11, 16, 18, 23, 25, 30, 32, 37, 39, 44, 46, 51, 53, 58, 60, 65, 67, 72, 74, 79, 81, 86, 88, 93, 95, 100";
+    expect(task.check(reply).verdict).toBe("pass");
+  });
+
+  it("fails when a number is missing", () => {
+    const list = [2, 4, 9, 11, 16, 18, 23, 25, 30, 32, 37, 39, 44, 46, 51, 53, 58, 60, 65, 67, 72];
+    const reply = `Answer: ${list.join(", ")}`;
+    const result = task.check(reply);
+    expect(result.verdict).toBe("fail");
+    expect(result.note).toMatch(/missing/);
+  });
+
+  it("fails when an extra in-range number sneaks in (e.g. 3 — which is NOT in the valid set)", () => {
+    const list = [
+      2, 3, 4, 9, 11, 16, 18, 23, 25, 30, 32, 37, 39, 44, 46, 51, 53, 58, 60, 65, 67, 72, 74, 79,
+      81, 86, 88, 93, 95, 100,
+    ]; // 3 is the intruder
+    const reply = `Answer: ${list.join(", ")}`;
+    const result = task.check(reply);
+    expect(result.verdict).toBe("fail");
+    expect(result.note).toMatch(/extra.*3/);
+  });
+
+  it("fails cleanly on an empty / garbled answer", () => {
+    expect(task.check("").verdict).toBe("fail");
+    expect(task.check("I cannot solve this").verdict).toBe("fail");
+  });
+});
+
+describe("harvest-bench: flips_until_3heads checker", () => {
+  const task = taskById("flips_until_3heads");
+
+  it("passes on exact answer 14", () => {
+    expect(task.check("Answer: 14").verdict).toBe("pass");
+  });
+
+  it("passes when agent adds units ('14 flips')", () => {
+    expect(task.check("Answer: 14 flips").verdict).toBe("pass");
+  });
+
+  it("fails on wrong number", () => {
+    const r = task.check("Answer: 7");
+    expect(r.verdict).toBe("fail");
+    expect(r.note).toMatch(/got 7/);
+  });
+
+  it("fails when no number is present", () => {
+    expect(task.check("Answer: lots").verdict).toBe("fail");
+  });
+});
+
+describe("harvest-bench: three_hats checker", () => {
+  const task = taskById("three_hats");
+
+  it("passes on 'red'", () => {
+    expect(task.check("Answer: red").verdict).toBe("pass");
+  });
+
+  it("passes with extra wording around the keyword", () => {
+    expect(task.check("Answer: The third person's hat is red.").verdict).toBe("pass");
+  });
+
+  it("fails on 'blue'", () => {
+    expect(task.check("Answer: blue").verdict).toBe("fail");
+  });
+
+  it("fails when answer mentions both colors (ambiguous)", () => {
+    // We require a clean red-only answer to avoid giving credit for hedging
+    expect(task.check("Answer: red or blue, depends").verdict).toBe("fail");
+  });
+});
+
+describe("harvest-bench: pseudoprime_base2 checker", () => {
+  const task = taskById("pseudoprime_base2");
+
+  it("passes on 341", () => {
+    expect(task.check("Reasoning... Answer: 341").verdict).toBe("pass");
+  });
+
+  it("fails on 561 (common V3 wrong answer — Carmichael)", () => {
+    const r = task.check("Answer: 561");
+    expect(r.verdict).toBe("fail");
+    expect(r.note).toMatch(/got 561/);
+  });
+
+  it("passes when answer is wrapped in LaTeX", () => {
+    expect(task.check("Answer: $341$ (= 11 \\cdot 31)").verdict).toBe("pass");
+  });
+});
+
+describe("harvest-bench: derangements_d7 checker", () => {
+  const task = taskById("derangements_d7");
+
+  it("passes on 1854", () => {
+    expect(task.check("Answer: 1854").verdict).toBe("pass");
+  });
+
+  it("fails on 265 (D_6) — common off-by-one", () => {
+    expect(task.check("Answer: 265").verdict).toBe("fail");
+  });
+
+  it("fails on 1855 (off by one)", () => {
+    expect(task.check("Answer: 1855").verdict).toBe("fail");
+  });
+});
+
+describe("harvest-bench: euler_quadratic_break checker", () => {
+  const task = taskById("euler_quadratic_break");
+
+  it("passes on 40", () => {
+    expect(task.check("Answer: 40").verdict).toBe("pass");
+  });
+
+  it("fails on 41 (the off-by-one trap from n²-n+41)", () => {
+    expect(task.check("Answer: 41").verdict).toBe("fail");
+  });
+
+  it("fails when agent gives f(40) instead of n=40", () => {
+    expect(task.check("Answer: 1681").verdict).toBe("fail");
+  });
+});
+
+describe("task set invariants", () => {
+  it("exposes at least 6 tasks (3 easy + 3 hard) with unique ids", () => {
+    expect(TASKS.length).toBeGreaterThanOrEqual(6);
+    const ids = new Set(TASKS.map((t) => t.id));
+    expect(ids.size).toBe(TASKS.length);
+  });
+
+  it("every task checker rejects a deliberately wrong answer (sanity)", () => {
+    const bogus = "Answer: this is not a valid answer to anything";
+    for (const t of TASKS) {
+      const r = t.check(bogus);
+      expect(r.verdict).toBe("fail");
+    }
+  });
+
+  it("every task checker is deterministic on identical input", () => {
+    const sample = "Answer: something";
+    for (const t of TASKS) {
+      expect(t.check(sample).verdict).toBe(t.check(sample).verdict);
+    }
+  });
+});

tests/loop-error.test.ts

@@ -0,0 +1,231 @@
+/**
+ * Tests for the loop's error-message decorator. Scope is narrow:
+ * context-overflow errors get a user-friendly hint, everything else
+ * passes through unchanged.
+ */
+
+import { describe, expect, it } from "vitest";
+import { formatLoopError, healLoadedMessages, stripHallucinatedToolMarkup } from "../src/loop.js";
+import type { ChatMessage } from "../src/types.js";
+
+describe("formatLoopError", () => {
+  it("annotates a DeepSeek 400 'maximum context length' error", () => {
+    const raw = new Error(
+      'DeepSeek 400: {"error":{"message":"This model\'s maximum context length is 131072 tokens. ' +
+        "However, you requested 929452 tokens (929452 in the messages, 0 in the completion). " +
+        'Please reduce the length of the messages or completion."}}',
+    );
+    const out = formatLoopError(raw);
+    expect(out).toMatch(/Context overflow/);
+    expect(out).toMatch(/\/forget/);
+    expect(out).toMatch(/929,452 tokens/); // pretty-printed from the raw JSON
+  });
+
+  it("leaves non-overflow errors unchanged", () => {
+    const raw = new Error("DeepSeek 401: invalid api key");
+    expect(formatLoopError(raw)).toBe("DeepSeek 401: invalid api key");
+  });
+
+  it("tolerates an overflow error without a requested-tokens figure", () => {
+    const raw = new Error("DeepSeek 400: This model's maximum context length is 131072 tokens.");
+    const out = formatLoopError(raw);
+    expect(out).toMatch(/Context overflow/);
+    expect(out).toMatch(/too many tokens/);
+  });
+});
+
+describe("healLoadedMessages", () => {
+  it("truncates a giant tool result, leaves user/assistant messages alone", () => {
+    const big = "X".repeat(80_000);
+    // Needs a proper assistant.tool_calls + matching tool response so
+    // the 0.4.12+ validator doesn't prune the tool as stray.
+    const messages: ChatMessage[] = [
+      { role: "user", content: "read the big file" },
+      {
+        role: "assistant",
+        content: "",
+        tool_calls: [{ id: "t1", type: "function", function: { name: "read", arguments: "{}" } }],
+      },
+      { role: "tool", tool_call_id: "t1", content: big },
+      { role: "assistant", content: "here's what I found" },
+    ];
+    const { messages: healed, healedCount, healedFrom } = healLoadedMessages(messages, 32_000);
+    expect(healedCount).toBe(1);
+    expect(healedFrom).toBe(80_000);
+    expect(healed[0]).toEqual(messages[0]); // user untouched
+    expect(healed[1]).toEqual(messages[1]); // assistant untouched
+    expect(typeof healed[2]!.content).toBe("string");
+    expect((healed[2]!.content as string).length).toBeLessThan(33_000);
+    expect(healed[2]!.content).toContain("truncated");
+    expect(healed[3]).toEqual(messages[3]); // trailing assistant untouched
+  });
+
+  it("is a no-op when every message fits AND pairing is valid", () => {
+    const messages: ChatMessage[] = [
+      { role: "user", content: "hi" },
+      { role: "assistant", content: "hi back" },
+    ];
+    const { messages: healed, healedCount } = healLoadedMessages(messages, 32_000);
+    expect(healedCount).toBe(0);
+    expect(healed).toEqual(messages);
+  });
+
+  it("heals multiple oversized tool messages in one pass (all properly paired)", () => {
+    // Each oversized tool MUST be the response to a preceding
+    // assistant.tool_calls, otherwise the 0.4.12 validator prunes it.
+    const messages: ChatMessage[] = [
+      { role: "user", content: "do three things" },
+      {
+        role: "assistant",
+        content: "",
+        tool_calls: [
+          { id: "t1", type: "function", function: { name: "x", arguments: "{}" } },
+          { id: "t2", type: "function", function: { name: "x", arguments: "{}" } },
+          { id: "t3", type: "function", function: { name: "x", arguments: "{}" } },
+        ],
+      },
+      { role: "tool", tool_call_id: "t1", content: "A".repeat(40_000) },
+      { role: "tool", tool_call_id: "t2", content: "B".repeat(50_000) },
+      { role: "tool", tool_call_id: "t3", content: "small" },
+    ];
+    const { healedCount, healedFrom } = healLoadedMessages(messages, 32_000);
+    expect(healedCount).toBe(2);
+    expect(healedFrom).toBe(90_000);
+  });
+
+  it("drops stray tool messages that have no preceding assistant.tool_calls", () => {
+    // This is the shape that triggered the "tool must be a response
+    // to a preceding tool_calls" 400 — a tool entry with no opener.
+    const messages: ChatMessage[] = [
+      { role: "user", content: "hi" },
+      { role: "tool", tool_call_id: "stray", content: "orphan result" },
+      { role: "assistant", content: "sure" },
+    ];
+    const { messages: healed, healedCount } = healLoadedMessages(messages, 32_000);
+    expect(healedCount).toBe(1);
+    expect(healed.map((m) => m.role)).toEqual(["user", "assistant"]);
+  });
+
+  it("drops an assistant.tool_calls whose response set is incomplete", () => {
+    // tool_calls declares [a, b], but only tool[a] follows. The
+    // validator can't deliver this to DeepSeek — drops the pair.
+    const messages: ChatMessage[] = [
+      { role: "user", content: "hi" },
+      {
+        role: "assistant",
+        content: "",
+        tool_calls: [
+          { id: "a", type: "function", function: { name: "x", arguments: "{}" } },
+          { id: "b", type: "function", function: { name: "x", arguments: "{}" } },
+        ],
+      },
+      { role: "tool", tool_call_id: "a", content: "partial" },
+      { role: "assistant", content: "trailing note" },
+    ];
+    const { messages: healed, healedCount } = healLoadedMessages(messages, 32_000);
+    expect(healedCount).toBeGreaterThan(0);
+    // Assistant.tool_calls and its partial tool response both dropped;
+    // the trailing plain assistant note survives.
+    expect(healed.map((m) => m.role)).toEqual(["user", "assistant"]);
+    expect(healed[1]!.content).toBe("trailing note");
+  });
+
+  it("strips a dangling assistant-with-tool_calls tail (pre-0.4.12 session files)", () => {
+    const messages: ChatMessage[] = [
+      { role: "user", content: "analyze" },
+      { role: "assistant", content: "sure" },
+      {
+        role: "assistant",
+        content: "",
+        tool_calls: [{ id: "t1", type: "function", function: { name: "probe", arguments: "{}" } }],
+      },
+      // NO tool response follows — this is the corrupted shape that
+      // DeepSeek 400s on the next user message. Heal must drop it.
+    ];
+    const { messages: healed, healedCount } = healLoadedMessages(messages, 32_000);
+    expect(healedCount).toBe(1);
+    expect(healed).toHaveLength(2);
+    expect(healed[healed.length - 1]!.role).toBe("assistant");
+    expect(healed[healed.length - 1]!.content).toBe("sure");
+  });
+
+  it("strips MULTIPLE trailing assistant-with-tool_calls entries (stacked corruption)", () => {
+    const messages: ChatMessage[] = [
+      { role: "user", content: "go" },
+      {
+        role: "assistant",
+        content: "",
+        tool_calls: [{ id: "a", type: "function", function: { name: "x", arguments: "{}" } }],
+      },
+      {
+        role: "assistant",
+        content: "",
+        tool_calls: [{ id: "b", type: "function", function: { name: "x", arguments: "{}" } }],
+      },
+    ];
+    const { messages: healed, healedCount } = healLoadedMessages(messages, 32_000);
+    // Both dangling assistant entries trimmed; user message survives.
+    expect(healedCount).toBe(2);
+    expect(healed).toHaveLength(1);
+    expect(healed[0]!.role).toBe("user");
+  });
+
+  it("keeps a PAIRED assistant.tool_calls + tool response intact", () => {
+    const messages: ChatMessage[] = [
+      { role: "user", content: "go" },
+      {
+        role: "assistant",
+        content: "",
+        tool_calls: [{ id: "t1", type: "function", function: { name: "x", arguments: "{}" } }],
+      },
+      { role: "tool", tool_call_id: "t1", content: "ok" },
+    ];
+    const { messages: healed, healedCount } = healLoadedMessages(messages, 32_000);
+    expect(healedCount).toBe(0);
+    expect(healed).toEqual(messages);
+  });
+});
+
+describe("stripHallucinatedToolMarkup", () => {
+  it("removes a full DSML function_calls block (the R1 hallucination we saw live)", () => {
+    const input = [
+      "Let me look at the file structure.",
+      "",
+      '<｜DSML｜function_calls> <｜DSML｜invoke name="filesystem_edit_file">',
+      '  <｜DSML｜parameter name="path" string="true">F:.html</｜DSML｜parameter>',
+      '  <｜DSML｜parameter name="edits" string="false">[...]</｜DSML｜parameter>',
+      "</｜DSML｜invoke> </｜DSML｜function_calls>",
+      "",
+      "Saved.",
+    ].join("\n");
+    const out = stripHallucinatedToolMarkup(input);
+    expect(out).toContain("Let me look at the file structure.");
+    expect(out).toContain("Saved.");
+    expect(out).not.toContain("DSML");
+    expect(out).not.toContain("filesystem_edit_file");
+  });
+
+  it("removes an Anthropic-style <function_calls> block", () => {
+    const input = "Here is the plan.\n<function_calls>\n<tool>...</tool>\n</function_calls>\nDone.";
+    const out = stripHallucinatedToolMarkup(input);
+    expect(out).toContain("Here is the plan.");
+    expect(out).toContain("Done.");
+    expect(out).not.toContain("function_calls");
+  });
+
+  it("strips a truncated DSML opener that never gets closed", () => {
+    const input = 'Before the junk.\n<｜DSML｜function_calls> <｜DSML｜invoke name="x"> ...';
+    const out = stripHallucinatedToolMarkup(input);
+    expect(out).toBe("Before the junk.");
+  });
+
+  it("leaves plain prose completely alone", () => {
+    const input = "Just a normal summary with no markup anywhere.";
+    expect(stripHallucinatedToolMarkup(input)).toBe(input);
+  });
+
+  it("returns empty string when ALL content was hallucinated markup", () => {
+    const input = "<｜DSML｜function_calls>garbage</｜DSML｜function_calls>";
+    expect(stripHallucinatedToolMarkup(input)).toBe("");
+  });
+});

tests/loop.test.ts

@@ -156,6 +156,48 @@ describe("CacheFirstLoop (non-streaming)", () => {
     expect(loop.stats.turns.length).toBe(2); // two model round-trips
   });
 
+  it("yields tool_start before each tool dispatch so the TUI can show 'running…'", async () => {
+    const client = makeClient([
+      {
+        content: "",
+        tool_calls: [
+          {
+            id: "call_1",
+            type: "function",
+            function: { name: "add", arguments: '{"a":1,"b":2}' },
+          },
+        ],
+      },
+      { content: "done" },
+    ]);
+    const tools = new ToolRegistry();
+    tools.register<{ a: number; b: number }, number>({
+      name: "add",
+      parameters: {
+        type: "object",
+        properties: { a: { type: "integer" }, b: { type: "integer" } },
+        required: ["a", "b"],
+      },
+      fn: ({ a, b }) => a + b,
+    });
+    const loop = new CacheFirstLoop({
+      client,
+      prefix: new ImmutablePrefix({ system: "s", toolSpecs: tools.specs() }),
+      tools,
+      stream: false,
+    });
+
+    const roleOrder: { role: string; toolName?: string }[] = [];
+    for await (const ev of loop.step("go")) {
+      if (ev.role === "tool_start" || ev.role === "tool") {
+        roleOrder.push({ role: ev.role, toolName: ev.toolName });
+      }
+    }
+    // tool_start must precede the matching tool result.
+    expect(roleOrder[0]).toEqual({ role: "tool_start", toolName: "add" });
+    expect(roleOrder[1]).toEqual({ role: "tool", toolName: "add" });
+  });
+
   it("immutable prefix is preserved across turns (cache-stability invariant)", async () => {
     const sharedFetch = fakeFetch([{ content: "a" }, { content: "b" }]);
     const client = new DeepSeekClient({ apiKey: "sk-test", fetch: sharedFetch });
@@ -186,6 +228,301 @@ describe("CacheFirstLoop (non-streaming)", () => {
     expect(msgs2.length).toBeGreaterThan(msgs1.length);
   });
 
+  it("yields a warning event once when tool-call count crosses 70% of budget", async () => {
+    const reg = new ToolRegistry();
+    reg.register({
+      name: "probe",
+      description: "no-op",
+      parameters: { type: "object", properties: {} },
+      fn: async () => "ok",
+    });
+    const callAgain = {
+      content: "",
+      tool_calls: [{ id: "c", type: "function", function: { name: "probe", arguments: "{}" } }],
+    };
+    const summary = { content: "all done" };
+    const responses: FakeResponseShape[] = [callAgain, callAgain, callAgain, callAgain, summary];
+    const client = makeClient(responses);
+    const loop = new CacheFirstLoop({
+      client,
+      prefix: new ImmutablePrefix({ system: "s", toolSpecs: reg.specs() }),
+      tools: reg,
+      stream: false,
+      maxToolIters: 4, // 70% → warn starting at iter >= 2
+    });
+
+    const warnings: string[] = [];
+    for await (const ev of loop.step("go")) {
+      if (ev.role === "warning") warnings.push(ev.content);
+    }
+    // Identical fixture calls also trip the storm breaker in 0.4.19+,
+    // which emits its own warning. Filter for the iter-budget warning
+    // specifically — that's what this test guards (once-per-turn flag).
+    const iterBudgetWarnings = warnings.filter((w) => /tool calls used/.test(w));
+    expect(iterBudgetWarnings).toHaveLength(1);
+    expect(iterBudgetWarnings[0]).toMatch(/\d+\/4 tool calls used/);
+    expect(iterBudgetWarnings[0]).toMatch(/Esc/);
+  });
+
+  it("abort() mid-step stops immediately without a follow-up API call", async () => {
+    const reg = new ToolRegistry();
+    reg.register({
+      name: "probe",
+      description: "no-op",
+      parameters: { type: "object", properties: {} },
+      fn: async () => "ok",
+    });
+    const chainingToolCall = {
+      content: "",
+      tool_calls: [{ id: "c", type: "function", function: { name: "probe", arguments: "{}" } }],
+    };
+    // Only one chaining response needed — abort should stop the loop
+    // before any follow-up model call. A second response in the array
+    // would indicate the loop made an unwanted extra API call.
+    const fetchSpy = vi.fn() as unknown as typeof fetch;
+    const responses: FakeResponseShape[] = [chainingToolCall];
+    const client = new DeepSeekClient({
+      apiKey: "sk-test",
+      fetch: fakeFetch(responses) as unknown as typeof fetch,
+    });
+    const loop = new CacheFirstLoop({
+      client,
+      prefix: new ImmutablePrefix({ system: "s", toolSpecs: reg.specs() }),
+      tools: reg,
+      stream: false,
+      maxToolIters: 16,
+    });
+
+    // Call abort AFTER the first tool event fires — simulates the user
+    // hitting Esc while the loop is exploring.
+    const events: { role: string; content?: string; forcedSummary?: boolean }[] = [];
+    let aborted = false;
+    for await (const ev of loop.step("go")) {
+      events.push({ role: ev.role, content: ev.content, forcedSummary: ev.forcedSummary });
+      if (!aborted && ev.role === "tool") {
+        aborted = true;
+        loop.abort();
+      }
+    }
+
+    // Warning fires with the abort notice.
+    const warnings = events.filter((e) => e.role === "warning");
+    expect(warnings.some((w) => /aborted at iter/.test(w.content ?? ""))).toBe(true);
+
+    // Synthetic assistant_final is tagged forcedSummary and carries
+    // the stopped-message text. It should NOT contain any model
+    // output because no second API call was made.
+    const finals = events.filter((e) => e.role === "assistant_final");
+    const stopped = finals[finals.length - 1]!;
+    expect(stopped.forcedSummary).toBe(true);
+    expect(stopped.content).toMatch(/aborted by user \(Esc\)/);
+    expect(stopped.content).toMatch(/no summary produced/);
+
+    // Suite ends with `done`.
+    expect(events[events.length - 1]!.role).toBe("done");
+    // Silence unused-var warning.
+    void fetchSpy;
+  });
+
+  it("forces a summary when maxToolIters is exhausted, instead of stopping silently", async () => {
+    // Give a registered tool so the repair layer doesn't strip the fake
+    // tool_calls for referring to an unknown name.
+    const reg = new ToolRegistry();
+    reg.register({
+      name: "probe",
+      description: "no-op",
+      parameters: { type: "object", properties: {} },
+      fn: async () => "ok",
+    });
+    // Every tool-iter response says "call probe again" — infinite loop
+    // absent the iter cap. The (N+1)th response is the forced-summary
+    // call (no tools, returns text).
+    const chainingToolCall = {
+      content: "",
+      tool_calls: [
+        {
+          id: "call_1",
+          type: "function",
+          function: { name: "probe", arguments: "{}" },
+        },
+      ],
+    };
+    const responses: FakeResponseShape[] = [
+      chainingToolCall,
+      chainingToolCall,
+      { content: "done — here's what I found." }, // summary call
+    ];
+    const client = makeClient(responses);
+    const loop = new CacheFirstLoop({
+      client,
+      prefix: new ImmutablePrefix({ system: "s", toolSpecs: reg.specs() }),
+      tools: reg,
+      stream: false,
+      maxToolIters: 2, // deliberately tight so we hit the cap fast
+    });
+
+    const events: { role: string; content?: string }[] = [];
+    for await (const ev of loop.step("go")) {
+      events.push({ role: ev.role, content: ev.content });
+    }
+
+    // Multiple assistant_final events are yielded (one per iter) — the
+    // summary is the LAST one, carrying the "tool-call budget" prefix.
+    const finals = events.filter((e) => e.role === "assistant_final");
+    const summary = finals[finals.length - 1];
+    expect(summary).toBeDefined();
+    expect(summary!.content).toMatch(/tool-call budget/);
+    expect(summary!.content).toContain("done — here's what I found.");
+    // Last event is still `done`, preserving the contract used by run().
+    expect(events[events.length - 1]!.role).toBe("done");
+  });
+
+  it("context-guard diverts to summary when promptTokens > 80% of the window, tagging forcedSummary", async () => {
+    const reg = new ToolRegistry();
+    reg.register({
+      name: "probe",
+      description: "no-op",
+      parameters: { type: "object", properties: {} },
+      fn: async () => "ok",
+    });
+    // First response: chaining tool call with a prompt-token count
+    // deliberately over 80% of DeepSeek's 131k window (131k * 0.8 = 104_857).
+    // 120k trips the guard.
+    const responses: FakeResponseShape[] = [
+      {
+        content: "",
+        tool_calls: [{ id: "c", type: "function", function: { name: "probe", arguments: "{}" } }],
+        usage: {
+          prompt_tokens: 120_000,
+          completion_tokens: 50,
+          total_tokens: 120_050,
+          prompt_cache_hit_tokens: 90_000,
+          prompt_cache_miss_tokens: 30_000,
+        },
+      },
+      // Forced-summary response (no tools)
+      { content: "based on what I saw, X." },
+    ];
+    const client = makeClient(responses);
+    const loop = new CacheFirstLoop({
+      client,
+      prefix: new ImmutablePrefix({ system: "s", toolSpecs: reg.specs() }),
+      tools: reg,
+      stream: false,
+      maxToolIters: 64,
+    });
+
+    const events: { role: string; forcedSummary?: boolean; content?: string }[] = [];
+    for await (const ev of loop.step("analyze the repo")) {
+      events.push({ role: ev.role, forcedSummary: ev.forcedSummary, content: ev.content });
+    }
+
+    // A warning must fire about the context guard. Accept both the
+    // auto-compact-saved-us variant and the nothing-to-compact variant
+    // — the message format shifted in 0.4.11 when we added the
+    // auto-compact attempt before forcing summary.
+    const warn = events.find((e) => e.role === "warning");
+    expect(warn).toBeDefined();
+    expect(warn!.content).toMatch(/context [\d,]+\/[\d,]+/);
+
+    // The final assistant_final must be tagged forcedSummary and carry the context-guard prefix.
+    const finals = events.filter((e) => e.role === "assistant_final");
+    const summary = finals[finals.length - 1];
+    expect(summary!.forcedSummary).toBe(true);
+    expect(summary!.content).toMatch(/context budget running low/);
+  });
+
+  it("context-guard auto-compacts oversized tool results and continues instead of jumping to summary", async () => {
+    // Pre-seed the log with an oversized tool result so compact has
+    // something to shrink. Then the model requests another tool call;
+    // the returned prompt_tokens trips the 80% guard. We expect compact
+    // to run, the warning to mention shrinking, and the loop to
+    // continue with the tool dispatch — no forced summary.
+    const reg = new ToolRegistry();
+    reg.register({
+      name: "probe",
+      description: "no-op",
+      parameters: { type: "object", properties: {} },
+      fn: async () => "ok",
+    });
+    const responses: FakeResponseShape[] = [
+      // Iter 0: chains a tool call, usage trips the guard.
+      {
+        content: "",
+        tool_calls: [{ id: "c1", type: "function", function: { name: "probe", arguments: "{}" } }],
+        usage: {
+          prompt_tokens: 120_000,
+          completion_tokens: 10,
+          total_tokens: 120_010,
+          prompt_cache_hit_tokens: 100_000,
+          prompt_cache_miss_tokens: 20_000,
+        },
+      },
+      // Iter 1: model wraps up normally after the tool result.
+      { content: "done analyzing." },
+    ];
+    const client = makeClient(responses);
+    const loop = new CacheFirstLoop({
+      client,
+      prefix: new ImmutablePrefix({ system: "s", toolSpecs: reg.specs() }),
+      tools: reg,
+      stream: false,
+      maxToolIters: 64,
+    });
+    // Put a big tool message into the log so compact has work to do.
+    loop.log.append({ role: "user", content: "do stuff" });
+    loop.log.append({
+      role: "tool",
+      tool_call_id: "prior",
+      content: "Z".repeat(60_000),
+    });
+
+    const events: { role: string; forcedSummary?: boolean; content?: string }[] = [];
+    for await (const ev of loop.step("continue")) {
+      events.push({ role: ev.role, forcedSummary: ev.forcedSummary, content: ev.content });
+    }
+
+    const warn = events.find((e) => e.role === "warning");
+    expect(warn).toBeDefined();
+    expect(warn!.content).toMatch(/auto-compacted \d+ oversized tool result/);
+    // Tool was actually dispatched (we didn't force-summary).
+    expect(events.find((e) => e.role === "tool")).toBeDefined();
+    // Final assistant_final should NOT be tagged forcedSummary — we
+    // took the happy path through the tool and a normal wrap-up.
+    const finals = events.filter((e) => e.role === "assistant_final");
+    const last = finals[finals.length - 1];
+    expect(last!.forcedSummary).toBeFalsy();
+  });
+
+  it("buildMessages strips a dangling assistant-with-tool_calls tail — defensive against 'insufficient tool messages' 400", async () => {
+    // Craft a log where the last entry is an assistant message with
+    // tool_calls but no matching tool responses. This is the shape
+    // that used to crash the forced-summary call with DeepSeek's
+    // 'insufficient tool messages following tool_calls' error.
+    const client = makeClient([{ content: "summary text" }]);
+    const loop = new CacheFirstLoop({
+      client,
+      prefix: new ImmutablePrefix({ system: "s" }),
+      stream: false,
+    });
+    loop.log.append({ role: "user", content: "hi" });
+    loop.log.append({
+      role: "assistant",
+      content: "",
+      tool_calls: [{ id: "x", type: "function", function: { name: "noop", arguments: "{}" } }],
+    });
+    // A chat turn from here should succeed, not 400, because
+    // buildMessages strips the unpaired tail.
+    const events: { role: string; content?: string }[] = [];
+    for await (const ev of loop.step("continue")) {
+      events.push({ role: ev.role, content: ev.content });
+    }
+    expect(events.find((e) => e.role === "error")).toBeUndefined();
+    // The fake fetch echoes the messages it received — no unpaired
+    // assistant+tool_calls should be in there.
+    expect(events.find((e) => e.role === "assistant_final")?.content).toContain("summary text");
+  });
+
   it("surfaces an error event when the HTTP call fails with a non-retryable status", async () => {
     // 401 is non-retryable (bad key). Using this avoids multi-retry waits.
     const errFetch = vi.fn(async () => new Response("boom", { status: 401 }));
@@ -207,3 +544,57 @@ describe("CacheFirstLoop (non-streaming)", () => {
     expect(roles).toContain("error");
   });
 });
+
+describe("CacheFirstLoop (streaming) — tool_call_delta emission", () => {
+  it("yields tool_call_delta events carrying growing arg-char count", async () => {
+    const client = new DeepSeekClient({
+      apiKey: "sk-test",
+      // Fake fetch that streams an SSE body with a multi-chunk tool call.
+      fetch: (async (_url: any, _init: any) => {
+        const frames = [
+          `data: ${JSON.stringify({ choices: [{ delta: { tool_calls: [{ index: 0, id: "c1", function: {} }] } }] })}\n\n`,
+          `data: ${JSON.stringify({ choices: [{ delta: { tool_calls: [{ index: 0, function: { name: "edit_file", arguments: '{"path":"a.txt","search":"' } }] } }] })}\n\n`,
+          `data: ${JSON.stringify({ choices: [{ delta: { tool_calls: [{ index: 0, function: { arguments: 'old","replace":"new"}' } }] } }] })}\n\n`,
+          `data: ${JSON.stringify({ choices: [{ finish_reason: "tool_calls", delta: {} }], usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2, prompt_cache_hit_tokens: 0, prompt_cache_miss_tokens: 1 } })}\n\n`,
+          "data: [DONE]\n\n",
+        ];
+        const body = new ReadableStream({
+          start(ctrl) {
+            for (const f of frames) ctrl.enqueue(new TextEncoder().encode(f));
+            ctrl.close();
+          },
+        });
+        return new Response(body, {
+          status: 200,
+          headers: { "Content-Type": "text/event-stream" },
+        });
+      }) as unknown as typeof fetch,
+    });
+
+    const tools = new ToolRegistry();
+    tools.register({
+      name: "edit_file",
+      parameters: { type: "object", properties: {}, required: [] },
+      fn: () => "ok",
+    });
+    const loop = new CacheFirstLoop({
+      client,
+      prefix: new ImmutablePrefix({ system: "s", toolSpecs: tools.specs() }),
+      tools,
+      stream: true,
+      maxToolIters: 1,
+    });
+
+    const deltas: Array<{ name?: string; chars?: number }> = [];
+    for await (const ev of loop.step("do it")) {
+      if (ev.role === "tool_call_delta") {
+        deltas.push({ name: ev.toolName, chars: ev.toolCallArgsChars });
+      }
+      if (ev.role === "tool_start") break;
+    }
+
+    expect(deltas.length).toBeGreaterThanOrEqual(2);
+    expect(deltas[0]!.name).toBe("edit_file");
+    expect(deltas[deltas.length - 1]!.chars).toBeGreaterThan(deltas[0]!.chars!);
+  });
+});

tests/markdown.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { stripMath } from "../src/cli/ui/markdown.js";
+import { parseBlocks, stripMath } from "../src/cli/ui/markdown.js";
 
 describe("stripMath", () => {
   it("converts \\frac, \\dfrac, \\tfrac uniformly", () => {
@@ -67,3 +67,202 @@ describe("stripMath", () => {
     expect(out).toContain("(d)/(30)");
   });
 });
+
+describe("parseBlocks — SEARCH/REPLACE detection", () => {
+  it("extracts a single SEARCH/REPLACE block into a first-class edit-block", () => {
+    const text = [
+      "Here is the fix:",
+      "",
+      "src/foo.ts",
+      "<<<<<<< SEARCH",
+      "const x = 1;",
+      "=======",
+      "const x = 2;",
+      ">>>>>>> REPLACE",
+    ].join("\n");
+    const blocks = parseBlocks(text);
+    const edit = blocks.find((b) => b.kind === "edit-block");
+    expect(edit).toBeDefined();
+    if (edit?.kind !== "edit-block") throw new Error("unreachable");
+    expect(edit.filename).toBe("src/foo.ts");
+    expect(edit.search).toBe("const x = 1;");
+    expect(edit.replace).toBe("const x = 2;");
+  });
+
+  it("preserves multi-line SEARCH and REPLACE verbatim (no markdown mangling)", () => {
+    // The original user-reported shape: JSDoc comments inside SEARCH.
+    // Before this fix, `/** ... */` got eaten by bold/italic regex and
+    // `para.join(" ")` collapsed newlines.
+    const text = [
+      "src/code/edit-blocks.ts",
+      "<<<<<<< SEARCH",
+      "/** Edit landed on disk. */",
+      "| 'applied'",
+      "=======",
+      "/** Edit landed on disk. */",
+      "| 'applied-new'",
+      ">>>>>>> REPLACE",
+    ].join("\n");
+    const [edit] = parseBlocks(text).filter((b) => b.kind === "edit-block");
+    if (edit?.kind !== "edit-block") throw new Error("expected edit-block");
+    // The `/** ... */` and `|` chars survive intact — no `*`-eating,
+    // no newline-flattening.
+    expect(edit.search).toContain("/** Edit landed on disk. */");
+    expect(edit.search).toContain("\n");
+    expect(edit.replace).toContain("'applied-new'");
+  });
+
+  it("recognizes new-file (empty SEARCH) blocks", () => {
+    const text = [
+      "src/new.ts",
+      "<<<<<<< SEARCH",
+      "=======",
+      "export const x = 1;",
+      ">>>>>>> REPLACE",
+    ].join("\n");
+    const [edit] = parseBlocks(text).filter((b) => b.kind === "edit-block");
+    if (edit?.kind !== "edit-block") throw new Error("expected edit-block");
+    expect(edit.search).toBe("");
+    expect(edit.replace).toBe("export const x = 1;");
+  });
+
+  it("ignores a stray <<<<<<< SEARCH without a filename or close marker", () => {
+    const text = "just some prose with <<<<<<< SEARCH left over in the middle";
+    const blocks = parseBlocks(text);
+    expect(blocks.find((b) => b.kind === "edit-block")).toBeUndefined();
+  });
+
+  it("extracts multiple edit-blocks in one response, keeping the prose between them", () => {
+    const text = [
+      "First change:",
+      "src/a.ts",
+      "<<<<<<< SEARCH",
+      "old_a",
+      "=======",
+      "new_a",
+      ">>>>>>> REPLACE",
+      "",
+      "And second:",
+      "src/b.ts",
+      "<<<<<<< SEARCH",
+      "old_b",
+      "=======",
+      "new_b",
+      ">>>>>>> REPLACE",
+    ].join("\n");
+    const blocks = parseBlocks(text);
+    const edits = blocks.filter((b) => b.kind === "edit-block");
+    expect(edits).toHaveLength(2);
+    const paragraphs = blocks.filter((b) => b.kind === "paragraph");
+    expect(paragraphs.map((p) => (p.kind === "paragraph" ? p.text : ""))).toEqual(
+      expect.arrayContaining(["First change:", "And second:"]),
+    );
+  });
+});
+
+describe("parseBlocks — GFM tables", () => {
+  it("recognizes a simple table with header + separator + rows", () => {
+    const md = [
+      "Intro paragraph.",
+      "",
+      "| 声望点 | 加成效果 |",
+      "|--------|----------|",
+      "| 每2点 | +1 点击力 |",
+      "| 每3点 | +10% CPS 乘数 |",
+      "",
+      "Trailing text.",
+    ].join("\n");
+    const blocks = parseBlocks(md);
+    const table = blocks.find((b) => b.kind === "table");
+    expect(table).toBeDefined();
+    if (table && table.kind === "table") {
+      expect(table.header).toEqual(["声望点", "加成效果"]);
+      expect(table.rows).toHaveLength(2);
+      expect(table.rows[0]).toEqual(["每2点", "+1 点击力"]);
+      expect(table.rows[1]).toEqual(["每3点", "+10% CPS 乘数"]);
+    }
+    // Surrounding paragraphs still parsed as separate blocks.
+    expect(
+      blocks.find((b) => b.kind === "paragraph" && b.text === "Intro paragraph."),
+    ).toBeDefined();
+    expect(blocks.find((b) => b.kind === "paragraph" && b.text === "Trailing text.")).toBeDefined();
+  });
+
+  it("accepts alignment colons in the separator without breaking", () => {
+    const md = ["| col1 | col2 |", "|:-----|-----:|", "| a    | b    |"].join("\n");
+    const [t] = parseBlocks(md).filter((b) => b.kind === "table");
+    expect(t).toBeDefined();
+    if (t && t.kind === "table") {
+      expect(t.header).toEqual(["col1", "col2"]);
+      expect(t.rows[0]).toEqual(["a", "b"]);
+    }
+  });
+
+  it("accepts tables without leading/trailing pipes", () => {
+    const md = ["col1 | col2", "-----|-----", "a    | b"].join("\n");
+    const [t] = parseBlocks(md).filter((b) => b.kind === "table");
+    expect(t).toBeDefined();
+    if (t && t.kind === "table") {
+      expect(t.header).toEqual(["col1", "col2"]);
+      expect(t.rows[0]).toEqual(["a", "b"]);
+    }
+  });
+
+  it("does NOT trigger on a bare '|' in prose when next line is not a separator", () => {
+    const md = ["Use the pipe | operator to chain.", "Second paragraph."].join("\n");
+    const blocks = parseBlocks(md);
+    expect(blocks.find((b) => b.kind === "table")).toBeUndefined();
+  });
+
+  it("preserves escaped pipes inside cell content", () => {
+    const md = ["| a | b |", "|---|---|", "| x \\| y | z |"].join("\n");
+    const [t] = parseBlocks(md).filter((b) => b.kind === "table");
+    expect(t).toBeDefined();
+    if (t && t.kind === "table") {
+      expect(t.rows[0]).toEqual(["x | y", "z"]);
+    }
+  });
+});
+
+describe("parseBlocks — fenced code blocks", () => {
+  it("recognizes a plain multi-line fence", () => {
+    const blocks = parseBlocks("```bash\necho hi\necho bye\n```");
+    expect(blocks).toHaveLength(1);
+    expect(blocks[0]).toEqual({ kind: "code", lang: "bash", text: "echo hi\necho bye" });
+  });
+
+  it("allows up to 3 leading spaces on the fence line (GFM)", () => {
+    const blocks = parseBlocks("   ```bash\n   echo indented\n   ```");
+    const code = blocks.find((b) => b.kind === "code");
+    expect(code).toBeDefined();
+    expect(code && code.kind === "code" && code.lang).toBe("bash");
+  });
+
+  it("handles a one-line fenced code block (model puts everything on one line)", () => {
+    const blocks = parseBlocks("```bash svn commit -m hi```");
+    expect(blocks).toHaveLength(1);
+    expect(blocks[0]).toEqual({ kind: "code", lang: "bash", text: "svn commit -m hi" });
+  });
+
+  it("handles a one-line fenced block surrounded by prose paragraphs", () => {
+    const blocks = parseBlocks("Run this:\n\n```bash svn status```\n\nOr:\n\n```bash svn log```");
+    expect(blocks).toHaveLength(4);
+    expect(blocks[0]).toMatchObject({ kind: "paragraph" });
+    expect(blocks[1]).toMatchObject({ kind: "code", text: "svn status" });
+    expect(blocks[2]).toMatchObject({ kind: "paragraph" });
+    expect(blocks[3]).toMatchObject({ kind: "code", text: "svn log" });
+  });
+
+  it("closing fence must be at least as long as the opening fence", () => {
+    // Opened with 4 backticks so body can contain 3 without closing.
+    const blocks = parseBlocks("````\nsome ``` code\n````");
+    expect(blocks).toHaveLength(1);
+    expect(blocks[0]).toEqual({ kind: "code", lang: "", text: "some ``` code" });
+  });
+
+  it("an unclosed fence still emits a code block at EOF", () => {
+    const blocks = parseBlocks("```python\nprint('hi')");
+    const code = blocks.find((b) => b.kind === "code");
+    expect(code && code.kind === "code" && code.text).toBe("print('hi')");
+  });
+});

tests/mcp-inspect.test.ts

@@ -0,0 +1,229 @@
+/**
+ * Tests for inspectMcpServer (pure, runs against the fake transport).
+ * We don't unit-test the CLI wrapper — that's just argv parsing and
+ * stdout printing, covered by the integration story of "types compile".
+ */
+
+import { describe, expect, it } from "vitest";
+import { McpClient } from "../src/mcp/client.js";
+import { inspectMcpServer } from "../src/mcp/inspect.js";
+import type { McpTransport } from "../src/mcp/stdio.js";
+import {
+  type JsonRpcMessage,
+  type JsonRpcRequest,
+  MCP_PROTOCOL_VERSION,
+} from "../src/mcp/types.js";
+
+// A minimal in-process transport that answers methods from a handler
+// map. Simpler than the FakeMcpTransport in mcp.test.ts — we only
+// care about shape-of-response here, not call ordering.
+class HandlerTransport implements McpTransport {
+  private readonly queue: JsonRpcMessage[] = [];
+  private readonly waiters: Array<(m: JsonRpcMessage | null) => void> = [];
+  private closed = false;
+  constructor(private readonly handlers: Record<string, (req: JsonRpcRequest) => JsonRpcMessage>) {}
+
+  async send(msg: JsonRpcMessage): Promise<void> {
+    if (this.closed) throw new Error("closed");
+    if (!("id" in msg) || !("method" in msg)) return; // notification from client
+    const req = msg as JsonRpcRequest;
+    const handler = this.handlers[req.method];
+    const response = handler
+      ? handler(req)
+      : {
+          jsonrpc: "2.0",
+          id: req.id,
+          error: { code: -32601, message: `method not found: ${req.method}` },
+        };
+    const w = this.waiters.shift();
+    if (w) w(response as JsonRpcMessage);
+    else this.queue.push(response as JsonRpcMessage);
+  }
+
+  async *messages(): AsyncIterableIterator<JsonRpcMessage> {
+    while (true) {
+      if (this.queue.length > 0) {
+        yield this.queue.shift()!;
+        continue;
+      }
+      if (this.closed) return;
+      const next = await new Promise<JsonRpcMessage | null>((resolve) => {
+        this.waiters.push(resolve);
+      });
+      if (next === null) return;
+      yield next;
+    }
+  }
+
+  async close(): Promise<void> {
+    this.closed = true;
+    while (this.waiters.length > 0) this.waiters.shift()!(null);
+  }
+}
+
+function initOk(req: JsonRpcRequest): JsonRpcMessage {
+  return {
+    jsonrpc: "2.0",
+    id: req.id,
+    result: {
+      protocolVersion: MCP_PROTOCOL_VERSION,
+      serverInfo: { name: "test-server", version: "1.2.3" },
+      capabilities: { tools: {}, resources: {}, prompts: {} },
+      instructions: "Use tool X before Y.",
+    },
+  };
+}
+
+describe("inspectMcpServer", () => {
+  it("reports server info, capabilities, tools, resources, prompts — full-support server", async () => {
+    const transport = new HandlerTransport({
+      initialize: initOk,
+      "tools/list": (req) => ({
+        jsonrpc: "2.0",
+        id: req.id,
+        result: {
+          tools: [
+            { name: "echo", description: "echoes", inputSchema: { type: "object" } },
+            { name: "add", description: "a+b", inputSchema: { type: "object" } },
+          ],
+        },
+      }),
+      "resources/list": (req) => ({
+        jsonrpc: "2.0",
+        id: req.id,
+        result: {
+          resources: [
+            { uri: "file:///a.md", name: "a", mimeType: "text/markdown" },
+            { uri: "custom://b", name: "b" },
+          ],
+        },
+      }),
+      "prompts/list": (req) => ({
+        jsonrpc: "2.0",
+        id: req.id,
+        result: {
+          prompts: [
+            {
+              name: "summarize",
+              description: "summarize a doc",
+              arguments: [{ name: "lang", required: true }],
+            },
+          ],
+        },
+      }),
+    });
+    const client = new McpClient({ transport });
+    await client.initialize();
+    const report = await inspectMcpServer(client);
+
+    expect(report.protocolVersion).toBe(MCP_PROTOCOL_VERSION);
+    expect(report.serverInfo).toEqual({ name: "test-server", version: "1.2.3" });
+    expect(report.instructions).toBe("Use tool X before Y.");
+    expect(report.tools).toEqual({
+      supported: true,
+      items: expect.arrayContaining([expect.objectContaining({ name: "echo" })]),
+    });
+    expect(report.resources.supported).toBe(true);
+    if (report.resources.supported) {
+      expect(report.resources.items.map((r) => r.name)).toEqual(["a", "b"]);
+    }
+    expect(report.prompts.supported).toBe(true);
+    if (report.prompts.supported) {
+      expect(report.prompts.items[0]!.arguments?.[0]?.name).toBe("lang");
+    }
+
+    await client.close();
+  });
+
+  it("marks resources+prompts as not supported when server returns -32601", async () => {
+    // Tools-only server: init returns, tools/list works, resources/list
+    // + prompts/list fall through to the default -32601 in HandlerTransport.
+    const transport = new HandlerTransport({
+      initialize: initOk,
+      "tools/list": (req) => ({
+        jsonrpc: "2.0",
+        id: req.id,
+        result: { tools: [] },
+      }),
+    });
+    const client = new McpClient({ transport });
+    await client.initialize();
+    const report = await inspectMcpServer(client);
+
+    expect(report.tools.supported).toBe(true);
+    expect(report.resources.supported).toBe(false);
+    expect(report.prompts.supported).toBe(false);
+    if (!report.resources.supported) {
+      expect(report.resources.reason).toMatch(/-32601/);
+    }
+    if (!report.prompts.supported) {
+      expect(report.prompts.reason).toMatch(/-32601/);
+    }
+
+    await client.close();
+  });
+
+  it("forwards non-32601 errors as the section reason so user sees real diagnostics", async () => {
+    const transport = new HandlerTransport({
+      initialize: initOk,
+      "tools/list": (req) => ({
+        jsonrpc: "2.0",
+        id: req.id,
+        error: { code: -32000, message: "server is overloaded" },
+      }),
+      "resources/list": (req) => ({
+        jsonrpc: "2.0",
+        id: req.id,
+        result: { resources: [] },
+      }),
+      "prompts/list": (req) => ({
+        jsonrpc: "2.0",
+        id: req.id,
+        result: { prompts: [] },
+      }),
+    });
+    const client = new McpClient({ transport });
+    await client.initialize();
+    const report = await inspectMcpServer(client);
+
+    expect(report.tools.supported).toBe(false);
+    if (!report.tools.supported) {
+      expect(report.tools.reason).toMatch(/overloaded/);
+    }
+    // Resources and prompts are supported and empty — should not be affected.
+    expect(report.resources.supported).toBe(true);
+    expect(report.prompts.supported).toBe(true);
+
+    await client.close();
+  });
+});
+
+describe("McpClient: initialize records serverInfo + protocolVersion + instructions", () => {
+  it("exposes server info, protocol version, instructions from the handshake", async () => {
+    const transport = new HandlerTransport({ initialize: initOk });
+    const client = new McpClient({ transport });
+    await client.initialize();
+    expect(client.serverInfo).toEqual({ name: "test-server", version: "1.2.3" });
+    expect(client.protocolVersion).toBe(MCP_PROTOCOL_VERSION);
+    expect(client.serverInstructions).toBe("Use tool X before Y.");
+    await client.close();
+  });
+
+  it("leaves serverInstructions undefined when absent from the init result", async () => {
+    const transport = new HandlerTransport({
+      initialize: (req) => ({
+        jsonrpc: "2.0",
+        id: req.id,
+        result: {
+          protocolVersion: MCP_PROTOCOL_VERSION,
+          serverInfo: { name: "minimal", version: "0" },
+          capabilities: { tools: {} },
+        },
+      }),
+    });
+    const client = new McpClient({ transport });
+    await client.initialize();
+    expect(client.serverInstructions).toBeUndefined();
+    await client.close();
+  });
+});

tests/mcp-integration.test.ts

@@ -0,0 +1,112 @@
+/**
+ * Integration test: real subprocess + real transport + bridge + dispatch.
+ *
+ * Distinct from tests/mcp.test.ts (which uses an in-process fake
+ * transport). This one actually spawns the bundled demo MCP server as
+ * a child process, connects via StdioTransport, bridges tools into a
+ * ToolRegistry, and invokes them.
+ *
+ * We don't put this in CI yet — subprocess tests on Windows can be
+ * slow or flaky. Run locally with `npm test`. If it ever becomes
+ * flaky, swap the afterEach cleanup to force-kill and move on.
+ */
+
+import { afterEach, describe, expect, it } from "vitest";
+import { McpClient } from "../src/mcp/client.js";
+import { bridgeMcpTools } from "../src/mcp/registry.js";
+import { StdioTransport } from "../src/mcp/stdio.js";
+import { ToolRegistry } from "../src/tools.js";
+
+// Spawning `tsx` directly needs a cross-platform approach. `node --import tsx`
+// works everywhere Node 20+ is installed (which is our engines target) and
+// avoids the Windows `.cmd` resolution gotcha in child_process.spawn.
+const NODE_CMD = process.execPath;
+const DEMO_SERVER_ARGS = ["--import", "tsx", "examples/mcp-server-demo.ts"];
+
+describe("MCP integration — real subprocess against bundled demo server", () => {
+  let client: McpClient | null = null;
+
+  afterEach(async () => {
+    if (client) {
+      await client.close();
+      client = null;
+    }
+  });
+
+  it("initializes, lists tools, and calls echo/add end-to-end", async () => {
+    const transport = new StdioTransport({
+      command: NODE_CMD,
+      args: DEMO_SERVER_ARGS,
+      // We're spawning node.exe directly — bypass the shell-true default
+      // that exists for .cmd wrappers (npx etc.). Saves a cmd.exe hop
+      // and the quoting concerns that come with it.
+      shell: false,
+    });
+    client = new McpClient({ transport, requestTimeoutMs: 15_000 });
+    const info = await client.initialize();
+    expect(info.serverInfo.name).toBe("reasonix-demo-mcp");
+    expect(info.capabilities.tools).toBeDefined();
+
+    const { tools } = await client.listTools();
+    const names = tools.map((t) => t.name).sort();
+    expect(names).toEqual(["add", "echo", "get_time", "slow_count"]);
+
+    const echoResult = await client.callTool("echo", { msg: "hello" });
+    const echoText = echoResult.content.map((c) => ("text" in c ? c.text : "")).join("");
+    expect(echoText).toContain("hello");
+
+    const addResult = await client.callTool("add", { a: 17, b: 25 });
+    const addText = addResult.content.map((c) => ("text" in c ? c.text : "")).join("");
+    expect(addText).toContain("42");
+  }, 30_000);
+
+  it("bridges real MCP tools into a Reasonix ToolRegistry", async () => {
+    const transport = new StdioTransport({
+      command: NODE_CMD,
+      args: DEMO_SERVER_ARGS,
+      shell: false,
+    });
+    client = new McpClient({ transport, requestTimeoutMs: 15_000 });
+    await client.initialize();
+
+    const { registry, registeredNames } = await bridgeMcpTools(client, { namePrefix: "demo_" });
+    expect(registeredNames.sort()).toEqual([
+      "demo_add",
+      "demo_echo",
+      "demo_get_time",
+      "demo_slow_count",
+    ]);
+
+    // Dispatch through the registry — should round-trip through MCP
+    const out = await registry.dispatch("demo_add", JSON.stringify({ a: 100, b: 1 }));
+    expect(out).toContain("101");
+  }, 30_000);
+
+  it("bridges two MCP servers into a shared registry with different prefixes", async () => {
+    // Two instances of the same demo server, namespaced `a_` and `b_`.
+    // Proves the multi-server CLI wiring: both dispatches go through
+    // their respective subprocesses without cross-talk.
+    const tA = new StdioTransport({ command: NODE_CMD, args: DEMO_SERVER_ARGS, shell: false });
+    const a = new McpClient({ transport: tA, requestTimeoutMs: 15_000 });
+    const tB = new StdioTransport({ command: NODE_CMD, args: DEMO_SERVER_ARGS, shell: false });
+    const b = new McpClient({ transport: tB, requestTimeoutMs: 15_000 });
+    try {
+      await a.initialize();
+      await b.initialize();
+      const shared = new ToolRegistry();
+      const resA = await bridgeMcpTools(a, { registry: shared, namePrefix: "a_" });
+      const resB = await bridgeMcpTools(b, { registry: shared, namePrefix: "b_" });
+      expect(resA.registeredNames).toHaveLength(4);
+      expect(resB.registeredNames).toHaveLength(4);
+      expect(shared.size).toBe(8);
+
+      const outA = await shared.dispatch("a_add", JSON.stringify({ a: 10, b: 20 }));
+      expect(outA).toContain("30");
+      const outB = await shared.dispatch("b_add", JSON.stringify({ a: 1, b: 2 }));
+      expect(outB).toContain("3");
+    } finally {
+      await a.close();
+      await b.close();
+    }
+  }, 30_000);
+});

tests/mcp-shell-split.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect, it } from "vitest";
+import { shellSplit } from "../src/mcp/shell-split.js";
+
+describe("shellSplit", () => {
+  it("splits a simple space-separated command", () => {
+    expect(shellSplit("npx -y @scope/pkg /tmp")).toEqual(["npx", "-y", "@scope/pkg", "/tmp"]);
+  });
+
+  it("collapses runs of spaces and tabs", () => {
+    expect(shellSplit("a   b\tc")).toEqual(["a", "b", "c"]);
+  });
+
+  it("respects double quotes around paths with spaces", () => {
+    expect(shellSplit('npx pkg "my dir/with spaces"')).toEqual([
+      "npx",
+      "pkg",
+      "my dir/with spaces",
+    ]);
+  });
+
+  it("respects single quotes and keeps inner backslashes literal", () => {
+    expect(shellSplit("cmd 'a\\b c'")).toEqual(["cmd", "a\\b c"]);
+  });
+
+  it("processes backslash escapes inside double quotes", () => {
+    expect(shellSplit('cmd "a\\"b"')).toEqual(["cmd", 'a"b']);
+  });
+
+  it("passes backslashes through literally OUTSIDE quotes (so Windows paths don't mangle)", () => {
+    // Critical for `reasonix chat --mcp "... C:\\path\\to\\dir"`. Users
+    // who want to escape a space outside quotes can quote the arg.
+    expect(shellSplit("cmd C:\\path\\to\\file.exe")).toEqual(["cmd", "C:\\path\\to\\file.exe"]);
+  });
+
+  it("throws on unterminated double quote", () => {
+    expect(() => shellSplit('cmd "unterminated')).toThrow(/unterminated/);
+  });
+
+  it("throws on unterminated single quote", () => {
+    expect(() => shellSplit("cmd 'still open")).toThrow(/unterminated/);
+  });
+
+  it("returns empty array on whitespace-only input", () => {
+    expect(shellSplit("   ")).toEqual([]);
+    expect(shellSplit("")).toEqual([]);
+  });
+});

tests/mcp-spec.test.ts

@@ -0,0 +1,97 @@
+import { describe, expect, it } from "vitest";
+import { parseMcpSpec } from "../src/mcp/spec.js";
+
+describe("parseMcpSpec: stdio", () => {
+  it("parses a namespaced spec", () => {
+    const spec = parseMcpSpec("fs=npx -y @scope/fs /tmp/dir");
+    expect(spec.transport).toBe("stdio");
+    if (spec.transport !== "stdio") throw new Error("unreachable");
+    expect(spec.name).toBe("fs");
+    expect(spec.command).toBe("npx");
+    expect(spec.args).toEqual(["-y", "@scope/fs", "/tmp/dir"]);
+  });
+
+  it("parses an anonymous spec (no name=)", () => {
+    const spec = parseMcpSpec("npx -y @scope/fs /tmp/dir");
+    expect(spec.transport).toBe("stdio");
+    if (spec.transport !== "stdio") throw new Error("unreachable");
+    expect(spec.name).toBeNull();
+    expect(spec.command).toBe("npx");
+    expect(spec.args).toEqual(["-y", "@scope/fs", "/tmp/dir"]);
+  });
+
+  it("does NOT treat Windows drive letters as a namespace", () => {
+    // `C:\...` matches the colon but NOT the identifier regex [a-zA-Z_]\w* =
+    // So it stays anonymous with the whole path as command.
+    const spec = parseMcpSpec("C:\\path\\to\\server.exe arg1");
+    expect(spec.transport).toBe("stdio");
+    if (spec.transport !== "stdio") throw new Error("unreachable");
+    expect(spec.name).toBeNull();
+    expect(spec.command).toBe("C:\\path\\to\\server.exe");
+    expect(spec.args).toEqual(["arg1"]);
+  });
+
+  it("handles quoted args in the body", () => {
+    const spec = parseMcpSpec('myserver=cmd "path with spaces" --flag');
+    if (spec.transport !== "stdio") throw new Error("unreachable");
+    expect(spec.name).toBe("myserver");
+    expect(spec.command).toBe("cmd");
+    expect(spec.args).toEqual(["path with spaces", "--flag"]);
+  });
+
+  it("trims leading/trailing whitespace", () => {
+    const spec = parseMcpSpec("  fs=npx pkg  ");
+    if (spec.transport !== "stdio") throw new Error("unreachable");
+    expect(spec.name).toBe("fs");
+    expect(spec.command).toBe("npx");
+    expect(spec.args).toEqual(["pkg"]);
+  });
+
+  it("throws on empty input", () => {
+    expect(() => parseMcpSpec("")).toThrow(/empty MCP spec/);
+    expect(() => parseMcpSpec("   ")).toThrow(/empty MCP spec/);
+  });
+
+  it("throws when name is given but no command follows", () => {
+    expect(() => parseMcpSpec("fs=")).toThrow(/has name but no command/);
+    expect(() => parseMcpSpec("fs=   ")).toThrow(/has name but no command/);
+  });
+
+  it("allows underscores and digits in the name (but not leading digit)", () => {
+    const ok = parseMcpSpec("my_fs2=cmd");
+    expect(ok.name).toBe("my_fs2");
+    // Leading digit → not a valid identifier → whole thing is command
+    // (since `2fs` doesn't match identifier regex).
+    const s = parseMcpSpec("2fs=cmd");
+    if (s.transport !== "stdio") throw new Error("unreachable");
+    expect(s.name).toBeNull();
+    expect(s.command).toBe("2fs=cmd");
+  });
+});
+
+describe("parseMcpSpec: sse", () => {
+  it("parses an anonymous https URL", () => {
+    const spec = parseMcpSpec("https://example.com/sse");
+    expect(spec.transport).toBe("sse");
+    if (spec.transport !== "sse") throw new Error("unreachable");
+    expect(spec.name).toBeNull();
+    expect(spec.url).toBe("https://example.com/sse");
+  });
+
+  it("parses a namespaced http URL (localhost dev)", () => {
+    const spec = parseMcpSpec("local=http://127.0.0.1:9000/sse");
+    if (spec.transport !== "sse") throw new Error("unreachable");
+    expect(spec.name).toBe("local");
+    expect(spec.url).toBe("http://127.0.0.1:9000/sse");
+  });
+
+  it("is case-insensitive on the scheme", () => {
+    const spec = parseMcpSpec("HTTPS://example.com/sse");
+    expect(spec.transport).toBe("sse");
+  });
+
+  it("does not match ws:// as SSE (falls through to stdio)", () => {
+    const spec = parseMcpSpec("ws://example.com/mcp");
+    expect(spec.transport).toBe("stdio");
+  });
+});

tests/mcp-sse.test.ts

@@ -0,0 +1,227 @@
+/**
+ * SSE transport tests.
+ *
+ * Strategy: spin up a tiny in-process http.Server that implements the
+ * 2024-11-05 MCP HTTP+SSE wire shape — GET emits `event: endpoint` then
+ * stays open; POSTs land a JSON-RPC response on the SSE channel. No real
+ * MCP server needed.
+ */
+
+import { type IncomingMessage, type ServerResponse, createServer } from "node:http";
+import type { AddressInfo } from "node:net";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { McpClient } from "../src/mcp/client.js";
+import { SseTransport } from "../src/mcp/sse.js";
+import { MCP_PROTOCOL_VERSION } from "../src/mcp/types.js";
+
+interface FakeSseServer {
+  url: string;
+  requests: Array<{ method: string; url: string; body?: string }>;
+  stop: () => Promise<void>;
+}
+
+interface FakeSseOptions {
+  /** Endpoint URL announced in the first SSE event. Relative or absolute. */
+  endpointPath?: string;
+  /** Override the SSE GET path (default `/sse`). */
+  ssePath?: string;
+  /** Override the POST path (default `/messages`). */
+  postPath?: string;
+  /** Auto-answer incoming JSON-RPC requests on the SSE channel. */
+  autoRespond?: (body: unknown) => unknown;
+  /** Return this status for the initial SSE GET instead of 200. */
+  handshakeStatus?: number;
+}
+
+function startFakeSseServer(opts: FakeSseOptions = {}): Promise<FakeSseServer> {
+  const ssePath = opts.ssePath ?? "/sse";
+  const postPath = opts.postPath ?? "/messages";
+  const endpointPath = opts.endpointPath ?? postPath;
+  let sseRes: ServerResponse | null = null;
+  const requests: FakeSseServer["requests"] = [];
+
+  const writeFrame = (res: ServerResponse, event: string, data: string) => {
+    res.write(`event: ${event}\ndata: ${data}\n\n`);
+  };
+
+  const server = createServer((req: IncomingMessage, res: ServerResponse) => {
+    if (req.method === "GET" && req.url === ssePath) {
+      requests.push({ method: "GET", url: req.url ?? "" });
+      if (opts.handshakeStatus && opts.handshakeStatus !== 200) {
+        res.statusCode = opts.handshakeStatus;
+        res.end("not ok");
+        return;
+      }
+      res.writeHead(200, {
+        "content-type": "text/event-stream",
+        "cache-control": "no-cache",
+        connection: "keep-alive",
+      });
+      sseRes = res;
+      writeFrame(res, "endpoint", endpointPath);
+      req.on("close", () => {
+        if (sseRes === res) sseRes = null;
+      });
+      return;
+    }
+    if (req.method === "POST" && req.url === postPath) {
+      let body = "";
+      req.setEncoding("utf8");
+      req.on("data", (chunk) => {
+        body += chunk;
+      });
+      req.on("end", () => {
+        requests.push({ method: "POST", url: req.url ?? "", body });
+        res.writeHead(202);
+        res.end();
+        if (opts.autoRespond && sseRes) {
+          let parsed: unknown;
+          try {
+            parsed = JSON.parse(body);
+          } catch {
+            return;
+          }
+          const reply = opts.autoRespond(parsed);
+          if (reply !== undefined) {
+            writeFrame(sseRes, "message", JSON.stringify(reply));
+          }
+        }
+      });
+      return;
+    }
+    res.writeHead(404);
+    res.end("not found");
+  });
+
+  return new Promise((resolve) => {
+    server.listen(0, "127.0.0.1", () => {
+      const { port } = server.address() as AddressInfo;
+      resolve({
+        url: `http://127.0.0.1:${port}${ssePath}`,
+        requests,
+        stop: () =>
+          new Promise<void>((r) => {
+            sseRes?.end();
+            server.close(() => r());
+            server.closeAllConnections?.();
+          }),
+      });
+    });
+  });
+}
+
+describe("SseTransport: handshake + round-trip", () => {
+  let fake: FakeSseServer | null = null;
+
+  beforeEach(() => {
+    fake = null;
+  });
+  afterEach(async () => {
+    await fake?.stop();
+  });
+
+  it("resolves a relative endpoint URL against the SSE base", async () => {
+    fake = await startFakeSseServer({
+      endpointPath: "/messages",
+      autoRespond: (req) => ({
+        jsonrpc: "2.0",
+        id: (req as { id: number }).id,
+        result: { ok: true },
+      }),
+    });
+    const transport = new SseTransport({ url: fake.url });
+    await transport.send({ jsonrpc: "2.0", id: 1, method: "ping" });
+
+    // Read one incoming message.
+    const iter = transport.messages();
+    const first = await iter.next();
+    expect(first.done).toBe(false);
+    expect(first.value).toMatchObject({ id: 1, result: { ok: true } });
+    await transport.close();
+  });
+
+  it("drives a full McpClient initialize → tools/list round-trip", async () => {
+    fake = await startFakeSseServer({
+      autoRespond: (raw) => {
+        const req = raw as { id?: number; method: string };
+        if (req.id === undefined) return undefined; // notification (initialized)
+        if (req.method === "initialize") {
+          return {
+            jsonrpc: "2.0",
+            id: req.id,
+            result: {
+              protocolVersion: MCP_PROTOCOL_VERSION,
+              serverInfo: { name: "fake-sse", version: "0.0.0" },
+              capabilities: { tools: { listChanged: false } },
+            },
+          };
+        }
+        if (req.method === "tools/list") {
+          return {
+            jsonrpc: "2.0",
+            id: req.id,
+            result: {
+              tools: [
+                {
+                  name: "ping",
+                  description: "responds pong",
+                  inputSchema: { type: "object", properties: {} },
+                },
+              ],
+            },
+          };
+        }
+        return {
+          jsonrpc: "2.0",
+          id: req.id,
+          error: { code: -32601, message: `no such method ${req.method}` },
+        };
+      },
+    });
+    const client = new McpClient({ transport: new SseTransport({ url: fake.url }) });
+    const info = await client.initialize();
+    expect(info.serverInfo.name).toBe("fake-sse");
+    const { tools } = await client.listTools();
+    expect(tools).toHaveLength(1);
+    expect(tools[0]!.name).toBe("ping");
+
+    await client.close();
+
+    // We should have exactly: GET /sse, POST initialize, POST notifications/initialized, POST tools/list
+    const posts = fake.requests.filter((r) => r.method === "POST");
+    expect(posts).toHaveLength(3);
+    const methods = posts.map((p) => (JSON.parse(p.body!) as { method: string }).method);
+    expect(methods).toEqual(["initialize", "notifications/initialized", "tools/list"]);
+  });
+
+  it("accepts an absolute endpoint URL", async () => {
+    // Spin up a first server just to get a port we can embed in the other.
+    const probe = await startFakeSseServer();
+    const absoluteEndpoint = new URL("/messages", probe.url).toString();
+    await probe.stop();
+
+    fake = await startFakeSseServer({
+      endpointPath: absoluteEndpoint,
+      autoRespond: (req) => ({
+        jsonrpc: "2.0",
+        id: (req as { id: number }).id,
+        result: { pong: true },
+      }),
+    });
+    // Point the SSE transport at THIS server, but have it advertise the
+    // stale probe URL — we care that the client stores it verbatim
+    // rather than resolving it against the base, so the POST will land
+    // on the dead probe port and fail. That's the assertion.
+    const t = new SseTransport({ url: fake.url });
+    await expect(t.send({ jsonrpc: "2.0", id: 1, method: "ping" })).rejects.toThrow();
+    await t.close();
+  });
+
+  it("surfaces a handshake failure as a synthetic error frame", async () => {
+    fake = await startFakeSseServer({ handshakeStatus: 500 });
+    const t = new SseTransport({ url: fake.url });
+    // Any pending send() rejects with the handshake error.
+    await expect(t.send({ jsonrpc: "2.0", id: 1, method: "ping" })).rejects.toThrow(/500/);
+    await t.close();
+  });
+});