feat: web dashboard + auto/flash/pro preset rework (0.12.0)

Web dashboard at /dashboard slash — 12 panels, modal mirroring back to
the live TUI, bidirectional chat. 127.0.0.1 only, ephemeral token,
CSRF on every mutation. Preact + HTM SPA, no build step. Drawer-style
CodeMirror editor (click any path in chat tool cards).

- src/server/ — HTTP server, 16 endpoints, SSE event stream
- dashboard/ — embedded SPA (3 files, ~1600 LOC)
- src/cli/ui/slash/handlers/dashboard.ts — /dashboard slash entry
- src/cli/ui/App.tsx — broadcast hooks for events / modals / stats

Preset semantics rework: auto / flash / pro replaces fast / smart / max.
- auto: flash baseline + auto-escalate (current behavior, default)
- flash: lock to flash, no escalation
- pro: lock to pro, no downgrade
- loop.autoEscalate flag gates NEEDS_PRO marker + failure-threshold paths
- applyPresetLive callback flips loop.model + autoEscalate live (no
  session restart needed — closes the "switched to max but still on
  flash" gap the user reported)

Other:
- cacheSavingsUsd telemetry helper + UsageBucket field, surfaced in
  /stats dashboard + web Usage chart
- BUILTIN_ALLOWLIST exported, removeProjectShellAllowed +
  clearProjectShellAllowed in src/config.ts (powers Permissions panel)
- marked v12 renderer hardened (token-vs-positional + null text coerce)
- CodeMirror multi-instance bug fixed via esm.sh ?deps= pinning

1568 tests pass. 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,11 @@ sessions/
 !benchmarks/tau-bench/transcripts/
 !benchmarks/tau-bench/transcripts/*.jsonl
 .turbo/
+# Local-only Claude Code settings — personal overrides, never committed.
+.claude/settings.local.json
+# Per-user Reasonix state under .reasonix/ — committable team-level
+# files (settings.json, skills/) stay tracked, but the user-private
+# bits (semantic index, sessions, opt-out markers) never should.
+.reasonix/semantic/
+.reasonix/sessions/
+.reasonix/semantic-skip

README.zh-CN.md

@@ -0,0 +1,836 @@
+<p align="center">
+  <img src="docs/logo.svg" alt="Reasonix — DeepSeek 原生的 agent 框架" width="640"/>
+</p>
+
+<p align="center">
+  <em>为 DeepSeek V4（flash + pro）打造的缓存优先 agent 循环 — Ink TUI、原生 MCP、不依赖 LangChain。</em>
+</p>
+
+<p align="center">
+  <a href="./README.md">English</a> · <strong>简体中文</strong> · <a href="https://esengine.github.io/reasonix/">官方网站</a>
+</p>
+
+# Reasonix
+
+[![npm version](https://img.shields.io/npm/v/reasonix.svg)](https://www.npmjs.com/package/reasonix)
+[![CI](https://github.com/esengine/reasonix/actions/workflows/ci.yml/badge.svg)](https://github.com/esengine/reasonix/actions/workflows/ci.yml)
+[![license](https://img.shields.io/npm/l/reasonix.svg)](./LICENSE)
+[![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)
+
+**DeepSeek 原生的终端 AI 编程代理。** 单次任务成本约为 Claude Code 的
+1/30，缓存优先的循环是为 DeepSeek 的定价模型量身打造的。编辑以可审查的
+SEARCH/REPLACE 块呈现，落盘前必须确认。MIT 许可、不绑 IDE、原生 MCP。
+
+---
+
+## 60 秒快速上手
+
+**1. 获取 DeepSeek API Key。** 注册即送免费额度：
+<https://platform.deepseek.com/api_keys>
+
+**2. 切到项目目录运行。** 无需安装。
+
+```bash
+cd my-project
+npx reasonix code
+```
+
+首次运行会走 30 秒向导（粘贴 API key → 选预设 → 多选 MCP 服务器）。
+之后每次直接进入。
+
+**3. 让它改代码。** 模型会以 SEARCH/REPLACE 块的形式提出编辑——
+你不 `/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 处待应用编辑（1 个文件）— /apply 写入 · /discard 丢弃
+
+reasonix code › /apply
+▸ ✓ applied src/users.ts
+```
+
+要求 Node ≥ 20.10。支持 macOS、Linux、Windows（PowerShell · Git Bash ·
+Windows Terminal）。任何时候按 `Esc` 中断；`/help` 查看完整命令列表。
+
+---
+
+## 为什么选 Reasonix？（vs Cursor / Claude Code / Cline / Aider）
+
+三件事，别家不会同时都给你：
+
+- **成本节省落到账单上。** DeepSeek V4 的 token 单价大约是 Claude Sonnet
+  的 1/30。光便宜还不够 —— *便宜的 token 配上 90%+ 的前缀缓存命中*才是关键。
+  Reasonix 的循环按 append-only 增长设计，缓存稳定的前缀在每次工具调用之间
+  都活着，下面的 benchmark 章节端到端验证过：实测 94.4% 缓存命中，对照组通用
+  框架只有 46.6%。`/stats` 面板每轮都跟踪 "vs Claude Sonnet 4.6" 的节省额，
+  你可以亲眼看着账单不涨。
+
+- **它住在终端里。** 纯 CLI —— 没有 Electron，没有 VS Code 插件，没有要
+  塞进编辑器的 IDE 插件。和 git、tmux、shell 历史并排。macOS / Linux /
+  Windows（PowerShell、Git Bash、Windows Terminal 都测过）。唯一的网络
+  请求就是 DeepSeek API 本身，中间没有厂商服务器。
+
+- **开源且彻底可改。** MIT 许可的 TypeScript。整个循环、工具注册表、
+  缓存稳定前缀、TUI、MCP 桥接 —— 全部在 `src/` 下，不到 3 万行。Fork
+  它、做私有构建、塞进 CI 都可以。没有 SaaS 层，没有企业版，没有功能闸门。
+
+| | Reasonix | Claude Code | Cursor | Cline | Aider |
+|---|---|---|---|---|---|
+| 后端 | 仅 DeepSeek V4 | 仅 Anthropic | OpenAI / Anthropic | 任意（OpenRouter）| 任意（OpenRouter）|
+| 单次任务成本 | **~$0.001–$0.005** | ~$0.05–$0.50 | $20/月 + 用量 | 视情况 | 视情况 |
+| 运行环境 | 终端 | 终端 + IDE | IDE（Electron）| 仅 VS Code | 终端 |
+| 开源协议 | **MIT** | 闭源 | 闭源 | Apache 2 | Apache 2 |
+| 缓存优先前缀循环 | **工程化（94% 命中）** | 基础 | n/a | n/a | 基础 |
+| MCP 服务器 | **原生支持** | 原生支持 | — | 测试中 | — |
+| 计划模式（只读审计闸门）| **支持** | 支持 | — | 支持 | — |
+| 用户编写的 skills | **支持** | 支持 | — | — | — |
+| 编辑审阅（不自动落盘）| **支持**（`/apply`）| 支持 | 部分 | 支持 | 支持 |
+| 工作区切换（`/cwd`、`change_workspace`）| **支持** | — | n/a（每窗一项目）| — | — |
+| 跨会话成本面板 | **支持**（`/stats`）| — | — | — | — |
+| 沙箱边界强制 | **严格**（拒绝 `..` 逃逸）| 支持 | 部分 | 支持 | 部分 |
+
+### 这些情况下应该选别的
+
+- **你想要多模型混用**（在一个工具里同时切 Claude / GPT / Gemini / 本地 Llama）。
+  试试 [Aider](https://aider.chat) 或 [Cline](https://cline.bot)。Reasonix
+  故意只绑 DeepSeek —— 每一层（缓存优先循环、R1 harvest、JSON 模式的工具
+  调用修复、reasoning_effort 上限）都是为 DeepSeek 的具体行为和经济模型
+  调出来的。绑死后端是设计选择，不是早晚要解决的限制。
+- **你想要 IDE 集成**（编辑器侧边栏 inline diff、多光标、ghost text、重构
+  预览）。试试 [Cursor](https://cursor.com) 或 Claude Code 的 IDE 模式。
+  Reasonix 是终端优先的：diff 在 `git diff` 里、文件树在 `ls` 里、对话
+  在 shell 里。
+- **你在追最难的推理 benchmark**。Claude Opus 4.6 还是赢一些榜单的。
+  DeepSeek V4-pro 在大多数编程任务上都很有竞争力，但不是每个 benchmark
+  都领先。如果你的任务是"证明这个 PhD 级别的数学命题"而不是"修这个
+  auth bug"，从 Claude 起步更合适。
+- **你需要完全本地 / 永远免费**。DeepSeek API 注册送额度，但不是永久
+  免费。要真正离线/永久免费，看看 Aider + Ollama 或者
+  [Continue](https://continue.dev)。
+
+### "DeepSeek 现在有 Anthropic 兼容 API 了，我直接拿 Claude Code 接上不就行？"
+
+可以接。DeepSeek 官方提供了 Anthropic 兼容端点
+`https://api.deepseek.com/anthropic`，Claude Code（或任何 Anthropic SDK
+客户端）不改一行代码就能连上去。**协议跑得通，缓存经济学跑不通** ——
+而后者才是关键。
+
+看 [DeepSeek 自己的兼容性表](https://api-docs.deepseek.com/guides/anthropic_api)：
+
+| 字段 | 在 DeepSeek 兼容端点上的状态 |
+|---|---|
+| `cache_control` 标记 | **Ignored（被忽略）** |
+| `mcp_servers`（API 层）| Ignored |
+| `thinking.budget_tokens` | Ignored |
+| 图像 / 文档 / 引用 | 不支持 |
+
+`cache_control: Ignored` 就是杀手级的那一行。这里有**两套完全不同的缓存
+机制在打架**：
+
+| | Anthropic 原生 | DeepSeek 自动缓存 |
+|---|---|---|
+| 模型 | **Marker 驱动。** 你在某条消息上打 `cache_control`，Anthropic 把"到此 marker 为止"的内容做内容寻址缓存。多个 marker = 多个独立断点。 | **Byte-stable prefix。** 缓存对字面字节流从第 0 字节起做指纹。 |
+| Claude Code 的设计 | 围绕这个设计的。在 system prompt + tool 定义上插 marker，让 loop 在 marker 之后做重排、压缩、插元数据都不丢缓存。 | n/a —— Claude Code 不是为 byte-stable prefix 设计的。 |
+| Claude Code 接 DeepSeek 兼容端点之后 | Marker 被 strip（忽略）。Claude Code 的主缓存策略消失。 | Fallback 到 auto-cache。但 Claude Code 的 prefix 不是 byte-stable 的（marker 本来就是 byte-stability 的*替代*），auto-cache 也命中不了。 |
+
+净效果：**Claude Code 的 loop 重定向到 DeepSeek 之后，便宜 token 拿到了，
+原本依赖的缓存命中没了**。一个在 Anthropic marker cache 上 80%+ 命中的
+loop，到 DeepSeek 的 auto-cache 上大概率掉到 40-60%（跟我们 benchmark 里
+通用 harness 的 baseline 同区间）。同一个模型、同一个 API、同一个负载 ——
+loop 的 invariant 跟它现在对话的缓存机制不匹配。
+
+Reasonix 的 loop 从第一行起就是按 byte-stable prefix 的不变量设计的。没有
+marker、没有断点 —— append-only 就是 invariant。这就是为什么同一份 τ-bench
+负载在 Reasonix 上是 **94.4% 缓存命中**、在 cache-hostile baseline 上是
+**46.6%**（已 commit 的 transcript，见下面 benchmark 段）。按 DeepSeek 的
+单价 —— $0.07/Mtok 非缓存、约 $0.014/Mtok 缓存命中 —— 50% 和 94% 命中之间
+**仅 input 这一侧就大约是 2.5× 的差距**。
+
+### "那 Aider / Cline / Continue 呢？"
+
+它们原生支持 DeepSeek（不需要兼容层），便宜 token 单价你确实拿到了。
+但你拿不到 DeepSeek-specific 的循环工程 —— 这些工具的 loop 是为**通用支持**
+所有后端（OpenAI / Anthropic / 本地 Llama / ...）设计的，用的是那种会破坏
+byte-stability 的通用压缩 / 摘要模式。命中率落在和 baseline 同样的 40-60%
+区间。再加上一堆 DeepSeek 怪癖通用 loop 不处理：
+
+| 通用 loop 假定 | DeepSeek 实际行为 | Reasonix 怎么处理 |
+|---|---|---|
+| 推理通过结构化 `thinking` 块产出 | R1 偶尔把 tool-call JSON 漏到 `<think>` 标签里 | `scavenge` 扫描把漏出的 tool call 拣回，否则模型以为自己已经调用，等不到结果 |
+| tool schema 严格校验 | DeepSeek 静默丢弃深嵌套 object/array 参数 | auto-flatten：嵌套参数被重写成单层 prefixed name，模型才看得见 |
+| tool-call args 是良构 JSON | DeepSeek 偶发 `string="false"` 之类的破碎片段 | 专用 `ToolCallRepair` 在 dispatch 之前修好常见形状 |
+| 推理深度靠系统级开关 | V4 直接暴露 `reasoning_effort` 旋钮（`max` / `high`） | `/effort` slash + `--effort` flag，简单任务可以降到 high 省钱 |
+| 老 tool result 永久保留 | 1M context 不需要主动 compact，但通用工具都会做 | call-storm breaker + 结果 token cap，但前缀**永不重写** —— 压缩作为新 turn 追加在尾部 |
+
+> 缓存稳定性不是一个开关，是 loop 设计之初就要建立的不变量。Reasonix
+> 不是"又一个 agent CLI"，是**围绕 DeepSeek 具体的缓存机制和定价模型
+> 设计的 agent CLI**。
+
+---
+
+## `reasonix code` — 终端里的结对编程
+
+作用域为启动目录。模型自带 `read_file` / `write_file` / `edit_file` /
+`list_directory` / `search_files` / `directory_tree` / `get_file_info` /
+`create_directory` / `move_file`，全部在沙箱内 —— 任何解析后落到启动根目录之外
+的路径（包括 `..` 或符号链接逃逸）都会被拒绝。再加上带只读白名单的
+`run_command`；任何会修改状态的命令（`npm install`、`git commit` 等）都要走
+确认弹窗。
+
+### 流程演示：先看再改
+
+对于"这段代码做什么用？"这类问题，模型会用读取类工具，然后用散文回答 ——
+不会出 SEARCH/REPLACE 块、也不会写文件。只有你明确要求修改时它才动手：
+
+```
+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 写子路径，最后 …
+```
+
+`edit_file` 的 SEARCH 块如果没有按字节精确匹配文件内容，编辑会被显式拒绝
+而不是模糊匹配。模型能看到错误并自行重试 —— 比起"静默改错"，"显式拒绝"
+是更安全的失败方式。
+
+### Plan 模式 —— 执行前先审阅
+
+任何比"改个 typo"更大的改动，模型会被引导先提交一份 markdown 计划。
+你会看到 **批准 / 重做 / 取消** 三选一：
+
+```
+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
+```
+
+**强制启用** 用 `/plan` —— 进入显式只读阶段：模型必须先提交计划，否则任何
+编辑或非白名单 shell 调用都不会执行。适合那些你想先审一遍再让模型动手的
+高风险改动。`/plan off` 或在弹窗里选 Approve/Cancel 退出。
+
+### 输入前缀 —— `!cmd` 与 `@path`
+
+两个不需要斜杠的内联快捷方式：
+
+**`!<cmd>` —— 在沙箱里跑 shell 命令并把结果喂给模型。** 像 bash 一样在
+prompt 里直接打。输出既会进入可见日志，也会进入会话 —— 模型下一轮会基于它
+推理：
+
+```
+reasonix code › !git status --short
+▸ M src/users.ts
+▸ M src/users.test.ts
+
+reasonix code › 把这两个文件的改动说明一下
+assistant
+  ▸ tool<read_file> → src/users.ts, src/users.test.ts
+  ▸ …
+```
+
+无白名单门 —— 用户主动输入的 shell 命令就是显式同意。60 秒超时、32k 字符
+上限，0.5.14 起会话恢复后依然保留。
+
+**`@path/to/file` —— 内联一个文件作为 "Referenced files"。** 输入 `@`
+弹出选择器（↑/↓ 切换、Tab/Enter 插入）。比让模型 `read_file` 后再问更省事：
+"@src/users.ts 这个文件做什么用？"。沙箱限定：仅相对路径、不允许 `..`、单
+文件 64KB 上限。最近用过的文件排在前面。
+
+### `/commit` —— 一步暂存 + 提交
+
+```
+reasonix code › /commit "fix: findByEmail case-insensitive"
+▸ git add -A && git commit -m "fix: findByEmail case-insensitive"
+  [main a1b2c3d] fix: findByEmail case-insensitive
+```
+
+### 一些值得试试的命令
+
+- `/tool 1` —— 打印最后一次工具调用的完整输出（当 400 字内联剪辑不够看时）。
+- `/think` —— 看上一轮模型的完整推理（思考模式：v4-flash / v4-pro / reasoner 别名）。
+- `/undo` —— 回滚上一批已应用的编辑。
+- `/new` —— 在同一目录开新会话，但不丢失旧会话文件。
+- `/effort high` —— 从默认 `max` agent 推理强度降一档，简单任务更省更快。
+- `npx reasonix code --preset max` —— v4-pro + 三路 self-consistency 分支，
+  适合疑难重构。
+- `npx reasonix code src/` —— 更窄的沙箱（只有 `src/` 可写）。
+- `npx reasonix code --no-session` —— 临时会话，什么都不存。
+
+### `reasonix stats` —— 你到底省了多少？
+
+每次 `reasonix chat|code|run` 跑完都会往
+`~/.reasonix/usage.jsonl` 追加一条精简记录（token + 成本 + Claude Sonnet
+4.6 同负载下的等价价格）。`reasonix stats` 不带参数会把日志聚合成今日 /
+本周 / 本月 / 历史 四个窗口：
+
+```
+Reasonix usage — /Users/you/.reasonix/usage.jsonl
+
+            turns  cache hit    cost (USD)      vs Claude     saved
+----------------------------------------------------------------------
+today           8      95.1%     $0.004821        $0.1348      96.4%
+week           34      93.8%     $0.023104        $0.6081      96.2%
+month         127      94.2%     $0.081530        $2.1452      96.2%
+all-time      342      94.0%     $0.210881        $5.8934      96.4%
+```
+
+隐私：日志里只有 token、成本和你自己取的 session 名。没有 prompt、没有
+completion、没有工具参数。`reasonix stats <transcript>` 仍兼容老用法
+（按文件出 assistant turn + tool call 摘要）。
+
+### 保持最新
+
+面板顶栏在 `Reasonix` 旁边显示当前版本（如
+`Reasonix v0.5.21 · deepseek-v4-pro · harvest · max …`，最后那个 `max` 是
+推理强度徽章 —— `/effort high` 可降一档）。后台每 24 小时静默查询一次 npm
+registry，发现新版会在同一行右侧显示黄色 `update: X.Y.Z`。不阻塞、不烦人，
+每天最多查一次，离线 / 防火墙下静默失败。
+
+```bash
+reasonix update             # 打印当前 vs 最新，并执行 `npm i -g reasonix@latest`
+reasonix update --dry-run   # 只打印计划，不实际安装
+```
+
+通过 `npx` 用？命令会识别这种情况并改为打印 cache 刷新提示 —— npx 在下次
+调用时会自动取最新版本。
+
+### 项目约定 —— `REASONIX.md`
+
+把 `REASONIX.md` 放到项目根目录，每次启动都会被钉进 system prompt。可提交
+的团队记忆 —— 房间约定、领域词表、模型老忘的事情：
+
+```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
+```
+
+重启（或 `/new`）后生效；前缀每会话只哈希一次，让 DeepSeek 的缓存保持热。
+`/memory` 打印当前已钉的内容。`REASONIX_MEMORY=off` 在 CI / 离线复现时关闭
+所有记忆来源。
+
+### 用户记忆 —— `~/.reasonix/memory/`
+
+第二层 **私人按用户** 的记忆放在你的 home 目录。不像 `REASONIX.md` 会被
+提交，模型自己也能通过 `remember` 工具往里写。两个作用域：
+
+- `~/.reasonix/memory/global/` —— 跨项目（你的偏好、工具链）。
+- `~/.reasonix/memory/<project-hash>/` —— 限定一个 `reasonix code` 沙箱
+  根目录（决策、本地事实、按仓库的快捷方式）。
+
+每个作用域都维护一个总是加载的 `MEMORY.md` 索引（一行一条）+ 零或多个
+`<name>.md` 详情文件（按需通过 `recall_memory` 加载）。写入立刻生效；钉进
+system prompt 在下一次 `/new` 或重启时生效，以保证当前会话的缓存前缀稳定。
+
+```
+reasonix code › 我用 bun 而不是 npm，请以后都用 bun 跑构建
+
+assistant
+  ▸ tool<remember> → project/bun_build saved
+    "Build command on this machine is `bun run build`"
+```
+
+**斜杠**：`/memory` · `/memory list` · `/memory show <name>` ·
+`/memory forget <name>` · `/memory clear <scope> confirm`。
+**模型工具**：`remember(type, scope, name, description, content)` ·
+`forget(scope, name)` · `recall_memory(scope, name)`。
+
+项目作用域只在 `reasonix code` 里可用（需要真实的沙箱根来计算哈希）；纯
+`reasonix` 只有全局作用域。
+
+### Skills —— 用户自定义的 prompt 包
+
+Skill 就是你写在磁盘上的散文指令块。Reasonix 把它们的名字 + 一行描述钉
+进 system prompt；模型可以在合适时机自动调 `run_skill({name: "..."})`，
+你也可以打 `/skill <name> [args]` 手动触发。
+
+两个作用域，与用户记忆同样的布局：
+
+- `<project>/.reasonix/skills/` —— 按项目（提交进 git 给团队，或加入
+  `.gitignore` 做个人草稿）。
+- `~/.reasonix/skills/` —— 全局，到处可用。
+
+两种文件结构都行：`<name>/SKILL.md`（推荐 —— 可同时打包附带资源）或扁平
+`<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.
+```
+
+用法：
+
+```
+reasonix code › /skill review
+▸ running skill: review
+assistant
+  ▸ tool<run_command> → git diff --cached
+  ▸ 3 改动，1 个需要回归测试 …
+```
+
+或者让模型自己挑 —— 因为 skill 名字 + 描述都在前缀里，问 "帮我看下未提交
+的改动有没有风险" 就会触发 `run_skill({name: "review"})`，不用你打斜杠。
+
+**斜杠**：`/skill`（列出） · `/skill show <name>` · `/skill <name>
+[args]`（把 body 作为用户轮注入）。
+
+**故意不绑死** 任何其他客户端的目录约定（`.claude/skills` 等等）——
+Reasonix 在对话层是模型无关的。任何 SKILL.md 都能用；body 是散文，所以
+为别的工具写的 skill 多半能直接用（Reasonix 工具名不同 —— `filesystem`
+/ `shell` / `web` —— 但模型读到指令后会挑我们的等价工具）。
+
+### Hooks —— 围绕工具调用与轮次自动化
+
+在 `.reasonix/`（项目或 `~/`）放一个 `settings.json`，Reasonix 会在
+循环里四个常见的点触发 shell 命令：工具运行前、工具返回后、prompt 到达
+模型前、轮次结束后。
+
+```json
+// <project>/.reasonix/settings.json   ← 可提交
+// ~/.reasonix/settings.json           ← 按用户
+{
+  "hooks": {
+    "PreToolUse":       [{ "match": "edit_file|write_file", "command": "bun scripts/guard.ts" }],
+    "PostToolUse":      [{ "match": "edit_file", "command": "biome format --write" }],
+    "UserPromptSubmit": [{ "command": "echo $(date +%s) >> ~/.reasonix/prompts.log" }],
+    "Stop":             [{ "command": "bun test --run", "timeout": 60000 }]
+  }
+}
+```
+
+每个 hook 都是 shell 命令。Reasonix 调用时通过 stdin 传一份 JSON 信封，
+描述事件：
+
+```json
+{ "event": "PreToolUse", "cwd": "/path/to/project",
+  "toolName": "edit_file", "toolArgs": { "path": "src/x.ts", "..." } }
+```
+
+退出码决定走向：
+
+- **0** —— 通过；循环正常继续
+- **2** —— 阻断（仅对 `PreToolUse` / `UserPromptSubmit` 生效）；hook 的
+  stderr 会作为合成工具结果让模型看到，或者整条 prompt 直接被丢弃
+- **其他** —— 警告；循环继续，stderr 渲染为黄色行内提示
+
+`match` 是对工具名的锚定正则；`*` 或省略匹配所有工具。项目 hook 先于全局
+hook 触发。默认超时：阻断类事件 5 秒，日志类事件 30 秒；可在每条 hook 里
+用 `timeout` 覆盖。
+
+**斜杠**：`/hooks`（列出当前生效的 hook）· `/hooks reload`（不丢会话从磁盘
+重读 `settings.json`）。
+
+### 在 TUI 里保持最新
+
+`/update` 在运行中的会话里会显示当前版本、最近一次后台 24h 检查取到的最新
+版本，以及实际安装命令。这条斜杠 **不会** 直接 spawn `npm install` ——
+stdio:inherit 进入正在跑的 Ink 渲染器会把显示搞乱。要真正升级请退出会话，
+在新 shell 里执行 `reasonix update`。
+
+---
+
+## `reasonix` —— 也能当通用聊天
+
+同一套 TUI，没有文件系统工具（除非你通过 MCP 主动接入）。适合起草、问答、
+schema 设计、架构讨论，或者驱动你自己的 MCP 服务器。会话按名字保存在
+`~/.reasonix/sessions/`。
+
+```bash
+npx reasonix                             # 用已保存配置 + 向导选过的 MCP
+npx reasonix --preset smart              # 这次跑用 reasoner + R1 harvest
+npx reasonix --session design            # 命名会话 — 之后 --session design 续聊
+```
+
+临时挂 MCP 服务器：
+
+```bash
+npx reasonix \
+  --mcp "fs=npx -y @modelcontextprotocol/server-filesystem /tmp/safe" \
+  --mcp "kb=https://mcp.example.com/sse"
+```
+
+MCP 工具走和原生工具一样的 Cache-First + 修复 + 上下文安全管线 —— 32k
+结果上限、实时进度通知渲染、自动重试。
+
+---
+
+## 会话内命令
+
+**核心**
+
+| 命令 | 作用 |
+|---|---|
+| `/help` · `/?` | 完整命令参考（带提示） |
+| `/status` | 当前模型 · flag · 上下文 · 会话 |
+| `/new` · `/reset` | 同会话内开新对话 |
+| `/clear` | 仅清空可见 scrollback（日志保留） |
+| `/retry` | 截断并重发上一条消息（重新采样） |
+| `/exit` · `/quit` | 退出 |
+
+**模型**
+
+| 命令 | 作用 |
+|---|---|
+| `/preset <fast\|smart\|max>` | 一键预设（model + harvest + branch） |
+| `/model <id>` | 切换 DeepSeek 模型（`deepseek-v4-flash`、`deepseek-v4-pro`，加上 `deepseek-chat` / `deepseek-reasoner` 兼容别名） |
+| `/models` | 列出 DeepSeek `/models` 端点的可用模型 |
+| `/harvest [on\|off]` | 切换 R1 plan-state 提取 |
+| `/branch <N\|off>` | 每轮跑 N 路并行采样，挑最佳（N ≥ 2） |
+| `/effort <high\|max>` | reasoning_effort 上限 —— `max` 是 agent 默认，`high` 更便宜更快 |
+| `/think` | 打印上一轮的完整 thinking-mode 推理 |
+
+**上下文与工具**
+
+| 命令 | 作用 |
+|---|---|
+| `/mcp` | 列出已挂载的 MCP 服务器及其 tool / resource / prompt |
+| `/resource [uri]` | 浏览 + 读取 MCP resource（无参 → 列 URI；`<uri>` → 拉取） |
+| `/prompt [name]` | 浏览 + 拉取 MCP prompt |
+| `/tool [N]` | 打印第 N 次工具调用的完整输出（1 = 最近） |
+| `/compact [tokens]` | 压缩日志里超大的工具结果（默认每条结果 4000 tokens） |
+| `/context` | 看上下文 token 都花在哪（system / tools / log） |
+| `/stats` | 跨会话成本仪表盘（today / week / month / all-time） |
+| `/keys` | 键盘快捷键 + 输入前缀（`!` / `@` / `/`）速查 |
+
+**记忆与 Skill**
+
+| 命令 | 作用 |
+|---|---|
+| `/memory` | 显示已钉记忆（REASONIX.md + ~/.reasonix/memory） |
+| `/memory list` · `show <name>` · `forget <name>` · `clear <scope> confirm` | 管理记忆库 |
+| `/skill` · `/skill list` | 列出已发现的 skill（项目 + 全局） |
+| `/skill show <name>` | 打印某个 skill 的 body |
+| `/skill <name> [args]` | 运行 skill（把 body 作为用户轮注入） |
+
+**会话**
+
+| 命令 | 作用 |
+|---|---|
+| `/sessions` | 列出已保存的会话（当前用 `▸` 标记） |
+| `/forget` | 从磁盘删除当前会话 |
+| `/setup` | 重新配置（退出后跑 `reasonix setup`） |
+
+**只在 code 模式下** (`reasonix code`)
+
+| 命令 | 作用 |
+|---|---|
+| `/apply` | 把待应用的 SEARCH/REPLACE 块写入磁盘 |
+| `/discard` | 丢弃待应用的编辑块 |
+| `/undo` | 回滚最后一批已应用的编辑 |
+| `/commit "msg"` | `git add -A && git commit -m "msg"` |
+| `/plan [on\|off]` | 切换只读 plan 模式 |
+| `/apply-plan` | 强制批准当前待审计划 |
+
+**键盘**
+
+- `Enter` —— 提交
+- `Shift+Enter` / `Ctrl+J` —— 换行（多行粘贴也行；
+  `\` + Enter 是跨平台兜底）
+- `↑` / `↓` —— 空闲时翻 prompt 历史；在斜杠自动补全里上下选
+- `/foo` 前缀下按 `Tab` / `Enter` —— 接受高亮的建议
+- `Esc` —— 中断当前轮（停 API 调用、取消进行中的工具、拒绝待响应的 MCP 请求）
+- 确认弹窗里的 `y` / `n` —— 快捷接受 / 拒绝
+
+---
+
+## 会话与安全网
+
+- 会话以 JSONL 形式保存在 `~/.reasonix/sessions/<name>.jsonl`（`reasonix
+  code` 按目录分）。每条消息都原子追加；`Ctrl+C` 不会丢上下文。
+- 工具结果每次调用最多 32k 字符。超大会话加载时自动自愈（缩小并重写文件）。
+- 每次出站 API 调用前会校验 `assistant.tool_calls` / `tool` 的配对，损坏的
+  会话不会一直 400。
+- 上下文仪表 50% 变黄、80% 变红并提示 `/compact`。接近 1M token 上限
+  （V4 flash + pro）会先尝试自动压缩，再退化为强制总结。
+- `reasonix code` 沙箱拒绝任何解析后落到启动目录之外的路径（含符号链接
+  逃逸和 `..` 穿越）。
+
+### 故障排查：重复行 / 鬼影渲染
+
+有些 Windows 终端（Git Bash / MINTTY / winpty 包装的 shell）没完整实现
+Ink 用的 ANSI cursor-up 转义。表现：spinner、流式预览、工具结果行不在原地
+覆盖刷新，反而在 scrollback 里印出多份。
+
+遇到了就用 plain 模式：
+
+```bash
+REASONIX_UI=plain npx reasonix code
+```
+
+Plain 模式抑制了实时 / 动画行，关掉了内部 tick 计时器。代价是失去流式预览
+和 spinner，但 scrollback 稳定。Windows Terminal、Windows Terminal 里的
+PowerShell 7、WezTerm 不需要这个开关。
+
+---
+
+## Web 搜索 —— 默认开
+
+模型一启动就有两个 web 工具：`web_search` 和 `web_fetch`。无 flag、无 API
+key、无注册。当你问到模型训练时没见过的事（新发布、最近事件、冷门 API），
+它会自己决定调 `web_search`；snippet 不够就跟一个 `web_fetch`。
+
+底层是 **Mojeek** 的公开搜索页 —— 独立 web 索引，bot 友好，无 cookie /
+session。冷门或非常新的查询覆盖率比 Google/Bing 薄一些，但脚本里很可靠。
+（DDG 是原始后端，但 2026 年开始上反机器人页。）
+
+**关掉**（离线 / 隐私 / CI）：
+
+```json
+// ~/.reasonix/config.json
+{ "apiKey": "sk-…", "search": false }
+```
+
+```bash
+REASONIX_SEARCH=off npx reasonix code
+```
+
+**接自己的**（Kagi、SearXNG、内部缓存）：实现 `WebSearchProvider` 接口
+然后自己调 `registerWebTools(registry, { provider })`，或通过 `--mcp`
+桥接已有的 MCP 搜索服务器。
+
+---
+
+## MCP —— 自带工具
+
+任意 [MCP](https://spec.modelcontextprotocol.io/) 服务器都能用。向导内置
+目录可选，或用 flag 直接挂：
+
+```bash
+# stdio（本地子进程）
+npx reasonix --mcp "fs=npx -y @modelcontextprotocol/server-filesystem /tmp/safe"
+
+# 同时挂多个
+npx reasonix \
+  --mcp "fs=npx -y @modelcontextprotocol/server-filesystem /tmp/safe" \
+  --mcp "demo=npx tsx examples/mcp-server-demo.ts"
+
+# HTTP+SSE（远程 / 托管）
+npx reasonix --mcp "kb=https://mcp.example.com/sse"
+```
+
+`reasonix mcp list` 显示精选目录。`reasonix mcp inspect <spec>` 不开聊天，
+直接连一次并打印服务器的 tool / resource / prompt。长任务的进度通知
+（2025-03-26 spec）会以进度条形式实时渲染在 spinner 里。
+
+支持的传输：**stdio**（本地命令）和 **HTTP+SSE**（远程，MCP 2024-11-05
+spec）。
+
+---
+
+## CLI 参考
+
+```bash
+npx reasonix code [path]                 # 编程模式，作用域 path（默认 cwd）
+npx reasonix                             # 聊天（用已保存配置）
+npx reasonix setup                       # 重跑配置向导
+npx reasonix chat --session work         # 命名会话
+npx reasonix chat --no-session           # 临时会话
+npx reasonix run "ask anything"          # 一次性运行，结果流到 stdout
+npx reasonix stats session.jsonl         # 总结一份 transcript
+npx reasonix replay chat.jsonl           # 从 transcript 重建成本/缓存视图
+npx reasonix diff a.jsonl b.jsonl --md   # 对比两份 transcript
+npx reasonix mcp list                    # 精选 MCP 目录
+npx reasonix mcp inspect <spec>          # 探测单个 MCP 服务器
+npx reasonix sessions                    # 列已保存会话
+```
+
+常用 flag：
+
+```bash
+--preset <fast|smart|max>   # 预设组合（model + harvest + branch）
+--model <id>                # 显式指定模型 ID
+--harvest / --no-harvest    # R1 plan-state 提取
+--branch <N>                # self-consistency 预算
+--mcp "name=cmd args…"      # 挂 MCP 服务器（可重复）
+--transcript path.jsonl     # 同时旁路写一份 JSONL transcript
+--session <name>            # 命名会话（code 模式默认按目录）
+--no-session                # 临时会话
+--no-config                 # 忽略 ~/.reasonix/config.json（CI 友好）
+```
+
+环境变量（覆盖 config）：
+
+```bash
+export DEEPSEEK_API_KEY=sk-...
+export DEEPSEEK_BASE_URL=https://...   # 可选的备用端点
+export REASONIX_MEMORY=off              # 关闭 REASONIX.md + 用户记忆
+export REASONIX_SEARCH=off              # 关闭 web_search / web_fetch
+export REASONIX_UI=plain                # 关闭实时行（鬼影绕开）
+```
+
+---
+
+## 库用法
+
+```ts
+import {
+  CacheFirstLoop,
+  DeepSeekClient,
+  ImmutablePrefix,
+  ToolRegistry,
+} from "reasonix";
+
+const client = new DeepSeekClient(); // 从环境变量读 DEEPSEEK_API_KEY
+const tools = new ToolRegistry();
+
+tools.register({
+  name: "add",
+  description: "Add two integers",
+  parameters: {
+    type: "object",
+    properties: { a: { type: "integer" }, b: { type: "integer" } },
+    required: ["a", "b"],
+  },
+  fn: ({ a, b }: { a: number; b: number }) => a + b,
+});
+
+const loop = new CacheFirstLoop({
+  client,
+  tools,
+  prefix: new ImmutablePrefix({
+    system: "You are a math helper.",
+    toolSpecs: tools.specs(),
+  }),
+  harvest: true,
+  branch: 3,
+});
+
+for await (const ev of loop.step("What is 17 + 25?")) {
+  if (ev.role === "assistant_final") console.log(ev.content);
+}
+console.log(loop.stats.summary());
+```
+
+`ChatOptions.seedTools` 接受一个预置好的 `ToolRegistry`，如果你只想要
+`reasonix code` 的 loop 接线、不要 CLI 包装。详见
+[docs/ARCHITECTURE.md](docs/ARCHITECTURE.md)。
+
+---
+
+## 性能对比 —— 缓存命中率自己也能验证
+
+这里每个抽象都对应 DeepSeek 的一个具体特性 —— 极低 token 价、R1 推理轨
+迹、自动前缀缓存、JSON 模式。通用框架把这些机会全留在桌上。
+
+| | Reasonix 默认 | 通用框架 |
+|---|---|---|
+| 前缀稳定的循环（→ 85–95% 缓存命中） | 是 | 否（每轮重建 prompt） |
+| 自动展平深层 tool schema | 是 | 否（DeepSeek 会丢参数） |
+| 带 jitter 退避的 429/503 重试 | 是 | 否（要自己写回调） |
+| 抢救泄到 `<think>` 里的 tool call | 是 | 否 |
+| 同参数重复爆发熔断 | 是 | 否 |
+| 实时缓存命中 / 成本 / vs Claude 面板 | 是 | 否 |
+
+同一 τ-bench-lite 负载（8 个多轮工具调用任务 × 3 次重复 = 每边 48 次运行），
+实测 DeepSeek `deepseek-chat`，唯一变量是前缀稳定性：
+
+| 指标 | 基线（缓存敌对） | Reasonix | 差值 |
+|---|---:|---:|---:|
+| 缓存命中 | 46.6% | **94.4%** | +47.7 pp |
+| 单任务成本 | $0.002599 | $0.001579 | **−39%** |
+| 通过率 | 96% (23/24) | **100% (24/24)** | — |
+
+**无需消耗 API 额度即可复现：**
+
+```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
+```
+
+提交进仓库的 JSONL 文件每轮带 `usage`、`cost`、`prefixHash`。Reasonix
+的前缀哈希在每次模型调用时都字节稳定；基线则每轮都变。缓存差距是从日志稳
+定性 **机械可推导** 的，不依赖于 prompt 写得不一样。
+
+完整 48 次运行报告：
+[`benchmarks/tau-bench/report.md`](./benchmarks/tau-bench/report.md)。
+用自己的 API key 复现：`npx tsx benchmarks/tau-bench/runner.ts --repeats 3`。
+
+MCP 参考运行（即使两个 MCP 子进程并发，整 5 轮也只有一个前缀哈希）：
+
+| 服务器 | 轮次 | 缓存命中 | 成本 | vs Claude |
+|---|---:|---:|---:|---:|
+| 内置 demo（`add` / `echo` / `get_time`） | 2 | **96.6%**（第 2 轮） | $0.000254 | −94.0% |
+| 官方 `server-filesystem` | 5 | **96.7%** | $0.001235 | −97.0% |
+| **两者并发** | 5 | **81.1%** | $0.001852 | −95.9% |
+
+---
+
+## Non-goals（明确不做）
+
+- **多 agent 编排 / 子 agent**（用 LangGraph）。
+- **工作流 DSL / DAG 调度 / 并行分支引擎** —— skill 是散文，模型靠正常的
+  tool-use 循环串起来。这样保住了单循环 + append-only + cache-first 三大
+  不变量。
+- **多供应商抽象**（用 LiteLLM）。Reasonix 故意只做 DeepSeek —— 每个支柱
+  （cache-first 循环、R1 抢救、tool-call 修复）都针对 DeepSeek 的具体行为
+  和经济性做了调优。绑死一家后端是特性。
+- **RAG / 向量库**（用 LlamaIndex）。
+- **Web UI / SaaS。**
+
+Reasonix 只做 DeepSeek，做到底。
+
+---
+
+## 开发
+
+```bash
+git clone https://github.com/esengine/reasonix.git
+cd reasonix
+npm install
+npm run dev code        # 用 tsx 直接从源码跑 CLI
+npm run build           # tsup 打包到 dist/
+npm test                # vitest（1482 个测试）
+npm run lint            # biome
+npm run typecheck       # tsc --noEmit
+```
+
+---
+
+## License
+
+MIT

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`."}

dashboard/index.html

@@ -0,0 +1,19 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>Reasonix</title>
+    <meta name="reasonix-token" content="__REASONIX_TOKEN__" />
+    <meta name="reasonix-mode" content="__REASONIX_MODE__" />
+    <link rel="stylesheet" href="/assets/app.css?token=__REASONIX_TOKEN__" />
+    <link rel="stylesheet" href="https://esm.sh/[email protected]/dist/uPlot.min.css" />
+    <link rel="stylesheet" href="https://esm.sh/[email protected]/styles/github-dark.min.css" />
+  </head>
+  <body>
+    <div id="root">
+      <div class="boot">loading…</div>
+    </div>
+    <script type="module" src="/assets/app.js?token=__REASONIX_TOKEN__"></script>
+  </body>
+</html>

docs/ARCHITECTURE.md

@@ -6,7 +6,11 @@ Reasonix is **opinionated, not general**. Every abstraction is justified by a
 DeepSeek-specific behavior or economic property. If it's generic, we don't
 ship it.
 
-## The three pillars
+The product north star: **coding agent that stays cheap enough to leave on**.
+A tool that quietly burns $200/month on a background project is one nobody
+uses. Every subsystem below is answerable to that goal.
+
+## The four pillars
 
 ### Pillar 1 — Cache-First Loop
 
@@ -37,49 +41,29 @@ timestamps each turn — cache hit rate in practice: <20%.
    into the log.
 
 **Metric.** `prompt_cache_hit_tokens / (hit + miss)` exposed per-turn and
-aggregated per-session. This is the user-visible proof of Pillar 1's value.
+aggregated per-session. Visible in the TUI's top-bar cache cell.
 
-### Pillar 2 — R1 Thought Harvesting *(v0.0.3, opt-in)*
+### Pillar 2 — R1 Thought Harvesting *(opt-in)*
 
-**Problem.** R1 emits extensive `reasoning_content`. DeepSeek's own docs
-recommend *not* feeding it back to the next turn. Most frameworks display it
-to the user and discard. The planning signal inside is lost.
+**Problem.** R1 / V4-thinking emits extensive `reasoning_content`. DeepSeek's
+own docs recommend *not* feeding it back to the next turn. Most frameworks
+display it to the user and discard. The planning signal inside is lost.
 
 **Solution.** A two-stage process:
 
 ```
-R1 output → Harvester (V3, cheap) → TypedPlanState
-                                     ├─ subgoals: string[]
-                                     ├─ hypotheses: string[]
-                                     ├─ uncertainties: string[]
-                                     └─ rejectedPaths: string[]
+R1 output → Harvester (v4-flash, thinking off) → TypedPlanState
+                                                  ├─ subgoals: string[]
+                                                  ├─ hypotheses: string[]
+                                                  ├─ uncertainties: string[]
+                                                  └─ rejectedPaths: string[]
 ```
 
-The harvester is a cheap V3 call with a strict JSON schema. Output is
-validated at runtime. The typed state is queryable by the orchestrator — e.g.
-"if `uncertainties.length > 2`, trigger branch sampling."
+The harvester is a cheap flash call with a strict JSON schema. Output is
+validated at runtime. **Not enabled in any preset** (see Pillar 4) — the
+additional round-trip rarely pays back, so it's `/harvest on` opt-in.
 
-### Branch-and-Select *(v0.0.5, opt-in, builds on Pillar 2)*
-
-**Why now.** DeepSeek is cheap enough that running N=3 R1 samples is still
-cheaper than a single Claude call. What was research luxury (self-consistency
-sampling) becomes a practical default.
-
-**How.** When `--branch N` (or `{ branch: N }` in code) is passed:
-
-1. The turn is forced non-streaming (N samples must complete before we can
-   compare).
-2. `runBranches` fires N `client.chat` calls in parallel, spreading
-   temperatures across `[0, 1]` to diversify reasoning paths.
-3. Each sample's `reasoning_content` is piped through Pillar 2's harvest.
-4. The default selector picks the sample with the fewest `uncertainties`;
-   ties are broken by shorter answer length (Occam).
-5. The loop emits a `branch_summary` alongside the winning `assistant_final`.
-
-**Cost.** 3× R1 on a hard math problem ≈ \$0.02 — still dominates Claude on
-cost/quality for agentic work.
-
-### Pillar 3 — Tool-Call Repair *(v0.0.1 ships complete)*
+### Pillar 3 — Tool-Call Repair
 
 **Problem.** Empirical DeepSeek failure modes:
 - Tool-call JSON emitted inside `<think>`, missing from the final message.
@@ -92,7 +76,6 @@ cost/quality for agentic work.
 1. **`flatten`** — schemas with >10 leaf params or depth >2 are auto-detected
    on `ToolRegistry.register()` and presented to the model in dot-notation
    form. `dispatch()` re-nests the args before calling the user's `fn`.
-   Opt out with `new ToolRegistry({ autoFlatten: false })`.
 2. **`scavenge`** — regex + JSON parser sweeps `reasoning_content` for any tool
    call the model forgot to emit in `tool_calls`.
 3. **`truncation`** — detect unbalanced JSON and repair by closing braces or
@@ -100,48 +83,169 @@ cost/quality for agentic work.
 4. **`storm`** — identical `(tool, args)` tuple within a sliding window →
    suppress the call, inject a reflection turn.
 
+### Pillar 4 — Cost Control *(v0.6)*
+
+**Problem.** Coding agents that default to the frontier model (v4-pro, ~12×
+flash cost) and accumulate full tool results in context are $150-$250/month
+for active users. Most turns don't need frontier reasoning; most sessions
+re-pay for tool results that were only useful once.
+
+**Solution.** Four complementary mechanisms, none of which require manual
+tuning in the common case:
+
+#### 4.1 Tiered defaults (flash-first)
+
+The three presets now trade only **model tier** and **reasoning effort**:
+
+| Preset | Model | Effort | Harvest | Branch | Cost |
+|---|---|---|---|---|---:|
+| `fast` | `v4-flash` | `high` | off | 1 | 1× |
+| `smart` (default) | `v4-flash` | `max` | off | 1 | ~1.5× |
+| `max` | `v4-pro` | `max` | off | 1 | ~12× |
+
+**Branching and harvest are never in a preset.** Both multiply cost and
+rarely pay back; `/branch N` and `/harvest on` are pure opt-ins. A user can
+run for weeks without ever touching them.
+
+All auxiliary calls — `forceSummaryAfterIterLimit`, subagent spawns,
+truncation repair retries — hard-code `v4-flash + effort=high` regardless
+of the user's preset. There's no reason to pay pro rates for "paraphrase
+these tool results into prose" or for an `explore` subagent's grep chain.
+
+#### 4.2 Turn-end auto-compaction
+
+Every tool result in the log exceeding `TURN_END_RESULT_CAP_TOKENS` (3000)
+is shrunk to that cap when a turn ends. The model had the full text for
+the turn that read it; subsequent turns see a compact summary and can
+re-read if needed. One extra `read_file` call is vastly cheaper than
+dragging 12KB through every future prompt.
+
+A proactive 40% context-ratio threshold runs the same shrink pre-emptively
+inside long multi-iter turns before the 80% emergency threshold fires.
+
+#### 4.3 `/pro` single-turn arming
+
+Users who predict a hard task type `/pro`; the **next** turn runs on
+`v4-pro`, then auto-disarms. No preset churn, no forgotten revert. Armed
+state is visible as a yellow `⇧ pro armed` pill in the header.
+
+#### 4.4 Failure-signal auto-escalation
+
+The loop counts visible "flash is struggling" events per turn:
+- `edit_file` / `write_file` SEARCH-not-found errors
+- ToolCallRepair fires (scavenge / truncation-fix / storm-break)
+
+Once the count hits `FAILURE_ESCALATION_THRESHOLD` (3), the **remainder of
+the current turn** runs on `v4-pro`. Announced via a yellow warning row —
+no silent cost surprises. Counter + escalation flag reset at every turn
+start.
+
+Header shows a red `⇧ pro escalated` pill while the turn is on pro.
+
+#### Cost transparency
+
+Per-turn and session cost are colored in the StatsPanel:
+- `turn $0.003` — green <$0.05, yellow $0.05–0.20, red ≥$0.20
+- `session $0.12` — same scale ×10
+
 ## Module layout
 
 ```
 src/
-├── client.ts          # httpx-equivalent DeepSeek client (fetch + SSE)
-├── loop.ts            # Pillar 1: Cache-First Loop (async iterator)
-├── harvest.ts         # Pillar 2 stub (v0.0.1 surface only)
-├── repair/
-│   ├── index.ts       # Pillar 3 pipeline
+├── client.ts               # DeepSeek client (fetch + SSE)
+├── loop.ts                 # Pillar 1 + 4 — CacheFirstLoop
+├── harvest.ts              # Pillar 2 — flash-backed plan-state extraction
+├── repair/                 # Pillar 3 pipeline
+│   ├── index.ts
 │   ├── scavenge.ts
 │   ├── flatten.ts
 │   ├── truncation.ts
 │   └── storm.ts
-├── tools.ts           # Tool registry + dispatch
-├── memory.ts          # Prefix / Log / Scratch primitives
-├── telemetry.ts       # Cost & cache-hit accounting
-├── types.ts           # Shared type definitions
-├── index.ts           # Library barrel export
+├── prompt-fragments.ts     # TUI_FORMATTING_RULES, NEGATIVE_CLAIM_RULE —
+│                           #   reused by main + subagent + skill prompts
+├── code/prompt.ts          # reasonix code main system prompt
+├── tools/                  # Tool implementations
+│   ├── filesystem.ts       # read / list / search / edit / write
+│   ├── shell.ts            # run_command + run_background (JobRegistry)
+│   ├── jobs.ts             # background-process registry
+│   ├── memory.ts           # remember / forget / list user memories
+│   ├── skills.ts           # list + invoke SKILL.md playbooks
+│   ├── subagent.ts         # spawn_subagent — flash+high by default
+│   ├── plan.ts             # submit_plan (review gate)
+│   └── web.ts              # web_search, web_fetch
+├── mcp/                    # MCP client + bridge (stdio + SSE)
+├── memory.ts               # ImmutablePrefix / AppendOnlyLog / VolatileScratch
+├── project-memory.ts       # REASONIX.md loader
+├── user-memory.ts          # ~/.reasonix/memory/ store (project + global)
+├── skills.ts               # built-in explore + research skills
+├── session.ts              # JSONL session persistence
+├── telemetry.ts            # cost + cache-hit accounting + SessionSummary
+├── tokenizer.ts            # DeepSeek V3 tokenizer (ported)
+├── usage.ts                # ~/.reasonix/usage.jsonl roll-up
+├── types.ts                # ChatMessage, ToolCall, ToolSpec
+├── index.ts                # library barrel
 └── cli/
-    ├── index.ts       # commander entry
-    ├── commands/      # chat, run, stats, version
-    └── ui/            # Ink React components (App, StatsPanel, EventLog, PromptInput)
+    ├── index.ts            # commander entry
+    ├── resolve.ts          # config + CLI flag precedence
+    ├── commands/           # chat, code, run, stats, sessions, ...
+    └── ui/
+        ├── App.tsx                  # root Ink component (~1984 LOC, was 2931)
+        ├── LiveRows.tsx             # spinner rows (OngoingTool / Status / ...)
+        ├── EventLog.tsx             # Historical row rendering
+        ├── StatsPanel.tsx           # top bar + cost badges
+        ├── PromptInput.tsx          # cursor-aware multi-line input
+        ├── PlanConfirm.tsx          # submit_plan review modal
+        ├── ShellConfirm.tsx         # run_command approval modal
+        ├── EditConfirm.tsx          # per-edit review modal
+        ├── markdown.tsx             # Ink-native markdown renderer
+        ├── edit-history.ts          # EditHistoryEntry + formatters
+        ├── useEditHistory.ts        # /undo, /history, /show state machine
+        ├── useCompletionPickers.ts  # slash, @, slash-arg pickers
+        ├── useSessionInfo.ts        # balance + models + updates fetch
+        ├── useSubagent.ts           # subagent sink wiring
+        └── slash/                   # /-command implementation
+            ├── types.ts             # SlashContext, SlashResult, ...
+            ├── commands.ts          # SLASH_COMMANDS data + parse + suggest
+            ├── helpers.ts           # git, memory, token formatters
+            ├── dispatch.ts          # registry + handleSlash lookup
+            └── handlers/            # per-topic: basic, mcp, memory,
+                                     # skill, admin, observability, edits,
+                                     # jobs, sessions, model (/pro lives here)
 ```
 
-## Roadmap
+Files kept small by design: the largest module under `cli/ui/` is 2K
+lines (App.tsx), every handler under `slash/handlers/` is ≤200 lines,
+every hook under `cli/ui/` is ≤310 lines. Adding a new slash command
+means editing one handler file and one registry line.
 
-- **v0.0.1** — Pillar 1 end-to-end, Pillar 3 complete, Ink TUI, τ-bench scaffold.
-- **v0.0.2** — First-run key prompt, saved to `~/.reasonix/config.json`.
-- **v0.0.3** — Pillar 2 MVP (opt-in harvest), retry layer, TextInput fix.
-- **v0.0.4** — Schema flatten auto-applied in ToolRegistry (closes Pillar 3).
-- **v0.0.5** — Self-consistency branching (`--branch N`) driven by Pillar 2
-  plan-state uncertainty count.
-- **v0.0.6** — Named session persistence (`--session <name>`), JSONL log
-  stored under `~/.reasonix/sessions/`, restored into the append-only log
-  on resume.
+## Design evolution
+
+- **v0.0.x** — Pillar 1 end-to-end, Pillar 3 complete, Ink TUI scaffold.
 - **v0.1** — τ-bench numbers published, streaming polish, transcript replay.
 - **v0.2** — Self-consistency / branch-budget sampling driven by plan state.
-- **v0.3** — MCP client, session persistence.
+- **v0.3** — MCP client (stdio + SSE), session persistence.
+- **v0.4.x** — `reasonix code` with SEARCH/REPLACE edits, review/auto
+  gate, background jobs, hooks.
+- **v0.5.x** — V4 model support, skills, memory, subagents, actionable
+  error messages.
+- **v0.6** *(current)* —
+  - **Pillar 4 cost control** (flash-first defaults, auto-compaction,
+    `/pro` one-shot, failure-triggered escalation, cost badges).
+  - `deepseek-chat` / `deepseek-reasoner` scheduled for deprecation —
+    all user-facing surfaces updated to `v4-flash` / `v4-pro`.
+  - `branch` + `harvest` removed from every preset; manual opt-in only.
+  - Shared prompt fragments (`TUI_FORMATTING_RULES`, `NEGATIVE_CLAIM_RULE`).
+  - UI refactor: App.tsx split into 6 hooks/components, slash.ts split
+    into 13 per-topic modules.
 
 ## Explicit non-goals
 
-- Multi-agent orchestration.
+- Multi-agent orchestration as a first-class concept (subagents are a
+  cost-reduction mechanism, not a coordination primitive).
 - RAG / vector retrieval.
-- Support for non-DeepSeek backends.
+- Support for non-DeepSeek backends (an OpenAI-compatible shim would
+  work today via `--model` override, but is not tested).
 - Web UI / SaaS.
+- Automatic cost escalation without user-visible announcement. Every
+  pro-tier model call is surfaced; silent escalation was considered
+  and rejected.

docs/favicon.svg

@@ -0,0 +1,12 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64">
+  <defs>
+    <linearGradient id="g" x1="0%" y1="0%" x2="100%" y2="100%">
+      <stop offset="0%" stop-color="#5eead4"/>
+      <stop offset="50%" stop-color="#93c5fd"/>
+      <stop offset="100%" stop-color="#c4b5fd"/>
+    </linearGradient>
+  </defs>
+  <rect width="64" height="64" rx="12" fill="#0a0d14"/>
+  <path d="M 32,10 L 54,32 L 32,54 L 10,32 Z" fill="none" stroke="url(#g)" stroke-width="3" stroke-linejoin="round"/>
+  <path d="M 32,21 L 43,32 L 32,43 L 21,32 Z" fill="url(#g)" opacity="0.9"/>
+</svg>

docs/i18n.js

@@ -0,0 +1,406 @@
+// Reasonix landing — i18n auto-switch (en / zh).
+// Detection precedence: ?lang=xx → localStorage → navigator.language → "en".
+// Falls back gracefully when localStorage is unavailable (private mode, etc).
+
+(function () {
+  "use strict";
+
+  const STORAGE_KEY = "reasonix.lang";
+  const DEFAULT_LANG = "en";
+  const SUPPORTED = ["en", "zh"];
+
+  const translations = {
+    en: {
+      "nav.features": "Features",
+      "nav.quickstart": "Quick start",
+      "nav.benchmarks": "Benchmarks",
+      "nav.github": "GitHub",
+
+      "hero.badge": "v0.6 · DeepSeek V4 · cache-first",
+      "hero.title.line1": "DeepSeek-native",
+      "hero.title.line2": "AI coding agent in your terminal",
+      "hero.sub":
+        "Cache-first agent loop for DeepSeek V4 (flash + pro). Edits files as reviewable SEARCH/REPLACE blocks. Ink TUI. MCP first-class. No LangChain.",
+      "hero.copy": "Copy",
+      "hero.copy.done": "Copied",
+      "hero.cta.start": "Get started →",
+      "hero.cta.star": "Star on GitHub",
+      "hero.stat.cache": "prefix cache hit rate",
+      "hero.stat.cost": "cheaper vs Claude Sonnet 4.6",
+      "hero.stat.pass": "τ-bench-lite pass rate",
+
+      "term.user":
+        "users.ts findByEmail is case-sensitive — login fails for users with uppercase emails",
+      "term.found":
+        "▸ Found it. findByEmail uses === directly. Switch to lowercase normalization.",
+      "term.pending": "▸ 1 pending edit · /apply to write · /discard to drop",
+
+      "why.title": "Why Reasonix",
+      "why.sub":
+        "Every abstraction earns its weight against a DeepSeek-specific property — dirt-cheap tokens, R1 traces, automatic prefix caching, JSON mode. Generic wrappers leave these on the table.",
+      "why.cache.title": "Cache-first loop",
+      "why.cache.body":
+        "Append-only conversation log keeps the prompt prefix byte-stable across turns, so DeepSeek's automatic cache hits 85–95% — not 40%.",
+      "why.cost.title": "Cost is a pillar",
+      "why.cost.body":
+        "Flash-first defaults, turn-end auto-compaction, model self-escalation when (and only when) needed. Per-turn cost badge in the TUI.",
+      "why.tui.title": "Ink TUI, no web",
+      "why.tui.body":
+        "Lives in your terminal. Streaming preview, slash commands, plan picker, edit-confirm modal. Plain mode for stubborn Windows shells.",
+      "why.mcp.title": "MCP first-class",
+      "why.mcp.body":
+        "Stdio + HTTP+SSE transports. Live progress notifications. Same cache-safety + repair plumbing as native tools.",
+      "why.safe.title": "Reviewable edits",
+      "why.safe.body":
+        "Edits arrive as SEARCH/REPLACE blocks; nothing hits disk until /apply. Per-file diff confirm modal, undo history, sandboxed paths.",
+      "why.ctx.title": "1M-token aware",
+      "why.ctx.body":
+        "Context gauge with proactive compaction, oversized tool-result repair, forced-summary fallback near the window edge.",
+
+      "qs.title": "Quick start (60 seconds)",
+      "qs.step1.title": "Get a DeepSeek API key",
+      "qs.step1.body":
+        'Free credit on signup at <a href="https://platform.deepseek.com/api_keys" target="_blank" rel="noopener">platform.deepseek.com</a>.',
+      "qs.step2.title": "Point it at a project",
+      "qs.step2.body": "No install needed.",
+      "qs.step2.note":
+        "First run walks you through a 30-second wizard (paste API key → pick preset → pick MCP servers).",
+      "qs.step3.title": "Ask it to edit",
+      "qs.step3.body":
+        "The model proposes edits as SEARCH/REPLACE blocks — nothing hits disk until you <code>/apply</code>.",
+      "qs.req":
+        "Requires Node ≥ 20.10. macOS, Linux, Windows (PowerShell · Git Bash · Windows Terminal). Press <kbd>Esc</kbd> anytime to abort; <code>/help</code> for the full command list.",
+
+      "feat.title": "In the box",
+      "feat.code.title": "Pair programmer mode",
+      "feat.code.body":
+        "<code>read_file</code> · <code>write_file</code> · <code>edit_file</code> · <code>search_files</code> · <code>directory_tree</code> · <code>run_command</code> with read-only allowlist. Sandboxed to the launch root — no path escapes. Plan mode and per-edit review modal.",
+      "feat.memory.title": "Two-layer memory",
+      "feat.memory.body":
+        "Committable <code>REASONIX.md</code> for team conventions plus a private per-user <code>~/.reasonix/memory/</code> with global and per-project scopes. The model can write to it via the <code>remember</code> tool.",
+      "feat.skills.title": "User-authored prompt packs",
+      "feat.skills.body":
+        "Drop <code>SKILL.md</code> files anywhere. Names + descriptions are pinned in the prefix; the model picks them autonomously, or you trigger with <code>/skill name</code>.",
+      "feat.hooks.title": "Lifecycle hooks",
+      "feat.hooks.body":
+        "Shell commands fire at <code>PreToolUse</code> · <code>PostToolUse</code> · <code>UserPromptSubmit</code> · <code>Stop</code>. Exit code drives pass / block / warn.",
+      "feat.mcp.title": "Bring your own tools",
+      "feat.mcp.body":
+        'Wizard catalog, or <code>--mcp "name=cmd"</code> to attach stdio / HTTP+SSE servers on the fly. Live progress bars on long calls.',
+      "feat.web.title": "Web search built-in",
+      "feat.web.body":
+        "<code>web_search</code> + <code>web_fetch</code> via Mojeek — no key, no signup, off-by-flag for offline / CI. Bring-your-own provider via the <code>WebSearchProvider</code> interface.",
+
+      "bench.title": "Verify the cache claim yourself",
+      "bench.sub":
+        "On the same τ-bench-lite workload (8 multi-turn tool-use tasks × 3 repeats = 48 runs per side), live DeepSeek <code>deepseek-chat</code>, sole variable prefix stability:",
+      "bench.col.metric": "metric",
+      "bench.col.baseline": "baseline (cache-hostile)",
+      "bench.col.reasonix": "Reasonix",
+      "bench.col.delta": "delta",
+      "bench.row.cache": "cache hit",
+      "bench.row.cost": "cost / task",
+      "bench.row.pass": "pass rate",
+      "bench.repro.intro": "Reproduce without spending an API credit:",
+      "bench.repro.note":
+        "The committed JSONL transcripts carry per-turn <code>usage</code>, <code>cost</code>, and <code>prefixHash</code>. Reasonix's prefix hash stays byte-stable across every model call.",
+
+      "cli.title": "CLI at a glance",
+      "cli.code": "coding mode scoped to path",
+      "cli.chat": "chat (uses saved config)",
+      "cli.setup": "reconfigure the wizard",
+      "cli.run": "one-shot, streams to stdout",
+      "cli.stats": "cross-session cost dashboard",
+      "cli.mcp": "probe a single MCP server",
+      "cli.flags.intro": "Common flags:",
+      "cli.f.preset": "model + harvest + branch bundle",
+      "cli.f.model": "explicit DeepSeek model id",
+      "cli.f.mcp": "attach an MCP server (repeatable)",
+      "cli.f.session": "named session",
+      "cli.f.noconf": "ignore ~/.reasonix/config.json (CI)",
+
+      "ctab.title": "Ready to try?",
+      "ctab.sub": "One <code>npx</code> away. Sandboxed. Reviewable. 96% cheaper.",
+      "ctab.gh": "GitHub repository →",
+      "ctab.npm": "npm package",
+
+      "foot.tag": "DeepSeek does deep, deeply.",
+      "foot.col.project": "Project",
+      "foot.col.docs": "Docs",
+      "foot.col.community": "Community",
+      "foot.changelog": "Changelog",
+      "foot.readme": "README",
+      "foot.readme.zh": "中文 README",
+      "foot.arch": "Architecture",
+      "foot.issues": "Issues",
+      "foot.discuss": "Discussions",
+      "foot.copyright": "© 2026 Reasonix · MIT License",
+    },
+
+    zh: {
+      "nav.features": "特性",
+      "nav.quickstart": "快速上手",
+      "nav.benchmarks": "性能对比",
+      "nav.github": "GitHub",
+
+      "hero.badge": "v0.6 · DeepSeek V4 · 缓存优先",
+      "hero.title.line1": "DeepSeek 原生",
+      "hero.title.line2": "终端里的 AI 编程代理",
+      "hero.sub":
+        "为 DeepSeek V4（flash + pro）打造的缓存优先 agent 循环。编辑以可审查的 SEARCH/REPLACE 块呈现，落盘前必须确认。Ink TUI、原生支持 MCP，不依赖 LangChain。",
+      "hero.copy": "复制",
+      "hero.copy.done": "已复制",
+      "hero.cta.start": "开始使用 →",
+      "hero.cta.star": "在 GitHub 加星",
+      "hero.stat.cache": "前缀缓存命中率",
+      "hero.stat.cost": "相比 Claude Sonnet 4.6 节省",
+      "hero.stat.pass": "τ-bench-lite 通过率",
+
+      "term.user":
+        "users.ts 里 findByEmail 对大小写敏感导致登录失败，帮我改",
+      "term.found":
+        "▸ 找到了。findByEmail 直接用 === 比对。改成小写规范化并补一条测试。",
+      "term.pending": "▸ 1 处待应用编辑 · /apply 写入 · /discard 丢弃",
+
+      "why.title": "为什么选 Reasonix",
+      "why.sub":
+        "每个抽象都对应 DeepSeek 的一个具体特性——极低 token 价、R1 推理轨迹、自动前缀缓存、JSON 模式。通用框架把这些机会全留在桌上。",
+      "why.cache.title": "缓存优先的循环",
+      "why.cache.body":
+        "对话日志只追加不重写，前缀字节级稳定，DeepSeek 的自动前缀缓存命中能稳定打到 85–95%，而不是 40%。",
+      "why.cost.title": "成本是头等公民",
+      "why.cost.body":
+        "默认 flash 优先、turn 末尾自动压缩、必要时模型自我升级到 pro。TUI 有实时单轮成本徽章。",
+      "why.tui.title": "Ink TUI，不靠浏览器",
+      "why.tui.body":
+        "完全在终端里。流式预览、斜杠命令、计划审阅、编辑确认弹窗。Windows 顽固终端可启用 plain 模式。",
+      "why.mcp.title": "原生 MCP",
+      "why.mcp.body":
+        "stdio + HTTP+SSE 双传输。长任务有实时进度条。和原生工具一样走缓存安全 + 自动修复管线。",
+      "why.safe.title": "编辑可审阅",
+      "why.safe.body":
+        "编辑以 SEARCH/REPLACE 块呈现，/apply 之前不动磁盘。逐文件 diff 确认、撤销历史、路径沙箱。",
+      "why.ctx.title": "百万 token 感知",
+      "why.ctx.body":
+        "上下文仪表 + 主动压缩、超大工具结果自动修复、贴近上限自动总结兜底。",
+
+      "qs.title": "60 秒快速上手",
+      "qs.step1.title": "获取 DeepSeek API Key",
+      "qs.step1.body":
+        '在 <a href="https://platform.deepseek.com/api_keys" target="_blank" rel="noopener">platform.deepseek.com</a> 注册即送免费额度。',
+      "qs.step2.title": "切到项目目录运行",
+      "qs.step2.body": "无需安装。",
+      "qs.step2.note":
+        "首次运行会走 30 秒向导：粘贴 API key → 选预设 → 勾选 MCP 服务器。",
+      "qs.step3.title": "让它改代码",
+      "qs.step3.body":
+        "模型会以 SEARCH/REPLACE 块的形式提出编辑——你不 <code>/apply</code>，磁盘不会被改。",
+      "qs.req":
+        "需要 Node ≥ 20.10。支持 macOS、Linux、Windows（PowerShell · Git Bash · Windows Terminal）。任何时候按 <kbd>Esc</kbd> 中断；<code>/help</code> 查看完整命令。",
+
+      "feat.title": "开箱即用",
+      "feat.code.title": "结对编程模式",
+      "feat.code.body":
+        "<code>read_file</code> · <code>write_file</code> · <code>edit_file</code> · <code>search_files</code> · <code>directory_tree</code> · 带只读白名单的 <code>run_command</code>。沙箱限定在启动目录——路径逃逸一律拒绝。支持 plan 模式与逐次编辑确认弹窗。",
+      "feat.memory.title": "两层记忆系统",
+      "feat.memory.body":
+        "可提交的 <code>REASONIX.md</code> 承载团队约定，私人 <code>~/.reasonix/memory/</code> 分全局与按项目两个作用域。模型可通过 <code>remember</code> 工具自行写入。",
+      "feat.skills.title": "用户定义的 prompt 包",
+      "feat.skills.body":
+        "把 <code>SKILL.md</code> 丢进任意位置。名字 + 描述会被钉在前缀里，模型可自动调用，或你用 <code>/skill name</code> 手动触发。",
+      "feat.hooks.title": "生命周期钩子",
+      "feat.hooks.body":
+        "在 <code>PreToolUse</code> · <code>PostToolUse</code> · <code>UserPromptSubmit</code> · <code>Stop</code> 四个点触发 shell 命令，退出码决定放行 / 阻断 / 警告。",
+      "feat.mcp.title": "自带工具进来",
+      "feat.mcp.body":
+        '向导内置目录，或用 <code>--mcp "name=cmd"</code> 直接挂 stdio / HTTP+SSE 服务器。长任务渲染实时进度条。',
+      "feat.web.title": "内置联网搜索",
+      "feat.web.body":
+        "<code>web_search</code> + <code>web_fetch</code>，背靠 Mojeek——无需 key、无需注册，离线 / CI 可关闭。可通过 <code>WebSearchProvider</code> 接口接入自家搜索。",
+
+      "bench.title": "缓存命中率自己也能验证",
+      "bench.sub":
+        "同一 τ-bench-lite 负载（8 个多轮工具调用任务 × 3 次重复 = 每边 48 次运行），实测 DeepSeek <code>deepseek-chat</code>，唯一变量是前缀稳定性：",
+      "bench.col.metric": "指标",
+      "bench.col.baseline": "基线（缓存敌对）",
+      "bench.col.reasonix": "Reasonix",
+      "bench.col.delta": "差值",
+      "bench.row.cache": "缓存命中",
+      "bench.row.cost": "单任务成本",
+      "bench.row.pass": "通过率",
+      "bench.repro.intro": "无需消耗 API 额度即可复现：",
+      "bench.repro.note":
+        "提交进仓库的 JSONL 文件每轮带 <code>usage</code>、<code>cost</code>、<code>prefixHash</code>。Reasonix 的前缀哈希在每次模型调用时都字节稳定。",
+
+      "cli.title": "CLI 速览",
+      "cli.code": "针对指定路径的编程模式",
+      "cli.chat": "聊天模式（读取已保存配置）",
+      "cli.setup": "重新跑配置向导",
+      "cli.run": "一次性运行，结果流到 stdout",
+      "cli.stats": "跨会话的成本仪表盘",
+      "cli.mcp": "探测单个 MCP 服务器",
+      "cli.flags.intro": "常用 flag：",
+      "cli.f.preset": "模型 + harvest + 分支并行 一键组合",
+      "cli.f.model": "显式指定 DeepSeek 模型 ID",
+      "cli.f.mcp": "挂载 MCP 服务器（可重复）",
+      "cli.f.session": "命名会话",
+      "cli.f.noconf": "忽略 ~/.reasonix/config.json（CI 友好）",
+
+      "ctab.title": "准备好了吗？",
+      "ctab.sub": "一条 <code>npx</code> 即可开始。沙箱、可审阅、便宜 96%。",
+      "ctab.gh": "GitHub 仓库 →",
+      "ctab.npm": "npm 包",
+
+      "foot.tag": "Reasonix 只做 DeepSeek，做到底。",
+      "foot.col.project": "项目",
+      "foot.col.docs": "文档",
+      "foot.col.community": "社区",
+      "foot.changelog": "更新日志",
+      "foot.readme": "英文 README",
+      "foot.readme.zh": "中文 README",
+      "foot.arch": "架构文档",
+      "foot.issues": "问题反馈",
+      "foot.discuss": "讨论区",
+      "foot.copyright": "© 2026 Reasonix · MIT 协议",
+    },
+  };
+
+  function safeStorageGet(key) {
+    try {
+      return window.localStorage.getItem(key);
+    } catch (_) {
+      return null;
+    }
+  }
+
+  function safeStorageSet(key, value) {
+    try {
+      window.localStorage.setItem(key, value);
+    } catch (_) {
+      /* ignore */
+    }
+  }
+
+  function detectLang() {
+    const params = new URLSearchParams(window.location.search);
+    const queryLang = params.get("lang");
+    if (queryLang && SUPPORTED.includes(queryLang)) return queryLang;
+
+    const stored = safeStorageGet(STORAGE_KEY);
+    if (stored && SUPPORTED.includes(stored)) return stored;
+
+    const navLang = (navigator.language || navigator.userLanguage || "").toLowerCase();
+    if (navLang.startsWith("zh")) return "zh";
+
+    if (Array.isArray(navigator.languages)) {
+      for (const l of navigator.languages) {
+        if (l && l.toLowerCase().startsWith("zh")) return "zh";
+      }
+    }
+
+    return DEFAULT_LANG;
+  }
+
+  let currentLang = DEFAULT_LANG;
+  const langListeners = [];
+
+  function applyLang(lang) {
+    if (!SUPPORTED.includes(lang)) lang = DEFAULT_LANG;
+    const changed = lang !== currentLang;
+    currentLang = lang;
+    const dict = translations[lang];
+
+    document.documentElement.lang = lang === "zh" ? "zh-CN" : "en";
+    document.documentElement.setAttribute("data-lang", lang);
+
+    document.querySelectorAll("[data-i18n]").forEach((el) => {
+      const key = el.getAttribute("data-i18n");
+      if (dict[key] !== undefined) {
+        el.innerHTML = dict[key];
+      }
+    });
+
+    document.querySelectorAll("[data-lang-btn]").forEach((btn) => {
+      const isActive = btn.getAttribute("data-lang-btn") === lang;
+      btn.setAttribute("aria-pressed", isActive ? "true" : "false");
+    });
+
+    safeStorageSet(STORAGE_KEY, lang);
+
+    if (changed) {
+      for (const fn of langListeners) {
+        try {
+          fn(lang);
+        } catch (_) {
+          /* ignore */
+        }
+      }
+    }
+  }
+
+  // Public API for sibling scripts (term-anim.js).
+  window.Reasonix = window.Reasonix || {};
+  window.Reasonix.t = function (key) {
+    const dict = translations[currentLang] || translations[DEFAULT_LANG];
+    return dict[key];
+  };
+  window.Reasonix.lang = function () {
+    return currentLang;
+  };
+  window.Reasonix.onLangChange = function (fn) {
+    if (typeof fn === "function") langListeners.push(fn);
+  };
+
+  function wireLangButtons() {
+    document.querySelectorAll("[data-lang-btn]").forEach((btn) => {
+      btn.addEventListener("click", () => {
+        applyLang(btn.getAttribute("data-lang-btn"));
+      });
+    });
+  }
+
+  function wireCopyButtons() {
+    document.querySelectorAll("[data-copy]").forEach((btn) => {
+      btn.addEventListener("click", async () => {
+        const text = btn.getAttribute("data-copy");
+        try {
+          await navigator.clipboard.writeText(text);
+        } catch (_) {
+          const ta = document.createElement("textarea");
+          ta.value = text;
+          ta.style.position = "fixed";
+          ta.style.opacity = "0";
+          document.body.appendChild(ta);
+          ta.select();
+          try {
+            document.execCommand("copy");
+          } catch (_) {
+            /* ignore */
+          }
+          document.body.removeChild(ta);
+        }
+        const lang = document.documentElement.getAttribute("data-lang") || DEFAULT_LANG;
+        const original = translations[lang]["hero.copy"] || "Copy";
+        const done = translations[lang]["hero.copy.done"] || "Copied";
+        btn.textContent = done;
+        btn.classList.add("copied");
+        setTimeout(() => {
+          btn.textContent = original;
+          btn.classList.remove("copied");
+        }, 1600);
+      });
+    });
+  }
+
+  function init() {
+    applyLang(detectLang());
+    wireLangButtons();
+    wireCopyButtons();
+  }
+
+  if (document.readyState === "loading") {
+    document.addEventListener("DOMContentLoaded", init);
+  } else {
+    init();
+  }
+})();

docs/index.html

@@ -0,0 +1,493 @@
+<!doctype html>
+<html lang="en" data-lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>Reasonix — DeepSeek-native AI coding agent</title>
+    <meta
+      name="description"
+      content="Cache-first agent loop for DeepSeek V4. Ink TUI. MCP first-class. 94%+ prefix cache hit, ~96% cheaper than Claude on the same workload. No LangChain."
+    />
+    <meta name="theme-color" content="#0b0f17" />
+
+    <meta property="og:title" content="Reasonix — DeepSeek-native AI coding agent" />
+    <meta
+      property="og:description"
+      content="Cache-first agent loop for DeepSeek V4 (flash + pro). Ink TUI. MCP first-class. No LangChain."
+    />
+    <meta property="og:type" content="website" />
+    <meta property="og:url" content="https://esengine.github.io/reasonix/" />
+    <meta property="og:image" content="https://raw.githubusercontent.com/esengine/reasonix/main/docs/logo.svg" />
+    <meta name="twitter:card" content="summary_large_image" />
+
+    <link rel="icon" type="image/svg+xml" href="favicon.svg" />
+    <link rel="preconnect" href="https://fonts.googleapis.com" />
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+    <link
+      href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700;800&family=JetBrains+Mono:wght@400;500;600;700&family=Noto+Sans+SC:wght@400;500;600;700;800&display=swap"
+      rel="stylesheet"
+    />
+    <link rel="stylesheet" href="styles.css" />
+  </head>
+
+  <body>
+    <div class="bg-grid" aria-hidden="true"></div>
+    <div class="bg-glow" aria-hidden="true"></div>
+
+    <header class="nav">
+      <a class="nav-brand" href="#top" aria-label="Reasonix">
+        <span class="brand-mark" aria-hidden="true">
+          <span class="diamond"></span>
+          <span class="diamond inner"></span>
+        </span>
+        <span class="brand-name">Reasonix</span>
+      </a>
+
+      <nav class="nav-links">
+        <a href="#features" data-i18n="nav.features">Features</a>
+        <a href="#quickstart" data-i18n="nav.quickstart">Quick start</a>
+        <a href="#benchmarks" data-i18n="nav.benchmarks">Benchmarks</a>
+        <a
+          href="https://github.com/esengine/reasonix"
+          target="_blank"
+          rel="noopener"
+          data-i18n="nav.github"
+          >GitHub</a
+        >
+      </nav>
+
+      <div class="nav-actions">
+        <div class="lang-switch" role="group" aria-label="Language">
+          <button data-lang-btn="en" type="button" aria-pressed="true">EN</button>
+          <button data-lang-btn="zh" type="button" aria-pressed="false">中文</button>
+        </div>
+      </div>
+    </header>
+
+    <main id="top">
+      <section class="hero">
+        <div class="hero-inner">
+          <div class="badge" data-i18n="hero.badge">v0.6 · DeepSeek V4 · cache-first</div>
+          <h1 class="hero-title">
+            <span class="grad-text" data-i18n="hero.title.line1">DeepSeek-native</span>
+            <br />
+            <span data-i18n="hero.title.line2">AI coding agent in your terminal</span>
+          </h1>
+          <p class="hero-sub" data-i18n="hero.sub">
+            Cache-first agent loop for DeepSeek V4 (flash + pro). Edits files as
+            reviewable SEARCH/REPLACE blocks. Ink TUI. MCP first-class. No LangChain.
+          </p>
+
+          <div class="hero-install">
+            <code class="install-cmd"
+              ><span class="prompt">$</span> <span class="cmd">npx reasonix code</span></code
+            >
+            <button class="copy-btn" data-copy="npx reasonix code" data-i18n="hero.copy">
+              Copy
+            </button>
+          </div>
+
+          <div class="hero-ctas">
+            <a class="cta primary" href="#quickstart" data-i18n="hero.cta.start">
+              Get started →
+            </a>
+            <a
+              class="cta ghost"
+              href="https://github.com/esengine/reasonix"
+              target="_blank"
+              rel="noopener"
+              data-i18n="hero.cta.star"
+              >Star on GitHub</a
+            >
+          </div>
+
+          <div class="hero-stats">
+            <div class="stat">
+              <div class="stat-num grad-text">94.4%</div>
+              <div class="stat-label" data-i18n="hero.stat.cache">prefix cache hit rate</div>
+            </div>
+            <div class="stat">
+              <div class="stat-num grad-text">~96%</div>
+              <div class="stat-label" data-i18n="hero.stat.cost">cheaper vs Claude Sonnet 4.6</div>
+            </div>
+            <div class="stat">
+              <div class="stat-num grad-text">100%</div>
+              <div class="stat-label" data-i18n="hero.stat.pass">τ-bench-lite pass rate</div>
+            </div>
+          </div>
+        </div>
+
+        <div class="hero-terminal" aria-hidden="true">
+          <div class="term-bar">
+            <span class="dot r"></span><span class="dot y"></span><span class="dot g"></span>
+            <span class="term-title">reasonix code</span>
+            <button class="term-replay" type="button" data-replay aria-label="replay">↻</button>
+          </div>
+          <div class="term-body" id="term-body" data-anim-root></div>
+        </div>
+      </section>
+
+      <section class="why">
+        <div class="container">
+          <h2 class="section-title" data-i18n="why.title">Why Reasonix</h2>
+          <p class="section-sub" data-i18n="why.sub">
+            Every abstraction earns its weight against a DeepSeek-specific property —
+            dirt-cheap tokens, R1 traces, automatic prefix caching, JSON mode. Generic
+            wrappers leave these on the table.
+          </p>
+
+          <div class="why-grid">
+            <article class="why-card">
+              <div class="why-icon">◈</div>
+              <h3 data-i18n="why.cache.title">Cache-first loop</h3>
+              <p data-i18n="why.cache.body">
+                Append-only conversation log keeps the prompt prefix byte-stable across
+                turns, so DeepSeek's automatic cache hits 85–95% — not 40%.
+              </p>
+            </article>
+            <article class="why-card">
+              <div class="why-icon">¥</div>
+              <h3 data-i18n="why.cost.title">Cost is a pillar</h3>
+              <p data-i18n="why.cost.body">
+                Flash-first defaults, turn-end auto-compaction, model self-escalation
+                when (and only when) needed. Per-turn cost badge in the TUI.
+              </p>
+            </article>
+            <article class="why-card">
+              <div class="why-icon">⌨</div>
+              <h3 data-i18n="why.tui.title">Ink TUI, no web</h3>
+              <p data-i18n="why.tui.body">
+                Lives in your terminal. Streaming preview, slash commands, plan picker,
+                edit-confirm modal. Plain mode for stubborn Windows shells.
+              </p>
+            </article>
+            <article class="why-card">
+              <div class="why-icon">⊕</div>
+              <h3 data-i18n="why.mcp.title">MCP first-class</h3>
+              <p data-i18n="why.mcp.body">
+                Stdio + HTTP+SSE transports. Live progress notifications. Same
+                cache-safety + repair plumbing as native tools.
+              </p>
+            </article>
+            <article class="why-card">
+              <div class="why-icon">↶</div>
+              <h3 data-i18n="why.safe.title">Reviewable edits</h3>
+              <p data-i18n="why.safe.body">
+                Edits arrive as SEARCH/REPLACE blocks; nothing hits disk until /apply.
+                Per-file diff confirm modal, undo history, sandboxed paths.
+              </p>
+            </article>
+            <article class="why-card">
+              <div class="why-icon">∞</div>
+              <h3 data-i18n="why.ctx.title">1M-token aware</h3>
+              <p data-i18n="why.ctx.body">
+                Context gauge with proactive compaction, oversized tool-result repair,
+                forced-summary fallback near the window edge.
+              </p>
+            </article>
+          </div>
+        </div>
+      </section>
+
+      <section id="quickstart" class="quickstart">
+        <div class="container">
+          <h2 class="section-title" data-i18n="qs.title">Quick start (60 seconds)</h2>
+          <ol class="qs-steps">
+            <li>
+              <h3 data-i18n="qs.step1.title">Get a DeepSeek API key</h3>
+              <p data-i18n="qs.step1.body">
+                Free credit on signup at
+                <a href="https://platform.deepseek.com/api_keys" target="_blank" rel="noopener"
+                  >platform.deepseek.com</a
+                >.
+              </p>
+            </li>
+            <li>
+              <h3 data-i18n="qs.step2.title">Point it at a project</h3>
+              <p data-i18n="qs.step2.body">No install needed.</p>
+              <pre class="code"><code>cd my-project
+npx reasonix code</code></pre>
+              <p data-i18n="qs.step2.note">
+                First run walks you through a 30-second wizard (paste API key → pick
+                preset → pick MCP servers).
+              </p>
+            </li>
+            <li>
+              <h3 data-i18n="qs.step3.title">Ask it to edit</h3>
+              <p data-i18n="qs.step3.body">
+                The model proposes edits as SEARCH/REPLACE blocks — nothing hits disk
+                until you <code>/apply</code>.
+              </p>
+            </li>
+          </ol>
+
+          <p class="req" data-i18n="qs.req">
+            Requires Node ≥ 20.10. macOS, Linux, Windows (PowerShell · Git Bash · Windows
+            Terminal). Press <kbd>Esc</kbd> anytime to abort; <code>/help</code> for the
+            full command list.
+          </p>
+        </div>
+      </section>
+
+      <section id="features" class="features">
+        <div class="container">
+          <h2 class="section-title" data-i18n="feat.title">In the box</h2>
+
+          <div class="feat-grid">
+            <article class="feat">
+              <h3>
+                <span class="feat-tag">code</span>
+                <span data-i18n="feat.code.title">Pair programmer mode</span>
+              </h3>
+              <p data-i18n="feat.code.body">
+                <code>read_file</code> · <code>write_file</code> · <code>edit_file</code> ·
+                <code>search_files</code> · <code>directory_tree</code> ·
+                <code>run_command</code> with read-only allowlist. Sandboxed to the
+                launch root — no path escapes. Plan mode and per-edit review modal.
+              </p>
+            </article>
+            <article class="feat">
+              <h3>
+                <span class="feat-tag">memory</span>
+                <span data-i18n="feat.memory.title">Two-layer memory</span>
+              </h3>
+              <p data-i18n="feat.memory.body">
+                Committable <code>REASONIX.md</code> for team conventions plus a private
+                per-user <code>~/.reasonix/memory/</code> with global and per-project
+                scopes. The model can write to it via the <code>remember</code> tool.
+              </p>
+            </article>
+            <article class="feat">
+              <h3>
+                <span class="feat-tag">skills</span>
+                <span data-i18n="feat.skills.title">User-authored prompt packs</span>
+              </h3>
+              <p data-i18n="feat.skills.body">
+                Drop <code>SKILL.md</code> files anywhere. Names + descriptions are
+                pinned in the prefix; the model picks them autonomously, or you trigger
+                with <code>/skill name</code>.
+              </p>
+            </article>
+            <article class="feat">
+              <h3>
+                <span class="feat-tag">hooks</span>
+                <span data-i18n="feat.hooks.title">Lifecycle hooks</span>
+              </h3>
+              <p data-i18n="feat.hooks.body">
+                Shell commands fire at <code>PreToolUse</code> · <code>PostToolUse</code>
+                · <code>UserPromptSubmit</code> · <code>Stop</code>. Exit code drives
+                pass / block / warn.
+              </p>
+            </article>
+            <article class="feat">
+              <h3>
+                <span class="feat-tag">mcp</span>
+                <span data-i18n="feat.mcp.title">Bring your own tools</span>
+              </h3>
+              <p data-i18n="feat.mcp.body">
+                Wizard catalog, or <code>--mcp "name=cmd"</code> to attach stdio /
+                HTTP+SSE servers on the fly. Live progress bars on long calls.
+              </p>
+            </article>
+            <article class="feat">
+              <h3>
+                <span class="feat-tag">web</span>
+                <span data-i18n="feat.web.title">Web search built-in</span>
+              </h3>
+              <p data-i18n="feat.web.body">
+                <code>web_search</code> + <code>web_fetch</code> via Mojeek — no key, no
+                signup, off-by-flag for offline / CI. Bring-your-own provider via the
+                <code>WebSearchProvider</code> interface.
+              </p>
+            </article>
+          </div>
+        </div>
+      </section>
+
+      <section id="benchmarks" class="bench">
+        <div class="container">
+          <h2 class="section-title" data-i18n="bench.title">Verify the cache claim yourself</h2>
+          <p class="section-sub" data-i18n="bench.sub">
+            On the same τ-bench-lite workload (8 multi-turn tool-use tasks × 3 repeats =
+            48 runs per side), live DeepSeek <code>deepseek-chat</code>, sole variable
+            prefix stability:
+          </p>
+
+          <div class="bench-table-wrap">
+            <table class="bench-table">
+              <thead>
+                <tr>
+                  <th data-i18n="bench.col.metric">metric</th>
+                  <th data-i18n="bench.col.baseline">baseline (cache-hostile)</th>
+                  <th data-i18n="bench.col.reasonix">Reasonix</th>
+                  <th data-i18n="bench.col.delta">delta</th>
+                </tr>
+              </thead>
+              <tbody>
+                <tr>
+                  <td data-i18n="bench.row.cache">cache hit</td>
+                  <td>46.6%</td>
+                  <td class="hi">94.4%</td>
+                  <td>+47.7 pp</td>
+                </tr>
+                <tr>
+                  <td data-i18n="bench.row.cost">cost / task</td>
+                  <td>$0.002599</td>
+                  <td class="hi">$0.001579</td>
+                  <td><strong>−39%</strong></td>
+                </tr>
+                <tr>
+                  <td data-i18n="bench.row.pass">pass rate</td>
+                  <td>96% (23/24)</td>
+                  <td class="hi">100% (24/24)</td>
+                  <td>—</td>
+                </tr>
+              </tbody>
+            </table>
+          </div>
+
+          <p data-i18n="bench.repro.intro">Reproduce without spending an API credit:</p>
+          <pre class="code"><code>git clone https://github.com/esengine/reasonix.git &amp;&amp; cd reasonix &amp;&amp; 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</code></pre>
+
+          <p data-i18n="bench.repro.note">
+            The committed JSONL transcripts carry per-turn <code>usage</code>,
+            <code>cost</code>, and <code>prefixHash</code>. Reasonix's prefix hash stays
+            byte-stable across every model call.
+          </p>
+        </div>
+      </section>
+
+      <section class="cli">
+        <div class="container">
+          <h2 class="section-title" data-i18n="cli.title">CLI at a glance</h2>
+          <pre class="code"><code>npx reasonix code [path]                 <span class="hash"># <span data-i18n="cli.code">coding mode scoped to path</span></span>
+npx reasonix                             <span class="hash"># <span data-i18n="cli.chat">chat (uses saved config)</span></span>
+npx reasonix setup                       <span class="hash"># <span data-i18n="cli.setup">reconfigure the wizard</span></span>
+npx reasonix run "ask anything"          <span class="hash"># <span data-i18n="cli.run">one-shot, streams to stdout</span></span>
+npx reasonix stats                       <span class="hash"># <span data-i18n="cli.stats">cross-session cost dashboard</span></span>
+npx reasonix mcp inspect &lt;spec&gt;          <span class="hash"># <span data-i18n="cli.mcp">probe a single MCP server</span></span></code></pre>
+
+          <p class="cli-flags" data-i18n="cli.flags.intro">Common flags:</p>
+          <pre class="code"><code>--preset &lt;fast|smart|max&gt;   <span class="hash"># <span data-i18n="cli.f.preset">model + harvest + branch bundle</span></span>
+--model &lt;id&gt;                <span class="hash"># <span data-i18n="cli.f.model">explicit DeepSeek model id</span></span>
+--mcp "name=cmd args…"      <span class="hash"># <span data-i18n="cli.f.mcp">attach an MCP server (repeatable)</span></span>
+--session &lt;name&gt;            <span class="hash"># <span data-i18n="cli.f.session">named session</span></span>
+--no-config                 <span class="hash"># <span data-i18n="cli.f.noconf">ignore ~/.reasonix/config.json (CI)</span></span></code></pre>
+        </div>
+      </section>
+
+      <section class="cta-band">
+        <div class="container">
+          <h2 data-i18n="ctab.title">Ready to try?</h2>
+          <p data-i18n="ctab.sub">
+            One <code>npx</code> away. Sandboxed. Reviewable. 96% cheaper.
+          </p>
+          <div class="hero-ctas center">
+            <a
+              class="cta primary"
+              href="https://github.com/esengine/reasonix"
+              target="_blank"
+              rel="noopener"
+              data-i18n="ctab.gh"
+              >GitHub repository →</a
+            >
+            <a
+              class="cta ghost"
+              href="https://www.npmjs.com/package/reasonix"
+              target="_blank"
+              rel="noopener"
+              data-i18n="ctab.npm"
+              >npm package</a
+            >
+          </div>
+        </div>
+      </section>
+    </main>
+
+    <footer class="foot">
+      <div class="container foot-inner">
+        <div>
+          <a href="#top" class="nav-brand">
+            <span class="brand-mark small" aria-hidden="true">
+              <span class="diamond"></span>
+              <span class="diamond inner"></span>
+            </span>
+            <span class="brand-name">Reasonix</span>
+          </a>
+          <p class="foot-tag" data-i18n="foot.tag">DeepSeek does deep, deeply.</p>
+        </div>
+        <div class="foot-cols">
+          <div>
+            <h4 data-i18n="foot.col.project">Project</h4>
+            <a href="https://github.com/esengine/reasonix" target="_blank" rel="noopener">GitHub</a>
+            <a href="https://www.npmjs.com/package/reasonix" target="_blank" rel="noopener">npm</a>
+            <a
+              href="https://github.com/esengine/reasonix/blob/main/CHANGELOG.md"
+              target="_blank"
+              rel="noopener"
+              data-i18n="foot.changelog"
+              >Changelog</a
+            >
+            <a
+              href="https://github.com/esengine/reasonix/blob/main/LICENSE"
+              target="_blank"
+              rel="noopener"
+              >MIT</a
+            >
+          </div>
+          <div>
+            <h4 data-i18n="foot.col.docs">Docs</h4>
+            <a
+              href="https://github.com/esengine/reasonix#readme"
+              target="_blank"
+              rel="noopener"
+              data-i18n="foot.readme"
+              >README</a
+            >
+            <a
+              href="https://github.com/esengine/reasonix/blob/main/README.zh-CN.md"
+              target="_blank"
+              rel="noopener"
+              data-i18n="foot.readme.zh"
+              >中文 README</a
+            >
+            <a
+              href="https://github.com/esengine/reasonix/blob/main/docs/ARCHITECTURE.md"
+              target="_blank"
+              rel="noopener"
+              data-i18n="foot.arch"
+              >Architecture</a
+            >
+          </div>
+          <div>
+            <h4 data-i18n="foot.col.community">Community</h4>
+            <a
+              href="https://github.com/esengine/reasonix/issues"
+              target="_blank"
+              rel="noopener"
+              data-i18n="foot.issues"
+              >Issues</a
+            >
+            <a
+              href="https://github.com/esengine/reasonix/discussions"
+              target="_blank"
+              rel="noopener"
+              data-i18n="foot.discuss"
+              >Discussions</a
+            >
+          </div>
+        </div>
+      </div>
+      <div class="foot-bottom">
+        <span data-i18n="foot.copyright">© 2026 Reasonix · MIT License</span>
+      </div>
+    </footer>
+
+    <script src="i18n.js"></script>
+    <script src="term-anim.js"></script>
+  </body>
+</html>

docs/logo.svg

@@ -0,0 +1,95 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="760" height="170" viewBox="0 0 760 170" role="img" aria-label="Reasonix — DeepSeek-native agent framework">
+  <title>Reasonix</title>
+  <defs>
+    <!-- Signature cyan → violet → fuchsia gradient used across the TUI wordmark
+         and the brand mark. Renders well on both GitHub dark and light bg. -->
+    <linearGradient id="rx-grad" x1="0%" y1="0%" x2="100%" y2="0%">
+      <stop offset="0%" stop-color="#5eead4"/>
+      <stop offset="15%" stop-color="#67e8f9"/>
+      <stop offset="30%" stop-color="#7dd3fc"/>
+      <stop offset="45%" stop-color="#93c5fd"/>
+      <stop offset="60%" stop-color="#a5b4fc"/>
+      <stop offset="75%" stop-color="#c4b5fd"/>
+      <stop offset="90%" stop-color="#d8b4fe"/>
+      <stop offset="100%" stop-color="#f0abfc"/>
+    </linearGradient>
+    <linearGradient id="rx-grad-mark" x1="0%" y1="0%" x2="100%" y2="100%">
+      <stop offset="0%" stop-color="#5eead4"/>
+      <stop offset="50%" stop-color="#93c5fd"/>
+      <stop offset="100%" stop-color="#c4b5fd"/>
+    </linearGradient>
+    <filter id="glow" x="-50%" y="-50%" width="200%" height="200%">
+      <feGaussianBlur stdDeviation="3" result="blur"/>
+      <feMerge>
+        <feMergeNode in="blur"/>
+        <feMergeNode in="SourceGraphic"/>
+      </feMerge>
+    </filter>
+  </defs>
+
+  <!-- ◈ brand mark: concentric diamonds. Outer stroke pulses,
+       inner fill breathes, whole group rotates slowly. The rotation
+       is subtle (12s / full turn) so it feels like a heartbeat, not a
+       spinner. -->
+  <g transform="translate(90, 85)" filter="url(#glow)">
+    <g>
+      <animateTransform attributeName="transform" type="rotate"
+                        from="0" to="360" dur="18s" repeatCount="indefinite"/>
+      <!-- Outer hollow diamond -->
+      <path d="M 0,-46 L 46,0 L 0,46 L -46,0 Z"
+            fill="none"
+            stroke="url(#rx-grad-mark)"
+            stroke-width="3.5"
+            stroke-linejoin="round">
+        <animate attributeName="stroke-width"
+                 values="3.5;5.5;3.5"
+                 dur="2.4s"
+                 repeatCount="indefinite"/>
+      </path>
+      <!-- Middle hollow diamond -->
+      <path d="M 0,-26 L 26,0 L 0,26 L -26,0 Z"
+            fill="none"
+            stroke="url(#rx-grad-mark)"
+            stroke-width="2"
+            stroke-linejoin="round"
+            opacity="0.7">
+        <animate attributeName="opacity"
+                 values="0.4;0.9;0.4"
+                 dur="2.4s"
+                 begin="0.8s"
+                 repeatCount="indefinite"/>
+      </path>
+      <!-- Inner solid diamond -->
+      <path d="M 0,-11 L 11,0 L 0,11 L -11,0 Z"
+            fill="url(#rx-grad-mark)">
+        <animate attributeName="opacity"
+                 values="0.75;1;0.75"
+                 dur="2.4s"
+                 repeatCount="indefinite"/>
+      </path>
+    </g>
+  </g>
+
+  <!-- REASONIX wordmark with shifting gradient. The x1 offset animates
+       so the gradient crawls left-to-right across the letters — a
+       slow rainbow sweep that gives the logo life without being noisy. -->
+  <text x="170" y="102"
+        font-family="ui-monospace, SFMono-Regular, 'Cascadia Code', Menlo, Consolas, 'DejaVu Sans Mono', monospace"
+        font-size="68"
+        font-weight="800"
+        fill="url(#rx-grad)"
+        letter-spacing="6">REASONIX
+    <animate attributeName="opacity"
+             values="0.9;1;0.9"
+             dur="3.2s"
+             repeatCount="indefinite"/>
+  </text>
+
+  <!-- Tagline sits just below the wordmark. Slate-500 reads well on
+       both GitHub dark and light themes (~4.5:1 contrast either way). -->
+  <text x="172" y="136"
+        font-family="ui-monospace, SFMono-Regular, 'Cascadia Code', Menlo, Consolas, 'DejaVu Sans Mono', monospace"
+        font-size="15"
+        fill="#64748b"
+        letter-spacing="0.5">DeepSeek-native agent framework  ·  cache-first loop  ·  Ink TUI</text>
+</svg>

docs/term-anim.js

@@ -0,0 +1,404 @@
+// Hero terminal animation — simulates a `reasonix code` session using
+// the real TUI rendering primitives:
+//   ◇ / ◆ role glyphs + colored vertical accent bars
+//   ` ✓ tool_name ` pills (yellow bg, black text)
+//   EditBlockRow: rounded cyan border, filename, `- old` red / `+ new` green
+//   info rows: dim glyph + dim body (slate)
+//
+// Reads i18n strings via Reasonix.t(); restarts on language toggle.
+
+(function () {
+  "use strict";
+
+  const ROOT_SEL = "[data-anim-root]";
+  const REPLAY_SEL = "[data-replay]";
+
+  const tr = (key, fallback) => {
+    if (window.Reasonix && typeof window.Reasonix.t === "function") {
+      const v = window.Reasonix.t(key);
+      if (v !== undefined && v !== null && v !== "") return v;
+    }
+    return fallback != null ? fallback : key;
+  };
+
+  const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+  function el(tag, cls, text) {
+    const n = document.createElement(tag);
+    if (cls) n.className = cls;
+    if (text != null) n.textContent = text;
+    return n;
+  }
+
+  // Brand gradient — same stops as src/cli/ui/theme.ts GRADIENT.
+  const GRADIENT = [
+    "#5eead4",
+    "#67e8f9",
+    "#7dd3fc",
+    "#93c5fd",
+    "#a5b4fc",
+    "#c4b5fd",
+    "#d8b4fe",
+    "#f0abfc",
+  ];
+
+  // ──────────────────────────────────────────────────────────────────
+  // Header bar — `◈ REASONIX v0.6.0  v4-flash  REVIEW  max  …  turn 1 · /help`
+  // ──────────────────────────────────────────────────────────────────
+  function buildHeader(turn) {
+    const h = el("div", "thead");
+    h.innerHTML =
+      '<span class="tw-mark">◈</span>' +
+      '<span class="tw-name">REASONIX</span>' +
+      '<span class="tw-ver">v0.6.0</span>' +
+      '<span class="tw-model">v4-flash</span>' +
+      '<span class="tw-pill review">REVIEW</span>' +
+      '<span class="tw-effort">max</span>' +
+      '<span class="tw-spacer"></span>' +
+      '<span class="tw-turn">turn ' +
+      turn +
+      " · /help</span>";
+    return h;
+  }
+
+  // ──────────────────────────────────────────────────────────────────
+  // User row — ◇ glyph (cyan) + cyan vertical accent bar + text.
+  // Mirrors EventLog.tsx role="user" render.
+  // ──────────────────────────────────────────────────────────────────
+  function buildUserRow(text) {
+    const row = el("div", "trow trow-user");
+    row.innerHTML =
+      '<span class="trole role-user">◇</span>' +
+      '<span class="tbar-cyan">▎</span>' +
+      '<span class="trow-body"></span>';
+    row.querySelector(".trow-body").textContent = text;
+    return row;
+  }
+
+  // Same shape as a user row but the body content is built progressively
+  // by the animation. Returns the row + an `input` ref + a `caret` span.
+  function buildLiveUserRow() {
+    const row = el("div", "trow trow-user trow-live");
+    row.innerHTML =
+      '<span class="trole role-user">◇</span>' +
+      '<span class="tbar-cyan">▎</span>' +
+      '<span class="trow-body"><span class="tinput"></span><span class="tcaret">▍</span></span>';
+    row._input = row.querySelector(".tinput");
+    row._caret = row.querySelector(".tcaret");
+    return row;
+  }
+
+  // ──────────────────────────────────────────────────────────────────
+  // Tool pill row — ` ✓ tool_name `  duration  dim summary  /tool N
+  // Yellow bg pill (red bg for errors). Mirrors ToolPill in EventLog.tsx.
+  // ──────────────────────────────────────────────────────────────────
+  function buildToolRow(name, summary, durationLabel, indexHint) {
+    const row = el("div", "trow trow-tool");
+    const pill = el("span", "tpill tpill-ok");
+    pill.textContent = " ✓ " + name + " ";
+    row.appendChild(pill);
+    if (durationLabel) {
+      row.appendChild(el("span", "tdim", "  " + durationLabel));
+    }
+    row.appendChild(el("span", "tdim", "  " + summary));
+    if (indexHint) {
+      row.appendChild(el("span", "tdim tindex", "  /tool " + indexHint));
+    }
+    return row;
+  }
+
+  // ──────────────────────────────────────────────────────────────────
+  // Assistant row — ◆ glyph + ` v4-flash ` pill, then a green-bordered
+  // body the caller fills with text + (optionally) an EditBlockRow.
+  // Returns { row, body } so the caller can append into body.
+  // ──────────────────────────────────────────────────────────────────
+  function buildAssistantRow() {
+    const row = el("div", "trow trow-asst");
+    row.innerHTML =
+      '<div class="trow-asst-head">' +
+      '<span class="trole role-asst">◆</span>' +
+      '<span class="tpill tpill-model"> v4-flash </span>' +
+      "</div>" +
+      '<div class="trow-asst-body">' +
+      '<span class="tbar-green">▎</span>' +
+      '<div class="trow-asst-content"></div>' +
+      "</div>";
+    return { row, body: row.querySelector(".trow-asst-content") };
+  }
+
+  // ──────────────────────────────────────────────────────────────────
+  // EditBlockRow — rounded cyan border, filename in cyan bold, then
+  // `- old` red and `+ new` green lines. NO literal SEARCH/REPLACE
+  // markers (the model's text format is parsed; only the diff is
+  // shown). Mirrors EditBlockRow in markdown.tsx.
+  // ──────────────────────────────────────────────────────────────────
+  function buildEditBlock(filename, oldLines, newLines) {
+    const box = el("div", "tedit");
+    const head = el("div", "tedit-head");
+    head.appendChild(el("span", "tedit-filename", filename));
+    box.appendChild(head);
+    const diff = el("div", "tedit-diff");
+    box.appendChild(diff);
+    return { box, diff, oldLines, newLines };
+  }
+
+  // ──────────────────────────────────────────────────────────────────
+  // Info row — colored glyph + dim body. Used for pending + applied
+  // status lines, mirrors EventLog.tsx role="info".
+  // ──────────────────────────────────────────────────────────────────
+  function buildInfoRow(glyph, glyphColor, body) {
+    const row = el("div", "trow trow-info");
+    const g = el("span", "tinfo-glyph", glyph);
+    g.style.color = glyphColor;
+    row.appendChild(g);
+    row.appendChild(el("span", "tdim", " " + body));
+    return row;
+  }
+
+  // ──────────────────────────────────────────────────────────────────
+  // Animate text into a target node, character by character.
+  // ──────────────────────────────────────────────────────────────────
+  async function typeInto(target, text, perChar, cancelled) {
+    for (let i = 0; i < text.length; i++) {
+      target.appendChild(document.createTextNode(text[i]));
+      const j = perChar * (0.85 + Math.random() * 0.3);
+      const ch = text[i];
+      const pause = /[，。、；：,.;:]/.test(ch) ? perChar * 4 : 0;
+      // eslint-disable-next-line no-await-in-loop
+      await sleep(j + pause);
+      if (cancelled && cancelled()) return;
+    }
+  }
+
+  // Cancellation token — interrupts in-flight cycles when the user
+  // toggles language or clicks replay so we don't double-render.
+  let token = 0;
+
+  async function runCycle(root) {
+    const myToken = ++token;
+    const cancelled = () => myToken !== token;
+
+    root.classList.remove("trun-fade");
+    root.innerHTML = "";
+
+    root.appendChild(buildHeader(1));
+
+    await sleep(400);
+    if (cancelled()) return;
+
+    // 1. Live user prompt — types the question, then converts to a
+    //    permanent user row on submit.
+    const userMsg = tr(
+      "term.user",
+      "users.ts findByEmail is case-sensitive — login fails"
+    );
+    const live = buildLiveUserRow();
+    root.appendChild(live);
+    await sleep(400);
+    if (cancelled()) return;
+    await typeInto(live._input, userMsg, 32, cancelled);
+    if (cancelled()) return;
+    await sleep(550);
+    live._caret.remove();
+    live.classList.add("trow-sent");
+
+    // 2. Tool pills appear one by one. Real summaries come from
+    //    summarizeToolResult() in summarize.ts — we hard-code the
+    //    representative output for this scene.
+    await sleep(380);
+    if (cancelled()) return;
+    root.appendChild(
+      buildToolRow(
+        "search_files",
+        "matched 2 files: src/users.ts, src/users.test.ts",
+        "0.4s",
+        "1"
+      )
+    );
+    await sleep(560);
+    if (cancelled()) return;
+    root.appendChild(
+      buildToolRow("read_file", "read src/users.ts (412 chars)", "0.2s", "2")
+    );
+    await sleep(640);
+    if (cancelled()) return;
+
+    // 3. Assistant row — ◆ + model pill, then green-bordered body
+    //    containing the streamed text and the EditBlockRow.
+    const a = buildAssistantRow();
+    root.appendChild(a.row);
+    await sleep(280);
+    if (cancelled()) return;
+
+    const replyP = el("p", "tmd-p");
+    a.body.appendChild(replyP);
+    const replyMsg = tr(
+      "term.found",
+      "Found it. findByEmail uses === directly. Switching to lowercase normalization."
+    );
+    await typeInto(replyP, replyMsg, 18, cancelled);
+    if (cancelled()) return;
+    await sleep(360);
+
+    // 4. EditBlockRow — rounded cyan border with filename + colored
+    //    diff lines. No SEARCH/REPLACE markers.
+    const eb = buildEditBlock(
+      "src/users.ts",
+      ["  return users.find(u => u.email === email);"],
+      [
+        "  const needle = email.toLowerCase();",
+        "  return users.find(u => u.email.toLowerCase() === needle);",
+      ]
+    );
+    a.body.appendChild(eb.box);
+    await sleep(220);
+    if (cancelled()) return;
+
+    for (const line of eb.oldLines) {
+      const r = el("div", "tdiff tdiff-old", "- " + line);
+      eb.diff.appendChild(r);
+      // eslint-disable-next-line no-await-in-loop
+      await sleep(180);
+      if (cancelled()) return;
+    }
+    for (const line of eb.newLines) {
+      const r = el("div", "tdiff tdiff-new", "+ " + line);
+      eb.diff.appendChild(r);
+      // eslint-disable-next-line no-await-in-loop
+      await sleep(180);
+      if (cancelled()) return;
+    }
+    await sleep(420);
+    if (cancelled()) return;
+
+    // 5. Pending info row — slate `▸` + dim body. Real text from
+    //    formatPendingPreview() in edit-history.ts.
+    root.appendChild(
+      buildInfoRow(
+        "▸",
+        "#94a3b8",
+        tr(
+          "term.pending",
+          "1 pending edit block(s) — /apply (or y) to commit · /discard (or n) to drop"
+        )
+      )
+    );
+    await sleep(1700);
+    if (cancelled()) return;
+
+    // 6. /apply — second user turn. Live row, types `/apply`, then
+    //    transforms to a sent row. No tool pills (slash is local).
+    const apply = buildLiveUserRow();
+    root.appendChild(apply);
+    await sleep(420);
+    if (cancelled()) return;
+    await typeInto(apply._input, "/apply", 75, cancelled);
+    if (cancelled()) return;
+    await sleep(380);
+    apply._caret.remove();
+    apply.classList.add("trow-sent");
+
+    // 7. Applied info rows — first the header, then the per-file line.
+    //    Mirrors formatEditResults() in edit-history.ts.
+    await sleep(420);
+    root.appendChild(
+      buildInfoRow(
+        "▸",
+        "#94a3b8",
+        "edit blocks: 1/1 applied — /undo to roll back, or `git diff` to review"
+      )
+    );
+    const ok = el("div", "trow trow-info trow-info-detail");
+    const gl = el("span", "tinfo-glyph", "✓");
+    gl.style.color = "#4ade80";
+    ok.appendChild(el("span", "tdim", "  "));
+    ok.appendChild(gl);
+    ok.appendChild(el("span", "tdim", " applied      src/users.ts"));
+    root.appendChild(ok);
+
+    await sleep(2800);
+    if (cancelled()) return;
+
+    // 8. Fade and loop.
+    root.classList.add("trun-fade");
+    await sleep(900);
+    if (cancelled()) return;
+    runCycle(root);
+  }
+
+  // Reduced-motion fallback — paint the final scene without typing.
+  function runStatic(root) {
+    root.innerHTML = "";
+    root.appendChild(buildHeader(1));
+    root.appendChild(buildUserRow(tr("term.user", "")));
+    root.appendChild(
+      buildToolRow(
+        "search_files",
+        "matched 2 files: src/users.ts, src/users.test.ts",
+        "0.4s",
+        "1"
+      )
+    );
+    root.appendChild(
+      buildToolRow("read_file", "read src/users.ts (412 chars)", "0.2s", "2")
+    );
+    const a = buildAssistantRow();
+    root.appendChild(a.row);
+    const p = el("p", "tmd-p");
+    p.textContent = tr("term.found", "");
+    a.body.appendChild(p);
+    const eb = buildEditBlock(
+      "src/users.ts",
+      ["  return users.find(u => u.email === email);"],
+      [
+        "  const needle = email.toLowerCase();",
+        "  return users.find(u => u.email.toLowerCase() === needle);",
+      ]
+    );
+    a.body.appendChild(eb.box);
+    eb.oldLines.forEach((l) =>
+      eb.diff.appendChild(el("div", "tdiff tdiff-old", "- " + l))
+    );
+    eb.newLines.forEach((l) =>
+      eb.diff.appendChild(el("div", "tdiff tdiff-new", "+ " + l))
+    );
+    root.appendChild(buildInfoRow("▸", "#94a3b8", tr("term.pending", "")));
+  }
+
+  function init() {
+    const root = document.querySelector(ROOT_SEL);
+    if (!root) return;
+
+    if (window.Reasonix && typeof window.Reasonix.onLangChange === "function") {
+      window.Reasonix.onLangChange(() => runCycle(root));
+    }
+
+    document.querySelectorAll(REPLAY_SEL).forEach((btn) => {
+      btn.addEventListener("click", () => runCycle(root));
+    });
+
+    const prm = window.matchMedia
+      ? window.matchMedia("(prefers-reduced-motion: reduce)")
+      : null;
+    if (prm && prm.matches) {
+      runStatic(root);
+      return;
+    }
+
+    runCycle(root);
+  }
+
+  window.Reasonix = window.Reasonix || {};
+  window.Reasonix.term = {
+    replay() {
+      const root = document.querySelector(ROOT_SEL);
+      if (root) runCycle(root);
+    },
+  };
+
+  if (document.readyState === "loading") {
+    document.addEventListener("DOMContentLoaded", init);
+  } else {
+    init();
+  }
+})();

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,7 +1,7 @@
 {
   "name": "reasonix",
-  "version": "0.2.2",
-  "description": "DeepSeek-native agent framework: cache-first loop, R1 thought harvesting, tool-call repair.",
+  "version": "0.12.0",
+  "description": "DeepSeek-native coding agent: cache-first loop, flash-first cost control, tool-call repair.",
   "type": "module",
   "bin": {
     "reasonix": "dist/cli/index.js"
@@ -17,6 +17,10 @@
   },
   "files": [
     "dist",
+    "data/deepseek-tokenizer.json.gz",
+    "dashboard/index.html",
+    "dashboard/app.js",
+    "dashboard/app.css",
     "README.md",
     "LICENSE"
   ],

scripts/ctrlc-probe.mjs

@@ -0,0 +1,28 @@
+// Minimal Ctrl+C probe. Usage: node scripts/ctrlc-probe.mjs
+// Reproduces the exact stdin setup Reasonix uses, then logs every byte
+// it sees and exits on \x03. Tells us whether the OS even delivers
+// Ctrl+C to a Node child on this terminal.
+
+process.stdin.setRawMode(true);
+process.stdin.setEncoding("utf8");
+process.stdin.resume();
+
+console.log("ctrl+c probe armed. press keys; ctrl+c should exit.");
+console.log("if ctrl+c does NOT exit, the byte never reaches Node on this terminal.\n");
+
+process.stdin.on("data", (chunk) => {
+  const s = String(chunk);
+  for (const ch of s) {
+    const code = ch.charCodeAt(0);
+    process.stdout.write(`got byte: 0x${code.toString(16).padStart(2, "0")} (${JSON.stringify(ch)})\r\n`);
+    if (ch === "\x03") {
+      process.stdout.write("→ \\x03 detected, exiting.\r\n");
+      process.exit(0);
+    }
+  }
+});
+
+process.on("SIGINT", () => {
+  process.stdout.write("→ SIGINT received, exiting.\r\n");
+  process.exit(0);
+});

scripts/prepare-tokenizer.ts

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+/**
+ * Regenerate `data/deepseek-tokenizer.json.gz` from an upstream
+ * `tokenizer.json` (as shipped in DeepSeek's deepseek_v3_tokenizer.zip).
+ *
+ * Why slim+gz: the full tokenizer.json is 7.5MB; we only need four
+ * fields (vocab, merges, pre_tokenizer, added_tokens). Strip + gzip
+ * drops the committed artifact to ~1.7MB with no loss of fidelity
+ * for encode-side token counting.
+ *
+ * Usage: `node --experimental-strip-types scripts/prepare-tokenizer.ts <path/to/tokenizer.json>`
+ * (or via `tsx` / `ts-node`.)
+ */
+
+import { readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { gzipSync } from "node:zlib";
+
+const src = process.argv[2];
+if (!src) {
+  process.stderr.write("usage: prepare-tokenizer.ts <tokenizer.json>\n");
+  process.exit(2);
+}
+
+const raw = JSON.parse(readFileSync(src, "utf8"));
+const slim = {
+  added_tokens: raw.added_tokens,
+  pre_tokenizer: raw.pre_tokenizer,
+  model: { type: raw.model.type, vocab: raw.model.vocab, merges: raw.model.merges },
+};
+const gz = gzipSync(Buffer.from(JSON.stringify(slim)), { level: 9 });
+const outPath = join(process.cwd(), "data", "deepseek-tokenizer.json.gz");
+writeFileSync(outPath, gz);
+process.stdout.write(`wrote ${outPath} (${(gz.length / 1024).toFixed(1)} KB)\n`);

scripts/shift-enter-probe.mjs

@@ -0,0 +1,30 @@
+// Shift+Enter probe. Usage: node scripts/shift-enter-probe.mjs
+// Enables modifyOtherKeys + kitty keyboard protocol, then prints the
+// raw bytes for every keypress. Press Shift+Enter and see what your
+// terminal actually emits — if it's just "0x0d", the host doesn't
+// support either protocol and there's nothing Reasonix can do at the
+// raw-stdin layer.
+
+process.stdout.write("\u001b[>4;2m"); // modifyOtherKeys level 2 (xterm)
+process.stdout.write("\u001b[>1u"); // kitty keyboard protocol level 1
+
+process.stdin.setRawMode(true);
+process.stdin.setEncoding("utf8");
+process.stdin.resume();
+
+console.log("shift+enter probe armed. press keys; ctrl+c exits.");
+console.log("expected for shift+enter:");
+console.log("  modifyOtherKeys → 0x1b 0x5b 0x32 0x37 0x3b 0x32 0x3b 0x31 0x33 0x7e  (\\x1b[27;2;13~)");
+console.log("  kitty           → 0x1b 0x5b 0x31 0x33 0x3b 0x32 0x75              (\\x1b[13;2u)");
+console.log("  unsupported     → 0x0d                                              (just \\r — no way to distinguish)\n");
+
+process.stdin.on("data", (chunk) => {
+  const s = String(chunk);
+  const bytes = [...s].map((c) => `0x${c.charCodeAt(0).toString(16).padStart(2, "0")}`).join(" ");
+  process.stdout.write(`got: ${bytes}    (${JSON.stringify(s)})\r\n`);
+  if (s.includes("\x03")) {
+    process.stdout.write("\u001b[>4m"); // disable modifyOtherKeys
+    process.stdout.write("\u001b[<u"); // pop kitty level
+    process.exit(0);
+  }
+});

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/at-mentions.ts

@@ -0,0 +1,598 @@
+/**
+ * Expand `@path/to/file` mentions in a user prompt to inline file
+ * content.
+ *
+ * Why: most interactive coding sessions start with "look at X, then
+ * change Y". Typing `@src/loop.ts` reads faster and cheaper than
+ * "look at src/loop.ts (and the model fires read_file, and we pay for
+ * the round trip)" — the model sees the file content from turn 1
+ * instead of round-tripping a tool call for it.
+ *
+ * Shape: the user's text is kept verbatim. Expanded file contents are
+ * appended in a "Referenced files" block at the end, each wrapped in
+ * `<file path="...">...</file>` so the model can cite them back
+ * unambiguously.
+ *
+ * Safety: paths must resolve inside `rootDir` (no `..` escape, no
+ * absolute paths), must exist as a regular file, and must be under
+ * `maxBytes`. Missing / too-large / escaping paths get a short note
+ * appended instead of content so the user sees why it was skipped.
+ */
+
+import { type Dirent, existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { isAbsolute, join, relative, resolve } from "node:path";
+
+/** Caps match tool-result dispatch truncation (0.5.2). */
+export const DEFAULT_AT_MENTION_MAX_BYTES = 64 * 1024;
+
+/**
+ * Default directory names skipped when listing files for the picker.
+ * Matches what most repos gitignore AND keeps the picker off the
+ * hottest bloat — `node_modules` alone can be 100k+ entries.
+ */
+export const DEFAULT_PICKER_IGNORE_DIRS: readonly string[] = [
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  ".next",
+  "out",
+  "coverage",
+  ".cache",
+  ".vscode",
+  ".idea",
+  "target",
+  ".venv",
+  "venv",
+  "__pycache__",
+];
+
+export interface ListFilesOptions {
+  /** Cap the walk once we've collected this many entries. Default 500. */
+  maxResults?: number;
+  /** Directory names to skip entirely. Defaults to {@link DEFAULT_PICKER_IGNORE_DIRS}. */
+  ignoreDirs?: readonly string[];
+}
+
+/**
+ * Walk `root` recursively and return relative file paths (forward-slash
+ * separator, regardless of platform) for the `@` picker.
+ *
+ * Synchronous on purpose: this runs once at App mount (and on each turn
+ * so newly-created files show up) and blocks the render thread for a
+ * predictable ~10-50ms on a moderate repo. An async variant would need
+ * to coordinate with the Ink render loop; sync fits the rest of the
+ * TUI's single-turn-per-tick model cleanly.
+ *
+ * Skips:
+ *   - directories in `ignoreDirs` (default: DEFAULT_PICKER_IGNORE_DIRS)
+ *   - any directory whose name starts with `.` (covers `.git`,
+ *     `.vscode`, dotfile vendors). Dotfile REGULAR FILES (`.env`,
+ *     `.gitignore`, `.prettierrc`) are kept — users reference them.
+ *   - entries the walker can't read (permission errors, broken links).
+ */
+export function listFilesSync(root: string, opts: ListFilesOptions = {}): string[] {
+  return listFilesWithStatsSync(root, opts).map((e) => e.path);
+}
+
+export interface FileWithStats {
+  /** Relative path with forward-slash separator. */
+  path: string;
+  /** Modification time (Date.getTime() / ms since epoch). 0 when stat failed. */
+  mtimeMs: number;
+}
+
+/**
+ * Same walk as {@link listFilesSync} but also statS each file for
+ * modification time. Used by the `@` picker to surface recently-
+ * edited files first — matches VS Code Quick Open / similar UX.
+ *
+ * Stat failures don't throw: the entry is kept with `mtimeMs: 0` so
+ * it still appears in the picker (just sinks to the bottom of the
+ * recency sort).
+ */
+export function listFilesWithStatsSync(root: string, opts: ListFilesOptions = {}): FileWithStats[] {
+  const maxResults = Math.max(1, opts.maxResults ?? 500);
+  const ignore = new Set(opts.ignoreDirs ?? DEFAULT_PICKER_IGNORE_DIRS);
+  const rootAbs = resolve(root);
+  const out: FileWithStats[] = [];
+
+  const walk = (dirAbs: string, dirRel: string) => {
+    if (out.length >= maxResults) return;
+    let entries: Dirent[];
+    try {
+      entries = readdirSync(dirAbs, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    entries.sort((a, b) => a.name.localeCompare(b.name));
+    for (const ent of entries) {
+      if (out.length >= maxResults) return;
+      const relPath = dirRel ? `${dirRel}/${ent.name}` : ent.name;
+      if (ent.isDirectory()) {
+        if (ent.name.startsWith(".") || ignore.has(ent.name)) continue;
+        walk(join(dirAbs, ent.name), relPath);
+      } else if (ent.isFile()) {
+        let mtimeMs = 0;
+        try {
+          mtimeMs = statSync(join(dirAbs, ent.name)).mtimeMs;
+        } catch {
+          /* stat failed (permission / EAGAIN) — keep the entry with mtime=0 */
+        }
+        out.push({ path: relPath, mtimeMs });
+      }
+    }
+  };
+
+  walk(rootAbs, "");
+  return out;
+}
+
+/**
+ * Prefix pattern used by the `@` picker to detect an IN-PROGRESS
+ * mention at the END of the input buffer. Captures the partial path
+ * (which may be empty — just `@`) so the picker can use it as a
+ * substring filter.
+ *
+ * Distinct from {@link AT_MENTION_PATTERN} (which finds completed
+ * mentions anywhere in the text for expansion-at-submit). This one
+ * fires on the trailing token only, anchored at end-of-input.
+ */
+export const AT_PICKER_PREFIX = /(?:^|\s)@([a-zA-Z0-9_./\\-]*)$/;
+
+/**
+ * Return the picker state for a given input buffer: the partial query
+ * (may be empty string — just `@`) and the buffer offset of the `@`
+ * character. `null` when the buffer doesn't end in a mention-in-
+ * progress.
+ */
+export function detectAtPicker(input: string): { query: string; atOffset: number } | null {
+  const m = AT_PICKER_PREFIX.exec(input);
+  if (!m) return null;
+  const query = m[1] ?? "";
+  // `m.index` is the offset of the capture group's SURROUNDING match —
+  // which starts at either ^ or the preceding whitespace. The `@`
+  // itself is at `end-of-input - query.length - 1`.
+  const atOffset = input.length - query.length - 1;
+  return { query, atOffset };
+}
+
+/** A candidate accepted by the picker ranker — either a bare path or a path with mtime. */
+export type PickerCandidate = string | FileWithStats;
+
+export interface RankPickerOptions {
+  /** Upper bound on returned entries. Default 40. */
+  limit?: number;
+  /**
+   * Paths the user or model has touched recently (via tool calls like
+   * `read_file` / `edit_file`). Matching paths get a recency boost so
+   * the picker surfaces "stuff I just looked at" near the top.
+   */
+  recentlyUsed?: readonly string[];
+}
+
+/**
+ * Filter and rank candidate files against the picker's partial query.
+ *
+ * Empty query:
+ *   - Sort by "recently used" bucket first (if provided), then mtime
+ *     descending (newer first), then path alpha.
+ *   - Pure-string input (no mtime data) falls back to alpha since
+ *     recency info isn't available.
+ *
+ * Non-empty query:
+ *   - Case-insensitive substring match, with a basename-prefix boost
+ *     so `lo` floats `loop.ts`-shaped paths to the top.
+ *   - Ties broken first by recently-used membership, then mtime.
+ *
+ * Back-compat: passes `string[]` through the same logic (mtime = 0,
+ * recently-used still honored).
+ */
+export function rankPickerCandidates(
+  files: readonly PickerCandidate[],
+  query: string,
+  limitOrOpts?: number | RankPickerOptions,
+): string[] {
+  const opts: RankPickerOptions =
+    typeof limitOrOpts === "number" ? { limit: limitOrOpts } : (limitOrOpts ?? {});
+  const limit = opts.limit ?? 40;
+  const recent = new Set(opts.recentlyUsed ?? []);
+
+  const entries: FileWithStats[] = files.map((f) =>
+    typeof f === "string" ? { path: f, mtimeMs: 0 } : f,
+  );
+
+  if (!query) {
+    // Only re-sort when we actually have signal to sort by. If input
+    // is bare strings (mtime = 0 everywhere) AND there's no recent-
+    // used list, preserve input order so callers keep their existing
+    // layout. Passing FileWithStats or a non-empty recentlyUsed opts
+    // you into mtime+recency ranking.
+    const anyMtime = entries.some((e) => e.mtimeMs > 0);
+    if (!anyMtime && recent.size === 0) {
+      return entries.slice(0, limit).map((e) => e.path);
+    }
+    const sorted = [...entries].sort((a, b) => {
+      const aRecent = recent.has(a.path) ? 1 : 0;
+      const bRecent = recent.has(b.path) ? 1 : 0;
+      if (aRecent !== bRecent) return bRecent - aRecent;
+      if (a.mtimeMs !== b.mtimeMs) return b.mtimeMs - a.mtimeMs;
+      return a.path.localeCompare(b.path);
+    });
+    return sorted.slice(0, limit).map((e) => e.path);
+  }
+
+  const needle = query.toLowerCase();
+  const scored: Array<{ path: string; score: number; mtimeMs: number; recent: boolean }> = [];
+  for (const e of entries) {
+    const lower = e.path.toLowerCase();
+    const hit = lower.indexOf(needle);
+    if (hit < 0) continue;
+    const slash = lower.lastIndexOf("/");
+    const base = slash >= 0 ? lower.slice(slash + 1) : lower;
+    let score = 2;
+    if (base.startsWith(needle)) score = 0;
+    else if (lower.startsWith(needle)) score = 1;
+    scored.push({
+      path: e.path,
+      score: score * 10_000 + hit,
+      mtimeMs: e.mtimeMs,
+      recent: recent.has(e.path),
+    });
+  }
+  scored.sort((a, b) => {
+    if (a.score !== b.score) return a.score - b.score;
+    // Tie-break: recently-used, then mtime (newer first).
+    if (a.recent !== b.recent) return a.recent ? -1 : 1;
+    return b.mtimeMs - a.mtimeMs;
+  });
+  return scored.slice(0, limit).map((s) => s.path);
+}
+
+/**
+ * Matches `@` at a word boundary (start-of-string or preceded by
+ * whitespace) followed by a path-like token. Deliberately rejects `@`
+ * embedded in longer words (email addresses, mentions on social sites)
+ * by requiring the word boundary.
+ *
+ * Path charset keeps it to the characters that appear in real repo
+ * paths — letters, digits, `_` `-` `.` `/` `\`. Trailing `.` (e.g.
+ * `@foo.ts.`) is stripped before lookup so a sentence-terminating
+ * period doesn't break the mention.
+ */
+export const AT_MENTION_PATTERN = /(?<=^|\s)@([a-zA-Z0-9_./\\-]+)/g;
+
+export interface AtMentionExpansion {
+  /** The raw `@path` token as it appeared in the text. */
+  token: string;
+  /** The relative path, as resolved against rootDir. */
+  path: string;
+  /** True if the content was inlined. False = skipped (reason in `skip`). */
+  ok: boolean;
+  /** Bytes read (only for ok=true). */
+  bytes?: number;
+  /** Why the mention was skipped. Set when ok=false. */
+  skip?: "missing" | "not-file" | "too-large" | "escape" | "read-error";
+}
+
+export interface AtMentionOptions {
+  /** Max file size in bytes before a mention is skipped. */
+  maxBytes?: number;
+  /**
+   * Optional file-system overrides for tests. Real callers omit these;
+   * the helper falls through to `node:fs`.
+   */
+  fs?: {
+    exists: (path: string) => boolean;
+    isFile: (path: string) => boolean;
+    size: (path: string) => number;
+    read: (path: string) => string;
+  };
+}
+
+/**
+ * Expand `@path` mentions in `text`. Returns the (possibly augmented)
+ * text plus a per-mention report so the caller can surface expansions
+ * in the UI.
+ */
+export function expandAtMentions(
+  text: string,
+  rootDir: string,
+  opts: AtMentionOptions = {},
+): { text: string; expansions: AtMentionExpansion[] } {
+  const maxBytes = opts.maxBytes ?? DEFAULT_AT_MENTION_MAX_BYTES;
+  const fs = opts.fs ?? defaultFs;
+  const root = resolve(rootDir);
+  // De-dupe by token so `@file.ts` referenced twice inlines once.
+  const seen = new Map<string, AtMentionExpansion>();
+  const expansions: AtMentionExpansion[] = [];
+
+  for (const match of text.matchAll(AT_MENTION_PATTERN)) {
+    const rawPath = match[1] ?? "";
+    // Strip trailing dot (sentence terminator): `@foo.ts.` → `@foo.ts`.
+    // Keep internal dots intact.
+    const cleaned = rawPath.replace(/\.+$/, "");
+    if (!cleaned) continue;
+    const token = `@${cleaned}`;
+    if (seen.has(token)) continue;
+
+    const expansion = resolveMention(cleaned, root, maxBytes, fs);
+    seen.set(token, expansion);
+    expansions.push(expansion);
+  }
+
+  if (expansions.length === 0) return { text, expansions };
+
+  // Build the trailing "Referenced files" block. Keep successful
+  // inlines and skipped ones (with their reason) so the model sees
+  // both what's here and what's missing.
+  const blocks: string[] = [];
+  for (const ex of expansions) {
+    if (ex.ok) {
+      const content = readSafe(root, ex.path, fs);
+      blocks.push(`<file path="${ex.path}">\n${content}\n</file>`);
+    } else {
+      blocks.push(`<file path="${ex.path}" skipped="${ex.skip}" />`);
+    }
+  }
+  const augmented = `${text}\n\n[Referenced files]\n${blocks.join("\n\n")}`;
+  return { text: augmented, expansions };
+}
+
+function resolveMention(
+  rawPath: string,
+  root: string,
+  maxBytes: number,
+  fs: NonNullable<AtMentionOptions["fs"]>,
+): AtMentionExpansion {
+  // Reject absolute paths — `@/etc/passwd` should not inline.
+  if (isAbsolute(rawPath)) {
+    return { token: `@${rawPath}`, path: rawPath, ok: false, skip: "escape" };
+  }
+  const resolved = resolve(root, rawPath);
+  // Sandbox escape: after resolution the path must still be inside root.
+  const rel = relative(root, resolved);
+  if (rel.startsWith("..") || isAbsolute(rel)) {
+    return { token: `@${rawPath}`, path: rawPath, ok: false, skip: "escape" };
+  }
+  if (!fs.exists(resolved)) {
+    return { token: `@${rawPath}`, path: rawPath, ok: false, skip: "missing" };
+  }
+  if (!fs.isFile(resolved)) {
+    return { token: `@${rawPath}`, path: rawPath, ok: false, skip: "not-file" };
+  }
+  const size = fs.size(resolved);
+  if (size > maxBytes) {
+    return { token: `@${rawPath}`, path: rawPath, ok: false, skip: "too-large", bytes: size };
+  }
+  return { token: `@${rawPath}`, path: rawPath, ok: true, bytes: size };
+}
+
+function readSafe(root: string, rawPath: string, fs: NonNullable<AtMentionOptions["fs"]>): string {
+  const resolved = resolve(root, rawPath);
+  try {
+    return fs.read(resolved);
+  } catch {
+    return "(read failed)";
+  }
+}
+
+const defaultFs: NonNullable<AtMentionOptions["fs"]> = {
+  exists: (p) => existsSync(p),
+  isFile: (p) => {
+    try {
+      return statSync(p).isFile();
+    } catch {
+      return false;
+    }
+  },
+  size: (p) => {
+    try {
+      return statSync(p).size;
+    } catch {
+      return 0;
+    }
+  },
+  read: (p) => readFileSync(p, "utf8"),
+};
+
+// =============================================================================
+// @url mentions — async sibling of @path. Matches `@http(s)://...` after a
+// word boundary, fetches each URL once per session (in-memory cache), and
+// appends a "Referenced URLs" block under the prompt the model sees. Uses
+// the same web-fetch + HTML-strip pipeline as the model's `web_fetch` tool
+// so a `@url` reference and a model-issued fetch produce identical content.
+
+/**
+ * Matches `@http://...` or `@https://...` at a word boundary. Captures the
+ * URL minus the leading `@`. Trailing sentence punctuation is stripped
+ * separately because URLs can legitimately contain `,` `.` `)` etc., and a
+ * blanket trim would butcher real query strings.
+ */
+export const AT_URL_PATTERN = /(?<=^|\s)@(https?:\/\/\S+)/g;
+
+/** Default cap on inlined URL body (chars). Matches DEFAULT_AT_MENTION_MAX_BYTES order-of-magnitude. */
+export const DEFAULT_AT_URL_MAX_CHARS = 32_000;
+
+export interface AtUrlExpansion {
+  /** The raw `@url` token as it appeared in the text. */
+  token: string;
+  /** Absolute URL (after trailing-punctuation strip). */
+  url: string;
+  /** True if content was inlined. False = skipped (reason in `skip`). */
+  ok: boolean;
+  /** Page title when extractable from `<title>`. */
+  title?: string;
+  /** Char count of the (post-truncation) inlined body. */
+  chars?: number;
+  /** True iff the original page exceeded `maxChars` and was clipped. */
+  truncated?: boolean;
+  /** Why the mention was skipped — set when ok=false. */
+  skip?: "fetch-error" | "non-text" | "timeout" | "blocked";
+  /** Free-form error message attached to skip outcomes. */
+  error?: string;
+}
+
+export interface AtUrlOptions {
+  /** Max chars of inlined body per URL. Default DEFAULT_AT_URL_MAX_CHARS. */
+  maxChars?: number;
+  /** Per-URL fetch timeout in ms. */
+  timeoutMs?: number;
+  /**
+   * Override the fetcher — production wires `webFetch` from src/tools/web.ts.
+   * Tests inject a stub so the suite stays offline.
+   */
+  fetcher?: (
+    url: string,
+    opts: { maxChars?: number; timeoutMs?: number; signal?: AbortSignal },
+  ) => Promise<{ url: string; title?: string; text: string; truncated: boolean }>;
+  /**
+   * Optional cache the caller persists across calls (e.g. one map per
+   * session). Hit-on-URL skips the fetch entirely. Omit for one-shot
+   * tests that don't care about reuse.
+   */
+  cache?: Map<string, AtUrlExpansion & { body?: string }>;
+  /** Forward Esc/abort to the fetcher. */
+  signal?: AbortSignal;
+}
+
+/**
+ * Expand `@http(s)://…` mentions in `text`. Returns the (possibly augmented)
+ * text plus a per-URL report so the caller can surface fetched URLs in the
+ * UI. Async because each URL hits the network; the file-mention sibling
+ * (`expandAtMentions`) stays sync.
+ *
+ * Caching: when `opts.cache` is provided, a hit skips the network and
+ * reuses the prior expansion (including its body). One Map per session is
+ * the intended use — a long conversation that references the same URL
+ * twice doesn't pay twice.
+ *
+ * Trailing-punctuation handling: a sentence like "see @https://x.com." has
+ * the period stripped so the actual fetched URL is `https://x.com`. We
+ * conservatively strip only `.,;:!?` and `)]}>` from the tail; anything
+ * else is preserved so query strings survive intact.
+ */
+export async function expandAtUrls(
+  text: string,
+  opts: AtUrlOptions = {},
+): Promise<{ text: string; expansions: AtUrlExpansion[] }> {
+  const maxChars = opts.maxChars ?? DEFAULT_AT_URL_MAX_CHARS;
+  const fetcher = opts.fetcher;
+  if (!fetcher) {
+    throw new Error("expandAtUrls: fetcher option is required (wire src/tools/web.ts:webFetch)");
+  }
+
+  // De-dupe by URL so the same `@https://x.com` referenced twice fetches once.
+  const seen = new Map<string, AtUrlExpansion>();
+  const bodies = new Map<string, string>();
+  const order: string[] = [];
+
+  for (const match of text.matchAll(AT_URL_PATTERN)) {
+    const rawUrl = match[1] ?? "";
+    const url = stripUrlTail(rawUrl);
+    if (!url) continue;
+    if (seen.has(url)) continue;
+
+    const cached = opts.cache?.get(url);
+    if (cached) {
+      seen.set(url, cached);
+      if (cached.body) bodies.set(url, cached.body);
+      order.push(url);
+      continue;
+    }
+
+    let expansion: AtUrlExpansion;
+    let body = "";
+    try {
+      const page = await fetcher(url, {
+        maxChars,
+        timeoutMs: opts.timeoutMs,
+        signal: opts.signal,
+      });
+      body = page.text;
+      expansion = {
+        token: `@${url}`,
+        url,
+        ok: true,
+        title: page.title,
+        chars: body.length,
+        truncated: page.truncated,
+      };
+    } catch (err) {
+      const message = (err as Error).message ?? String(err);
+      // Tag a few common shapes so the UI can hint at causes.
+      let skip: AtUrlExpansion["skip"] = "fetch-error";
+      if (/aborted|timeout/i.test(message)) skip = "timeout";
+      else if (/40\d|forbidden|access denied|captcha/i.test(message)) skip = "blocked";
+      expansion = {
+        token: `@${url}`,
+        url,
+        ok: false,
+        skip,
+        error: message,
+      };
+    }
+    seen.set(url, expansion);
+    if (body) bodies.set(url, body);
+    if (opts.cache) opts.cache.set(url, { ...expansion, body });
+    order.push(url);
+  }
+
+  if (seen.size === 0) return { text, expansions: [] };
+
+  const expansions = order.map((u) => seen.get(u)!).filter(Boolean);
+  const blocks: string[] = [];
+  for (const ex of expansions) {
+    if (ex.ok) {
+      const titleAttr = ex.title ? ` title="${escapeAttr(ex.title)}"` : "";
+      const truncTag = ex.truncated ? ' truncated="true"' : "";
+      const body = bodies.get(ex.url) ?? "";
+      blocks.push(`<url href="${ex.url}"${titleAttr}${truncTag}>\n${body}\n</url>`);
+    } else {
+      const reasonAttr = ex.skip ?? "fetch-error";
+      blocks.push(`<url href="${ex.url}" skipped="${reasonAttr}" />`);
+    }
+  }
+  const augmented = `${text}\n\n[Referenced URLs]\n${blocks.join("\n\n")}`;
+  return { text: augmented, expansions };
+}
+
+/**
+ * Strip trailing sentence punctuation from a URL captured at a word
+ * boundary. `https://x.com.` → `https://x.com`; `https://x.com/?q=a)` →
+ * `https://x.com/?q=a`. Conservative: only strips `.,;:!?` and unmatched
+ * close-brackets `)]}>` from the very end. Internal punctuation in path /
+ * query is preserved.
+ *
+ * Returns empty string if everything stripped — caller treats as "no URL."
+ */
+export function stripUrlTail(raw: string): string {
+  let s = raw;
+  while (s.length > 0) {
+    const last = s[s.length - 1]!;
+    if (".,;:!?".includes(last)) {
+      s = s.slice(0, -1);
+      continue;
+    }
+    if (")]}>".includes(last)) {
+      // Only strip if the matching open bracket isn't elsewhere in the
+      // URL — avoids butchering legitimate `(thing)` query fragments.
+      const open = ({ ")": "(", "]": "[", "}": "{", ">": "<" } as const)[
+        last as ")" | "]" | "}" | ">"
+      ];
+      if (!s.includes(open)) {
+        s = s.slice(0, -1);
+        continue;
+      }
+    }
+    break;
+  }
+  return s;
+}
+
+function escapeAttr(s: string): string {
+  return s
+    .replace(/"/g, "&quot;")
+    .replace(/[\r\n]+/g, " ")
+    .trim();
+}

src/cli/commands/chat.tsx

@@ -1,9 +1,36 @@
+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 { StreamableHttpTransport } from "../../mcp/streamable-http.js";
+import {
+  loadSessionMessages,
+  rewriteSession,
+  sessionPath as sessionPathOf,
+} from "../../session.js";
+import { ToolRegistry } from "../../tools.js";
+import { registerChoiceTool } from "../../tools/choice.js";
+import { registerMemoryTools } from "../../tools/memory.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 { KeystrokeProvider } from "../ui/keystroke-context.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 +39,69 @@ 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;
+    jobs?: import("../../tools/jobs.js").JobRegistry;
+    /**
+     * `/cwd <path>` callback — re-registers every rootDir-dependent
+     * native tool against the new path. Optional so embedders that
+     * don't want live cwd switching can omit it (the slash command
+     * then falls back to non-tool updates only).
+     */
+    reregisterTools?: (rootDir: string) => void;
+  };
+  /** 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,25 +112,227 @@ function Root({ initialKey, ...appProps }: RootProps) {
       />
     );
   }
-  // Ensure the loop's DeepSeekClient picks up the key when it lazy-instantiates.
   process.env.DEEPSEEK_API_KEY = key;
+
+  // KeystrokeProvider must wrap App from OUTSIDE — App.tsx itself
+  // calls `useKeystroke` in its function body for global hotkeys
+  // (Ctrl+C, Esc abort, Shift+Tab edit-mode cycle, @-mention picker,
+  // slash-suggestion navigation). If the provider lives inside App's
+  // render, `useContext(KeystrokeContext)` returns `null` at hook
+  // call time and those handlers silently never subscribe.
+  if (pending && appProps.session) {
+    return (
+      <KeystrokeProvider>
+        <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);
+          }}
+        />
+      </KeystrokeProvider>
+    );
+  }
+
   return (
-    <App
-      model={appProps.model}
-      system={appProps.system}
-      transcript={appProps.transcript}
-      harvest={appProps.harvest}
-      branch={appProps.branch}
-      session={appProps.session}
-    />
+    <KeystrokeProvider>
+      <App
+        model={appProps.model}
+        system={appProps.system}
+        transcript={appProps.transcript}
+        harvest={appProps.harvest}
+        branch={appProps.branch}
+        session={appProps.session}
+        tools={tools}
+        mcpSpecs={mcpSpecs}
+        mcpServers={mcpServers}
+        progressSink={progressSink}
+        codeMode={appProps.codeMode}
+      />
+    </KeystrokeProvider>
   );
 }
 
 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 })
+            : spec.transport === "streamable-http"
+              ? new StreamableHttpTransport({ 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.transport === "streamable-http"
+            ? 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,
+          client: mcp,
+        });
+      } 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).
+  // `run_skill` is registered later in App.tsx (where the client
+  // exists) so it can wire the subagent runner for runAs:subagent
+  // skills.
+  if (!opts.seedTools) {
+    if (!tools) tools = new ToolRegistry();
+    registerMemoryTools(tools, {});
+    // `ask_choice` — branching primitive, useful in chat too (stylistic
+    // preferences, doc language, library picks). Independent of plan
+    // mode, which chat doesn't have anyway.
+    registerChoiceTool(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, []);
+  }
+
+  // No startup clear, no resize listener. Earlier attempts wrote
+  // various combinations of \x1b[2J / \x1b[3J / cursor-home to
+  // present a 'clean canvas' on launch and to neutralize Ink's
+  // eraseLines miscount on resize, but on xterm.js-based terminals
+  // (VSCode integrated terminal in particular) those sequences
+  // interfere with scrollback in ways that make wheel-up scroll
+  // dead. Letting Ink mount directly leaves the user's previous
+  // shell prompt visible above (scrolling up just works) and
+  // accepts the resize-ghost / launch-noise tradeoffs as known
+  // limitations — `/clear` is the manual reset.
+
+  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,157 @@
+/**
+ * `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 { loadEditMode, loadProjectShellAllowed } from "../../config.js";
+import { bootstrapSemanticSearchInCodeMode } from "../../index/semantic/tool.js";
+import { sanitizeName } from "../../session.js";
+import { ToolRegistry } from "../../tools.js";
+import { registerChoiceTool } from "../../tools/choice.js";
+import { registerFilesystemTools } from "../../tools/filesystem.js";
+import { JobRegistry } from "../../tools/jobs.js";
+import { registerMemoryTools } from "../../tools/memory.js";
+import { registerPlanTool } from "../../tools/plan.js";
+import { registerShellTools } from "../../tools/shell.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;
+  /**
+   * Opt into Pillar 2 harvesting (extracts a typed plan state from R1
+   * reasoning via an extra V3 call). Default OFF in code mode — the
+   * displayed subgoals/hypotheses/rejectedPaths have no programmatic
+   * consumer, only `uncertainties.length` feeds branching, and the
+   * extra V3 call adds ~10-15% per-turn cost. Users who want the
+   * reasoning surfaced explicitly can pass `--harvest`.
+   */
+  harvest?: 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();
+  // Background-process registry shared between the shell tools and the
+  // TUI's /jobs + /kill slashes + exit cleanup. One per `reasonix code`
+  // run — orphan prevention on SIGINT / process exit kills everything
+  // it owns, so dev servers don't outlive the Reasonix process.
+  const jobs = new JobRegistry();
+  // Bundled re-registration so `/cwd <path>` can swap every rootDir-
+  // dependent tool atomically. ToolRegistry.register is keyed by name
+  // and overwrites in-place, so re-calling these against the existing
+  // registry replaces the closures cleanly without disturbing tool
+  // specs (names/descriptions/params don't reference rootDir, so the
+  // prefix cache survives).
+  const registerRootedTools = (root: string): void => {
+    registerFilesystemTools(tools, { rootDir: root });
+    registerShellTools(tools, {
+      rootDir: root,
+      // 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(root),
+      // `yolo` edit-mode disables shell confirmations entirely. Re-read
+      // from config on each dispatch so /mode yolo (or Shift+Tab cycling
+      // through to it) flips the gate live without forcing a relaunch.
+      allowAll: () => loadEditMode() === "yolo",
+      jobs,
+    });
+    // `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: root });
+  };
+  registerRootedTools(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);
+  // `ask_choice` — branching primitive. Independent of plan mode: the
+  // model uses it to put a 2–4 way choice in front of the user
+  // (strategy, style, library pick) without trying to squeeze the
+  // menu into a submit_plan body. Keeping it always-registered
+  // preserves the prefix cache across plan-mode toggles.
+  registerChoiceTool(tools);
+  // `run_skill` is intentionally NOT registered here — App.tsx wires it
+  // up with the subagent runner attached, so `runAs: subagent` skills
+  // can spawn isolated child loops. Doing it here would mean the App's
+  // re-registration would shadow the no-runner version, which works
+  // (last write wins) but obscures the wiring.
+
+  // Bootstrap semantic_search. Silent: registers the tool when an
+  // on-disk index already exists, skips entirely otherwise. Setup
+  // happens via the explicit `reasonix index` command — never
+  // by surprise on launch.
+  const semantic = await bootstrapSemanticSearchInCodeMode(tools, rootDir);
+
+  process.stderr.write(
+    `▸ reasonix code: rooted at ${rootDir}, session "${session ?? "(ephemeral)"}" · ${tools.size} native tool(s)${
+      semantic.enabled ? " · semantic_search on" : ""
+    }\n`,
+  );
+
+  // Belt-and-suspenders cleanup: even though spawn(detached:false)
+  // should tie child processes to the parent's lifetime, Windows cmd.exe
+  // wrappers occasionally leak. We DON'T install SIGINT/SIGTERM
+  // handlers here — that overrode Node's default "exit on Ctrl+C" with
+  // a silent no-op, which made Ctrl+C feel broken in the TUI. App.tsx
+  // owns the SIGINT path now (it shows the quit-armed banner and calls
+  // exit() on confirmation); this 'exit' hook just guarantees the job
+  // registry is drained on the way out, regardless of which exit path
+  // fired.
+  process.once("exit", () => {
+    void jobs.shutdown();
+  });
+
+  await chatCommand({
+    model: opts.model ?? "deepseek-v4-flash",
+    harvest: opts.harvest ?? false,
+    system: codeSystemPrompt(rootDir, { hasSemanticSearch: semantic.enabled }),
+    transcript: opts.transcript,
+    session,
+    seedTools: tools,
+    codeMode: { rootDir, jobs, reregisterTools: registerRootedTools },
+    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/index.ts

@@ -0,0 +1,202 @@
+/**
+ * `reasonix index` — build (or incrementally refresh) the project's
+ * semantic search index.
+ *
+ * Usage:
+ *   reasonix index                  # incremental: only re-embeds changed files
+ *   reasonix index --rebuild        # wipe + rebuild from scratch
+ *   reasonix index --model MODEL    # override embedding model
+ *   reasonix index --dir PATH       # index a different directory
+ *
+ * Output is rendered to stderr so piping the index to a script
+ * (which we don't actually do today, but might) keeps stdout clean.
+ *
+ * On a TTY the progress writer paints `<spinner> <status>  <elapsed>s`
+ * on a single line, ticking every 120ms via setInterval — so the
+ * line keeps animating even between onProgress events. That's the
+ * load-bearing UX guarantee: builds that take 30+ seconds never
+ * leave the user wondering whether the process is hung.
+ *
+ * On non-TTY (CI, piped logs) we emit one line per phase + a
+ * periodic heartbeat. No \r tricks because they make logs unreadable.
+ */
+
+import { resolve } from "node:path";
+import { buildIndex } from "../../index/semantic/builder.js";
+import type { BuildProgress, BuildResult } from "../../index/semantic/builder.js";
+import { t } from "../../index/semantic/i18n.js";
+import { ollamaPreflight } from "../../index/semantic/preflight.js";
+
+export interface IndexCommandOptions {
+  rebuild?: boolean;
+  model?: string;
+  dir?: string;
+  /** Ollama base URL override. */
+  ollamaUrl?: string;
+  /** Skip preflight prompts (yes to all). For scripts that already
+   *  know Ollama is set up. Default false. */
+  yes?: boolean;
+}
+
+export async function indexCommand(opts: IndexCommandOptions = {}): Promise<void> {
+  const root = resolve(opts.dir ?? process.cwd());
+  const tty = process.stderr.isTTY === true && process.stdin.isTTY === true;
+  const model = opts.model ?? process.env.REASONIX_EMBED_MODEL ?? "nomic-embed-text";
+
+  // Preflight: detect Ollama state and offer to fix what's missing.
+  // Runs before chunking so the user doesn't watch a scan finish only
+  // to hit "daemon not reachable" on the first embed call.
+  const preflightOk = await ollamaPreflight({
+    model,
+    baseUrl: opts.ollamaUrl,
+    interactive: tty && !opts.yes,
+    yesToAll: opts.yes ?? false,
+  });
+  if (!preflightOk) process.exit(1);
+
+  const writer = makeProgressWriter(tty);
+
+  const t0 = Date.now();
+  let result: BuildResult;
+  try {
+    result = await buildIndex(root, {
+      rebuild: opts.rebuild,
+      model,
+      baseUrl: opts.ollamaUrl,
+      onProgress: (p) => writer.update(p),
+    });
+  } catch (err) {
+    writer.clear();
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(t("indexFailed", { msg }));
+    process.exit(1);
+  }
+  writer.clear();
+
+  const seconds = ((Date.now() - t0) / 1000).toFixed(1);
+  const successKey = result.chunksSkipped > 0 ? "indexSuccessWithSkips" : "indexSuccess";
+  process.stderr.write(
+    t(successKey, {
+      scanned: result.filesScanned,
+      changed: result.filesChanged,
+      added: result.chunksAdded,
+      removed: result.chunksRemoved,
+      skipped: result.chunksSkipped,
+      seconds,
+    }),
+  );
+  if (result.filesChanged === 0 && !opts.rebuild) {
+    process.stderr.write(t("indexNothingToDo"));
+  }
+}
+
+interface ProgressWriter {
+  update(p: BuildProgress): void;
+  clear(): void;
+}
+
+/**
+ * Braille spinner — same alphabet most CLI spinners use. Ten frames,
+ * cycled at ~120ms each. Visually clear that the process is alive
+ * even when no progress events fire (e.g. during phase transitions
+ * or while waiting on Ollama's first model-load latency).
+ */
+const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const SPINNER_INTERVAL_MS = 120;
+
+function makeProgressWriter(tty: boolean): ProgressWriter {
+  if (!tty) return makeNonTtyWriter();
+  return makeTtyWriter();
+}
+
+/**
+ * Non-TTY writer — one line per phase transition + a heartbeat every
+ * 50 embedded chunks. Keeps logs short and parseable while still
+ * proving forward motion.
+ */
+function makeNonTtyWriter(): ProgressWriter {
+  let lastPhase: BuildProgress["phase"] | null = null;
+  let lastChunks = 0;
+  return {
+    update(p) {
+      if (p.phase !== lastPhase) {
+        lastPhase = p.phase;
+        if (p.phase === "scan") {
+          process.stderr.write(t("progressScanLine"));
+        } else if (p.phase === "embed") {
+          process.stderr.write(
+            t("progressEmbedLine", {
+              total: p.chunksTotal ?? 0,
+              files: p.filesChanged ?? 0,
+            }),
+          );
+        }
+      }
+      if (p.phase === "embed" && p.chunksDone !== undefined && p.chunksDone - lastChunks >= 50) {
+        lastChunks = p.chunksDone;
+        process.stderr.write(
+          t("progressEmbedHeartbeat", {
+            done: p.chunksDone,
+            total: p.chunksTotal ?? "?",
+          }),
+        );
+      }
+    },
+    clear() {
+      /* non-TTY keeps its accumulated lines */
+    },
+  };
+}
+
+/**
+ * TTY writer — paints `<spinner> <status>  <elapsed>s` on a single
+ * line via \r. The spinner ticks on a setInterval, INDEPENDENT of
+ * onProgress events: even if the embedder hangs for 5 seconds on
+ * the first model-load, the spinner keeps spinning so the user sees
+ * the process is alive.
+ */
+function makeTtyWriter(): ProgressWriter {
+  let status = t("progressStarting");
+  let lastLineLen = 0;
+  let frameIdx = 0;
+  const startTs = Date.now();
+
+  const repaint = () => {
+    const frame = SPINNER_FRAMES[frameIdx % SPINNER_FRAMES.length];
+    frameIdx++;
+    const elapsed = ((Date.now() - startTs) / 1000).toFixed(1);
+    const line = `${frame} ${status}  ${elapsed}s`;
+    const padded = line + " ".repeat(Math.max(0, lastLineLen - line.length));
+    process.stderr.write(`\r${padded}`);
+    lastLineLen = line.length;
+  };
+
+  // Paint the initial frame immediately so the user sees text on
+  // line one — don't wait for the first interval tick.
+  repaint();
+  const interval = setInterval(repaint, SPINNER_INTERVAL_MS);
+
+  return {
+    update(p) {
+      if (p.phase === "scan") {
+        status = t("progressScan", { files: p.filesScanned ?? 0 });
+      } else if (p.phase === "embed") {
+        const done = p.chunksDone ?? 0;
+        const total = p.chunksTotal ?? 0;
+        const pct = total > 0 ? ((done / total) * 100).toFixed(0) : "0";
+        status = t("progressEmbed", { done, total, pct });
+      }
+      // Repaint immediately on event arrival so the new counter
+      // shows up before the next interval tick (avoids a 120ms lag
+      // on each progress update).
+      repaint();
+    },
+    clear() {
+      clearInterval(interval);
+      if (lastLineLen > 0) {
+        process.stderr.write(`\r${" ".repeat(lastLineLen)}\r`);
+        lastLineLen = 0;
+      }
+    },
+  };
+}

src/cli/commands/mcp-inspect.ts

@@ -0,0 +1,110 @@
+/**
+ * `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";
+import { StreamableHttpTransport } from "../../mcp/streamable-http.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 })
+      : spec.transport === "streamable-http"
+        ? new StreamableHttpTransport({ 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,33 @@
+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 { StreamableHttpTransport } from "../../mcp/streamable-http.js";
+import { ToolRegistry } from "../../tools.js";
+import { openTranscriptFile, recordFromLoopEvent, writeRecord } from "../../transcript.js";
+import { appendUsage } from "../../usage.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 +68,117 @@ 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 })
+            : spec.transport === "streamable-http"
+              ? new StreamableHttpTransport({ 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.transport === "streamable-http"
+            ? 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");
+      if (ev.role === "assistant_final" && ev.stats?.usage) {
+        // `reasonix run` is often used in CI / scripting — we want
+        // those turns to show up in `reasonix stats` too so the
+        // dashboard reflects all DeepSeek spend, not just TUI sessions.
+        appendUsage({ session: null, model: ev.stats.model, usage: ev.stats.usage });
+      }
+      // 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/stats.ts

@@ -1,15 +1,60 @@
+/**
+ * `reasonix stats` — two modes, decided by whether the user passed
+ * a transcript path.
+ *
+ *   - `reasonix stats`          → cross-session usage dashboard
+ *                                  (reads `~/.reasonix/usage.jsonl`)
+ *   - `reasonix stats <path>`   → summary of a single JSONL transcript
+ *                                  (original v0.1 behavior, kept so
+ *                                   existing scripts don't break)
+ *
+ * The dashboard is the new story: for every turn `reasonix chat|code|run`
+ * has ever executed on this machine, we aggregate tokens + cost + the
+ * equivalent Claude spend, and print rolling-window totals (today /
+ * week / month / all-time). The savings column is the Pillar 1 pitch
+ * made concrete — "you paid $X; Claude would have charged $Y, a N%
+ * reduction."
+ */
+
 import { existsSync, readFileSync } from "node:fs";
+import {
+  type UsageAggregate,
+  type UsageBucket,
+  aggregateUsage,
+  bucketCacheHitRatio,
+  bucketSavingsFraction,
+  defaultUsageLogPath,
+  formatLogSize,
+  readUsageLog,
+} from "../../usage.js";
 
 export interface StatsOptions {
-  transcript: string;
+  /** Optional transcript path. Absent → dashboard mode. */
+  transcript?: string;
+  /** Override usage log location (tests). */
+  logPath?: string;
+  /** Inject a fixed timestamp (tests) so rolling windows are deterministic. */
+  now?: number;
 }
 
 export function statsCommand(opts: StatsOptions): void {
-  if (!existsSync(opts.transcript)) {
-    console.error(`no such transcript: ${opts.transcript}`);
+  if (opts.transcript) {
+    transcriptSummary(opts.transcript);
+    return;
+  }
+  dashboard(opts);
+}
+
+// ---------------------------------------------------------------------
+// Transcript summary — legacy v0.1 behavior, preserved verbatim.
+// ---------------------------------------------------------------------
+
+function transcriptSummary(path: string): void {
+  if (!existsSync(path)) {
+    console.error(`no such transcript: ${path}`);
     process.exit(1);
   }
-  const lines = readFileSync(opts.transcript, "utf8").split(/\r?\n/).filter(Boolean);
+  const lines = readFileSync(path, "utf8").split(/\r?\n/).filter(Boolean);
   let assistantTurns = 0;
   let toolCalls = 0;
   let lastTurn = 0;
@@ -23,8 +68,129 @@ export function statsCommand(opts: StatsOptions): void {
       /* skip */
     }
   }
-  console.log(`transcript:       ${opts.transcript}`);
+  console.log(`transcript:       ${path}`);
   console.log(`assistant turns:  ${assistantTurns}`);
   console.log(`tool invocations: ${toolCalls}`);
   console.log(`last turn index:  ${lastTurn}`);
 }
+
+// ---------------------------------------------------------------------
+// Dashboard — aggregates ~/.reasonix/usage.jsonl.
+// ---------------------------------------------------------------------
+
+function dashboard(opts: StatsOptions): void {
+  const path = opts.logPath ?? defaultUsageLogPath();
+  const records = readUsageLog(path);
+  if (records.length === 0) {
+    console.log("no usage data yet.");
+    console.log("");
+    console.log(`  ${path}`);
+    console.log("");
+    console.log("run `reasonix chat`, `reasonix code`, or `reasonix run <task>` — every turn");
+    console.log("appends one line to the log and `reasonix stats` will roll it up.");
+    return;
+  }
+
+  const agg = aggregateUsage(records, { now: opts.now });
+  console.log(renderDashboard(agg, path));
+}
+
+/** Pure renderer — pulled out so tests can assert on the string directly. */
+export function renderDashboard(agg: UsageAggregate, logPath: string): string {
+  const lines: string[] = [];
+  const size = formatLogSize(logPath);
+  lines.push(`Reasonix usage — ${logPath}${size ? ` (${size})` : ""}`);
+  lines.push("");
+  lines.push(header());
+  lines.push(divider());
+  for (const b of agg.buckets) {
+    lines.push(bucketRow(b));
+  }
+  lines.push("");
+
+  // Model + session breakdown — both trim to top 3 so a user with 20
+  // sessions doesn't drown the table.
+  if (agg.byModel.length > 0) {
+    const totalTurns = agg.buckets[agg.buckets.length - 1]?.turns ?? 0;
+    const top = agg.byModel[0];
+    if (top && totalTurns > 0) {
+      const pct = ((top.turns / totalTurns) * 100).toFixed(0);
+      lines.push(`most used model:   ${top.model} (${pct}% of turns)`);
+    }
+  }
+  if (agg.bySession.length > 0) {
+    const top = agg.bySession[0];
+    if (top) lines.push(`top session:       ${top.session} (${top.turns} turns)`);
+  }
+  if (agg.firstSeen) {
+    lines.push(`tracked since:     ${new Date(agg.firstSeen).toISOString().slice(0, 10)}`);
+  }
+  if (agg.subagents) {
+    lines.push("");
+    lines.push(renderSubagentSection(agg.subagents));
+  }
+  return lines.join("\n");
+}
+
+function renderSubagentSection(sub: NonNullable<UsageAggregate["subagents"]>): string {
+  const lines: string[] = [];
+  const seconds = (sub.totalDurationMs / 1000).toFixed(1);
+  lines.push(
+    `subagent activity: ${sub.total} run(s) · $${sub.costUsd.toFixed(6)} · ${seconds}s total`,
+  );
+  // Show at most 5 skills so the section never dwarfs the main table.
+  const top = sub.bySkill.slice(0, 5);
+  for (const s of top) {
+    const sec = (s.durationMs / 1000).toFixed(1);
+    lines.push(
+      `  ${pad(s.skillName, 18)} ${pad(`${s.count}`, 4, "right")}  $${s.costUsd.toFixed(6)}  ${sec}s`,
+    );
+  }
+  if (sub.bySkill.length > top.length) {
+    lines.push(`  (+${sub.bySkill.length - top.length} more)`);
+  }
+  return lines.join("\n");
+}
+
+function header(): string {
+  // Fixed column widths so alignment works in any TTY.
+  // `cache saved` reports DeepSeek's hit-vs-miss USD diff; the existing
+  // `saved` column is the % saved vs Claude-Sonnet equivalent.
+  return [
+    pad("", 10),
+    pad("turns", 8, "right"),
+    pad("cache hit", 10, "right"),
+    pad("cost (USD)", 14, "right"),
+    pad("cache saved", 14, "right"),
+    pad("vs Claude", 14, "right"),
+    pad("saved", 10, "right"),
+  ].join("  ");
+}
+
+function divider(): string {
+  return "-".repeat(86);
+}
+
+function bucketRow(b: UsageBucket): string {
+  const hit = bucketCacheHitRatio(b);
+  const savings = bucketSavingsFraction(b);
+  return [
+    pad(b.label, 10),
+    pad(b.turns.toString(), 8, "right"),
+    pad(b.turns > 0 ? `${(hit * 100).toFixed(1)}%` : "—", 10, "right"),
+    pad(b.turns > 0 ? `$${b.costUsd.toFixed(6)}` : "—", 14, "right"),
+    pad(
+      b.turns > 0 && b.cacheSavingsUsd > 0 ? `$${b.cacheSavingsUsd.toFixed(4)}` : "—",
+      14,
+      "right",
+    ),
+    pad(b.turns > 0 ? `$${b.claudeEquivUsd.toFixed(4)}` : "—", 14, "right"),
+    pad(b.turns > 0 && savings > 0 ? `${(savings * 100).toFixed(1)}%` : "—", 10, "right"),
+  ].join("  ");
+}
+
+function pad(s: string, width: number, align: "left" | "right" = "left"): string {
+  if (s.length >= width) return s;
+  const fill = " ".repeat(width - s.length);
+  return align === "right" ? `${fill}${s}` : `${s}${fill}`;
+}

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,79 +1,255 @@
 import { Command } from "commander";
+import { readConfig } from "../config.js";
 import { VERSION } from "../index.js";
+import { ESCALATION_CONTRACT } from "../prompt-fragments.js";
+import { listSessions } from "../session.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 { indexCommand } from "./commands/index.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 { resolveContinueFlag, resolveDefaults } from "./resolve.js";
 
-const DEFAULT_SYSTEM =
-  "You are Reasonix, a helpful DeepSeek-powered assistant. Be concise and accurate. Use tools when available.";
+const DEFAULT_SYSTEM = `You are Reasonix, a helpful DeepSeek-powered assistant. Be concise and accurate. Use tools when available.
+
+# Cite or shut up — non-negotiable
+
+Every factual claim about a codebase must be backed by evidence. Reasonix VALIDATES your citations — broken paths render in **red strikethrough with ❌** in front of the user.
+
+**Positive claims** — append a markdown link:
+- ✅ \`The MCP client supports listResources [listResources](src/mcp/client.ts:142).\`
+- ❌ \`The MCP client supports listResources.\` ← unverifiable, do not write.
+
+**Negative claims** ("X is missing", "Y isn't implemented", "lacks Z") are the #1 hallucination shape. STOP before writing them. If you have a search tool, call it first; if the search returns nothing, cite the search itself as evidence (\`No matches for "foo" in src/\`). If you have no tool, qualify hard: "I haven't verified — this is a guess."
+
+Asserting absence without checking is how evaluative answers go wrong. Treat the urge to write "missing" as a red flag in your own reasoning.
+
+# Don't invent what changes — search instead
+
+Your training data has a cutoff. When an answer's correctness depends on something that changes over time (the user is asking what's happening, not what's true) and a search tool is available, search first. Inventing currently-correct values from training memory is the most common way these answers go wrong, and the user usually can't tell until much later.
+
+The signal isn't a topic list — it's: "if I'm wrong about this, is it because reality moved on?". If yes, ground the answer in fresh evidence; if no (definitions, mechanisms, well-established APIs), answer from memory.
+
+${ESCALATION_CONTRACT}`;
 
 const program = new Command();
 program
   .name("reasonix")
   .description("DeepSeek-native agent framework — built for cache hits and cheap tokens.")
-  .version(VERSION);
+  .version(VERSION)
+  .option(
+    "-c, --continue",
+    "Resume the most recently used chat session without showing the picker.",
+  );
+
+// `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 (opts: { continue?: boolean }) => {
+  const cfg = readConfig();
+  if (!cfg.setupCompleted) {
+    await setupCommand({});
+    return;
+  }
+  const defaults = resolveDefaults({});
+  const continueOpts = resolveContinueFlag(
+    opts.continue,
+    defaults.session,
+    () => listSessions()[0],
+    (msg) => process.stderr.write(`${msg}\n`),
+  );
+  await chatCommand({
+    model: defaults.model,
+    system: applyMemoryStack(DEFAULT_SYSTEM, process.cwd()),
+    harvest: defaults.harvest,
+    branch: defaults.branch,
+    session: continueOpts.session,
+    mcp: defaults.mcp,
+    forceResume: continueOpts.forceResume,
+  });
+});
+
+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 tools rooted at <dir> (default: cwd), coding system prompt, v4-flash. Model proposes SEARCH/REPLACE blocks; Reasonix applies them to disk. Use /preset max or /pro to escalate to v4-pro on hard tasks.",
+  )
+  .option("-m, --model <id>", "Override default model (v4-flash)")
+  .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")
+  .option(
+    "--harvest",
+    "Opt-in Pillar-2 plan-state extraction. Adds one flash call per turn; off by default (no preset enables it).",
+  )
+  .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,
+      harvest: !!opts.harvest,
+    });
+  });
 
 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>",
+    "Model + effort bundle. One of: fast (flash·high), smart (flash·max, default), max (pro·max). Overrides config.preset.",
+  )
   .option(
     "--harvest",
-    "Extract typed plan state from R1 reasoning (Pillar 2, adds a cheap V3 call per turn)",
+    "Opt-in Pillar-2 plan-state extraction. Off by default — no preset enables it.",
   )
   .option(
     "--branch <n>",
-    "Self-consistency: run N parallel samples per turn and pick the most confident (disables streaming; enables harvest)",
+    "Self-consistency: run N parallel samples per turn (N× cost). Manual only — never auto-enabled.",
     (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(
+    "-c, --continue",
+    "Resume the most-recently-used session (any name) without showing the picker.",
+  )
+  .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,
+    });
+    // `-c` is "newest-touched session" + auto-resume; `-r` is "this
+    // session's prior messages, even if you also passed --session".
+    // When both are set we prefer the explicit `--session` + `-r`
+    // (more specific input wins). `-c` only kicks in if `-r` wasn't.
+    const continueOpts = opts.resume
+      ? { session: defaults.session, forceResume: true }
+      : resolveContinueFlag(
+          opts.continue,
+          defaults.session,
+          () => listSessions()[0],
+          (msg) => process.stderr.write(`${msg}\n`),
+        );
+    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: continueOpts.session,
+      mcp: defaults.mcp,
+      mcpPrefix: opts.mcpPrefix,
+      forceResume: continueOpts.forceResume,
+      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
-  .command("stats <transcript>")
-  .description("Summarize a JSONL transcript produced by `reasonix chat --transcript`.")
-  .action((transcript: string) => {
+  .command("stats [transcript]")
+  .description(
+    "Show usage dashboard (today / week / month / all-time · turns · cache hit · cost · savings vs Claude). " +
+      "Pass a transcript path to fall back to the per-file summary (assistant turns + tool calls).",
+  )
+  .action((transcript: string | undefined) => {
     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 +289,70 @@ 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
+  .command("index")
+  .description(
+    "Build (or incrementally refresh) a local semantic search index for the project so `reasonix code` can answer 'where do we…' questions by meaning, not just by token. Uses Ollama as the embedding backend; missing daemon / model is offered to the user with a confirm prompt.",
+  )
+  .option("--rebuild", "Wipe and rebuild from scratch")
+  .option("--model <name>", "Embedding model (default: nomic-embed-text)")
+  .option("--dir <path>", "Project root to index (default: cwd)")
+  .option("--ollama-url <url>", "Override Ollama base URL (default: http://localhost:11434)")
+  .option(
+    "-y, --yes",
+    "Skip preflight prompts — auto-start the daemon and pull the model if missing (use in scripts)",
+  )
+  .action(
+    async (opts: {
+      rebuild?: boolean;
+      model?: string;
+      dir?: string;
+      ollamaUrl?: string;
+      yes?: boolean;
+    }) => {
+      await indexCommand(opts);
+    },
+  );
+
 program.parseAsync(process.argv).catch((err) => {
   console.error(err);
   process.exit(1);

src/cli/resolve.ts

@@ -0,0 +1,125 @@
+/**
+ * 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 "smart" preset defaults (flash + effort=max)
+ *
+ * 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 { resolvePreset } from "./ui/presets.js";
+
+export interface ResolvedDefaults {
+  model: string;
+  reasoningEffort: "high" | "max";
+  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 = resolvePreset(preset);
+
+  const model = flags.model ?? presetSettings.model;
+  const reasoningEffort = presetSettings.reasoningEffort;
+  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, reasoningEffort, harvest, branch, mcp, session };
+}
+
+function pickPreset(
+  flagPreset: string | undefined,
+  configPreset: PresetName | undefined,
+): PresetName {
+  if (flagPreset && isPresetName(flagPreset)) return flagPreset;
+  if (configPreset) return configPreset;
+  return "auto";
+}
+
+function isPresetName(s: string): s is PresetName {
+  return (
+    s === "auto" ||
+    s === "flash" ||
+    s === "pro" ||
+    // Legacy names — kept callable so old `--preset smart` invocations
+    // and stale config.json entries don't error out.
+    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";
+}
+
+/**
+ * Resolve the `-c/--continue` flag into a concrete `(session, forceResume)`
+ * pair. When the flag is set we ask `getLatestSession` for the most-recently-
+ * touched saved session and skip the picker; if nothing is on disk we
+ * fall back silently to `fallbackSession` after emitting a single warning
+ * line via `warn`.
+ *
+ * Pure & testable: callers inject the fs lookup. `cli/index.ts` plugs in
+ * `() => listSessions()[0]`; tests pass a deterministic stub.
+ */
+export function resolveContinueFlag(
+  flag: boolean | undefined,
+  fallbackSession: string | undefined,
+  getLatestSession: () => { name: string } | undefined,
+  warn: (msg: string) => void = () => {},
+): { session: string | undefined; forceResume: boolean } {
+  if (!flag) return { session: fallbackSession, forceResume: false };
+  const latest = getLatestSession();
+  if (!latest) {
+    warn("▸ -c/--continue: no saved sessions yet — starting a fresh one.");
+    return { session: fallbackSession, forceResume: false };
+  }
+  return { session: latest.name, forceResume: true };
+}

src/cli/ui/AtMentionSuggestions.tsx

@@ -0,0 +1,82 @@
+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";
+
+export interface AtMentionSuggestionsProps {
+  /**
+   * Current matching file paths, ranked by the picker. `null` means
+   * "not in @-prefix mode" — render nothing. Empty array means "in @
+   * mode but no files match that partial" — render a hint.
+   */
+  matches: readonly string[] | null;
+  /** Index (within `matches`) of the currently highlighted row. */
+  selectedIndex: number;
+  /** The partial query the user typed after `@`. Shown in the hint row. */
+  query: string;
+}
+
+/**
+ * Floating `@`-mention picker. Rendered below the input box when the
+ * user is typing an `@…` prefix in code mode. Navigation state lives
+ * in the parent (App.tsx owns `atSelected`) — this component is pure
+ * display. Mirrors {@link SlashSuggestions} shape so the keybindings
+ * and layout feel identical across the two pickers.
+ */
+export function AtMentionSuggestions({
+  matches,
+  selectedIndex,
+  query,
+}: AtMentionSuggestionsProps): React.ReactElement | null {
+  if (matches === null) return null;
+  if (matches.length === 0) {
+    return (
+      <Box paddingX={1} marginTop={1}>
+        <Text color="yellow">no files match "@{query}"</Text>
+        <Text dimColor>
+          {" "}
+          — keep typing, or Backspace to edit. Paths resolve from the code root.
+        </Text>
+      </Box>
+    );
+  }
+  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} marginTop={1}>
+      {hiddenAbove > 0 ? <Text dimColor> ↑ {hiddenAbove} more above</Text> : null}
+      {shown.map((path, i) => (
+        <FileRow key={path} path={path} isSelected={windowStart + i === selectedIndex} />
+      ))}
+      {hiddenBelow > 0 ? <Text dimColor> ↓ {hiddenBelow} more below</Text> : null}
+      <Text dimColor> [↑↓] navigate · [Tab]/[Enter] pick · file content inlined on send</Text>
+    </Box>
+  );
+}
+
+function FileRow({ path, isSelected }: { path: string; isSelected: boolean }) {
+  // Split the path so the basename visually pops — same dropdown
+  // affordance as VS Code's Quick Open.
+  const slash = path.lastIndexOf("/");
+  const dir = slash >= 0 ? `${path.slice(0, slash)}/` : "";
+  const base = slash >= 0 ? path.slice(slash + 1) : path;
+  if (isSelected) {
+    return (
+      <Box>
+        <Text backgroundColor="#67e8f9" color="black" bold>
+          {` ▸ ${base}${dir ? `  ${dir}` : ""} `}
+        </Text>
+      </Box>
+    );
+  }
+  return (
+    <Box>
+      <Text color="#94a3b8">{`   ${base}`}</Text>
+      {dir ? <Text dimColor>{`  ${dir}`}</Text> : null}
+    </Box>
+  );
+}

src/cli/ui/ChoiceConfirm.tsx

@@ -0,0 +1,75 @@
+/**
+ * Modal picker shown when the model calls `ask_choice`. Renders the
+ * question + 2–4 option rows (title + dimmed summary) + an optional
+ * "Let me type my own answer" escape hatch when `allowCustom` is true.
+ *
+ * The escape hatch matters because DeepSeek flash sometimes misframes
+ * the alternatives — none actually fit the user's intent. Without a
+ * bailout the user would have to cancel, type feedback, and wait for
+ * another round-trip. With it they just type and ship.
+ *
+ * Border color: magenta — deliberately distinct from cyan (plan),
+ * green (checkpoint), red (shell) so the user's eye learns the modes
+ * without reading headers.
+ */
+
+import { Box } from "ink";
+import React from "react";
+import type { ChoiceOption } from "../../tools/choice.js";
+import { ModalCard } from "./ModalCard.js";
+import { SingleSelect } from "./Select.js";
+
+export type ChoiceConfirmChoice =
+  | { kind: "pick"; optionId: string }
+  | { kind: "custom" }
+  | { kind: "cancel" };
+
+export interface ChoiceConfirmProps {
+  question: string;
+  options: ChoiceOption[];
+  allowCustom: boolean;
+  onChoose: (choice: ChoiceConfirmChoice) => void;
+}
+
+const CUSTOM_VALUE = "__custom__";
+const CANCEL_VALUE = "__cancel__";
+
+function ChoiceConfirmInner({ question, options, allowCustom, onChoose }: ChoiceConfirmProps) {
+  const items: Array<{ value: string; label: string; hint?: string }> = options.map((opt) => ({
+    value: opt.id,
+    label: `${opt.id} · ${opt.title}`,
+    hint: opt.summary,
+  }));
+  if (allowCustom) {
+    items.push({
+      value: CUSTOM_VALUE,
+      label: "Let me type my own answer",
+      hint: "None of the above fits — type a free-form reply. The model reads it verbatim.",
+    });
+  }
+  items.push({
+    value: CANCEL_VALUE,
+    label: "Cancel — drop the question",
+    hint: "Model stops and asks what you want instead.",
+  });
+
+  return (
+    <ModalCard accent="#f0abfc" icon="🔀" title="model wants you to pick" subtitle={question}>
+      <Box>
+        <SingleSelect
+          initialValue={options[0]?.id}
+          items={items}
+          onSubmit={(v) => {
+            if (v === CUSTOM_VALUE) onChoose({ kind: "custom" });
+            else if (v === CANCEL_VALUE) onChoose({ kind: "cancel" });
+            else onChoose({ kind: "pick", optionId: v });
+          }}
+          onCancel={() => onChoose({ kind: "cancel" })}
+          footer="[↑↓] navigate  ·  [Enter] select  ·  [Esc] cancel"
+        />
+      </Box>
+    </ModalCard>
+  );
+}
+
+export const ChoiceConfirm = React.memo(ChoiceConfirmInner);

src/cli/ui/EditConfirm.tsx

@@ -0,0 +1,214 @@
+import { Box, Text, useStdout } from "ink";
+import React, { useMemo, useState } from "react";
+import { formatEditBlockDiff } from "../../code/diff-preview.js";
+import type { EditBlock } from "../../code/edit-blocks.js";
+import { ModalCard } from "./ModalCard.js";
+import { useKeystroke } from "./keystroke-context.js";
+
+/**
+ * Choice surfaced to the interceptor when the user resolves the modal:
+ *   - `apply`                → apply this edit, keep prompting on next.
+ *   - `reject`               → tell the model the user refused; do NOT
+ *                              retry the same edit.
+ *   - `apply-rest-of-turn`   → apply this edit AND every remaining edit
+ *                              this turn without further prompts. Resets
+ *                              at the next user turn.
+ *   - `flip-to-auto`         → apply this edit + persistently switch the
+ *                              session to AUTO mode (survives restart).
+ */
+export type EditReviewChoice = "apply" | "reject" | "apply-rest-of-turn" | "flip-to-auto";
+
+export interface EditConfirmProps {
+  block: EditBlock;
+  onChoose: (choice: EditReviewChoice) => void;
+}
+
+/**
+ * Overhead reserved for non-diff UI inside the modal: border (2),
+ * title (1), separator (1), file-header (1), scroll-indicator rows
+ * (up to 2), footer + margin (3), plus breathing room for the host
+ * TUI's chrome above (stats panel ≈ 4, historical live rows, prompt
+ * input ≈ 2). 18 rows absorbed before the diff gets any budget.
+ */
+const MODAL_OVERHEAD_ROWS = 18;
+
+/**
+ * Absolute floor on the diff viewport. If the terminal is absurdly
+ * short (< 26 rows total) we still show at least 8 diff lines so the
+ * modal is usable; the user scrolls more aggressively but can't end up
+ * with a zero-height viewport.
+ */
+const MIN_DIFF_ROWS = 8;
+
+/**
+ * Modal-style approval for a single model-proposed file edit.
+ *
+ * Why per-edit instead of end-of-turn batch: users reported they can't
+ * tell if the model is about to make one small change or seven sprawling
+ * ones until the turn is over. Per-edit prompts let the user intervene
+ * early — reject a bad direction before the model builds on it, or
+ * approve the first few and hit `a` to let the rest land.
+ *
+ * Diff viewport: we compute the UNCAPPED diff once, then slice to a
+ * height budget derived from terminal rows. Large diffs (100+ lines)
+ * are scrollable via j/k/↑/↓/Space/PgUp/PgDn/g/G — the user can page
+ * through the whole change before deciding, and the action footer
+ * never scrolls off the bottom. Before the scroll support a 97-line
+ * scene.ts diff truncated at "… 67 more …" which was unreviewable.
+ */
+export function EditConfirm({ block, onChoose }: EditConfirmProps) {
+  const { stdout } = useStdout();
+  const rows = stdout?.rows ?? 40;
+  const budget = Math.max(MIN_DIFF_ROWS, rows - MODAL_OVERHEAD_ROWS);
+
+  // Full diff — maxLines pushed high enough that the diff-preview
+  // renderer never inserts its own truncation marker. Context trimming
+  // (contextLines) still applies for tight scan.
+  const allLines = useMemo(
+    () => formatEditBlockDiff(block, { contextLines: 2, maxLines: 100_000, indent: "  " }),
+    [block],
+  );
+
+  const [scroll, setScroll] = useState(0);
+  const maxScroll = Math.max(0, allLines.length - budget);
+  // Clamp scroll if budget shrinks (terminal resized) after a previous
+  // keypress drove the offset past the new ceiling.
+  const effectiveScroll = Math.min(scroll, maxScroll);
+
+  useKeystroke((ev) => {
+    if (ev.paste) return;
+    const input = ev.input;
+    const key = ev;
+    // Action keys first — decision wins over scroll so a user who
+    // hammered PgDn can still hit `y` at the end without a stray
+    // extra scroll.
+    if (key.return || input === "y") {
+      onChoose("apply");
+      return;
+    }
+    if (input === "n") {
+      onChoose("reject");
+      return;
+    }
+    if (input === "a") {
+      onChoose("apply-rest-of-turn");
+      return;
+    }
+    if (input === "A") {
+      onChoose("flip-to-auto");
+      return;
+    }
+    // Scroll navigation — vim-ish (j/k) and emacs-ish (arrows) both
+    // work. Space for "next page" is the pager convention.
+    if (key.downArrow || input === "j") {
+      setScroll((s) => Math.min(maxScroll, s + 1));
+      return;
+    }
+    if (key.upArrow || input === "k") {
+      setScroll((s) => Math.max(0, s - 1));
+      return;
+    }
+    if (key.pageDown || input === " " || input === "f") {
+      setScroll((s) => Math.min(maxScroll, s + Math.max(1, budget - 2)));
+      return;
+    }
+    if (key.pageUp || input === "b") {
+      setScroll((s) => Math.max(0, s - Math.max(1, budget - 2)));
+      return;
+    }
+    if (input === "g") {
+      setScroll(0);
+      return;
+    }
+    if (input === "G") {
+      setScroll(maxScroll);
+      return;
+    }
+    // Esc falls through to the parent abort handler.
+  });
+
+  const isNew = block.search === "";
+  const removed = isNew ? 0 : (block.search.match(/\n/g)?.length ?? 0) + 1;
+  const added = block.replace === "" ? 0 : (block.replace.match(/\n/g)?.length ?? 0) + 1;
+  const tag = isNew ? "NEW" : "EDIT";
+
+  const visibleLines = allLines.slice(effectiveScroll, effectiveScroll + budget);
+  const hiddenAbove = effectiveScroll;
+  const hiddenBelow = Math.max(0, allLines.length - effectiveScroll - budget);
+  const totalLines = allLines.length;
+  const showScrollHud = hiddenAbove + hiddenBelow > 0;
+
+  const subtitleParts = [`-${removed} +${added} lines`];
+  if (showScrollHud) {
+    subtitleParts.push(
+      `viewing ${effectiveScroll + 1}-${effectiveScroll + visibleLines.length}/${totalLines}`,
+    );
+  }
+  return (
+    <ModalCard
+      accent={isNew ? "#86efac" : "#fcd34d"}
+      icon={isNew ? "✚" : "✎"}
+      title={`${tag}  ${block.path}`}
+      subtitle={subtitleParts.join("  ·  ")}
+    >
+      {hiddenAbove > 0 ? (
+        <Text
+          dimColor
+        >{`  ↑ ${hiddenAbove} line${hiddenAbove === 1 ? "" : "s"} above  (↑/k or PgUp)`}</Text>
+      ) : null}
+      <Box flexDirection="column">
+        {visibleLines.map((line, i) => {
+          const trimmed = line.trimStart();
+          const color = trimmed.startsWith("+")
+            ? "#4ade80"
+            : trimmed.startsWith("-")
+              ? "#f87171"
+              : undefined;
+          const dim = !color;
+          return (
+            <Text
+              // Stable-enough: slice only shifts by scroll; React keys only
+              // need to be unique within the current render.
+              // biome-ignore lint/suspicious/noArrayIndexKey: list is static per render
+              key={`diff-${effectiveScroll}-${i}`}
+              color={color}
+              dimColor={dim}
+            >
+              {line}
+            </Text>
+          );
+        })}
+      </Box>
+      {hiddenBelow > 0 ? (
+        <Text
+          dimColor
+        >{`  ↓ ${hiddenBelow} line${hiddenBelow === 1 ? "" : "s"} below  (↓/j or Space/PgDn)`}</Text>
+      ) : null}
+      <Box marginTop={1}>
+        <Text dimColor>
+          {"["}
+          <Text color="#67e8f9" bold>
+            y
+          </Text>
+          {"/Enter] apply  ·  ["}
+          <Text color="#67e8f9" bold>
+            n
+          </Text>
+          {"] reject  ·  ["}
+          <Text color="#67e8f9" bold>
+            a
+          </Text>
+          {"] apply rest  ·  ["}
+          <Text color="#67e8f9" bold>
+            A
+          </Text>
+          {"] flip AUTO  ·  ["}
+          <Text color="#67e8f9" bold>
+            ↑↓/Space
+          </Text>
+          {"] scroll  ·  [Esc] abort"}
+        </Text>
+      </Box>
+    </ModalCard>
+  );
+}

src/cli/ui/EventLog.tsx

@@ -1,11 +1,52 @@
-import { Box, Text } from "ink";
-import React, { useEffect, useState } from "react";
+import { Box, Text, useStdout } from "ink";
+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 type { PlanStep } from "../../tools/plan.js";
+import { PlanStateBlock } from "./PlanStateBlock.js";
+import { PlanStepList } from "./PlanStepList.js";
 import { Markdown } from "./markdown.js";
+import { COLOR, gradientCells } from "./theme.js";
+import { useElapsedSeconds, useTick } from "./ticker.js";
+import { formatDuration, summarizeToolResult } from "./tool-summary.js";
 
-export type DisplayRole = "user" | "assistant" | "tool" | "system" | "error" | "info";
+export type DisplayRole =
+  | "user"
+  | "assistant"
+  | "tool"
+  | "system"
+  | "error"
+  | "info"
+  | "warning"
+  /**
+   * A plan body pushed to scrollback when the model calls `submit_plan`.
+   * Rendered through the full markdown pipeline (not truncated), so the
+   * user reads the whole thing in the permanent Static log and the
+   * PlanConfirm modal below it stays a tight picker.
+   */
+  | "plan"
+  /**
+   * One step of an approved plan ticked off via `mark_step_complete`.
+   * Rendered as a compact `✓ step-id · title — result (N/M)` row so
+   * the user can glance at the scrollback and see how far along the
+   * execution is without scrolling through every tool call.
+   */
+  | "step-progress"
+  /**
+   * Pushed once at session startup when an existing plan was loaded
+   * from disk. Renders as a bordered box with the step list and
+   * progress so the user sees exactly where they left off — much
+   * more useful than the bare "2/5 done" info line it replaced.
+   */
+  | "plan-resumed"
+  /**
+   * Read-only snapshot of an archived (completed) plan, pushed by
+   * the `/replay` slash. Visually distinct from `plan-resumed` —
+   * dim border + ⏪ icon — so the user immediately sees this is
+   * historical, not the active plan.
+   */
+  | "plan-replay";
 
 export interface DisplayEvent {
   id: string;
@@ -16,19 +57,161 @@ export interface DisplayEvent {
   branch?: BranchSummary;
   branchProgress?: BranchProgress;
   toolName?: string;
+  /**
+   * Raw JSON args the model passed to the tool. Carried through so the
+   * web dashboard's snapshot endpoint can reconstruct the same
+   * tool-specific rendering (edit_file diff, write_file content, etc)
+   * the live SSE channel already provides. Not used by the Ink TUI
+   * directly — it shows the args via OngoingToolRow / tool-summary.
+   */
+  toolArgs?: string;
+  /**
+   * 1-based position in the session's tool-call history. Rendered as a
+   * dim `/tool N` suffix on compact rows so the user can quickly jump
+   * to the full output via the existing `/tool` slash command.
+   */
+  toolIndex?: number;
+  /** Wall-clock duration in ms between tool_start and result. */
+  durationMs?: number;
   stats?: TurnStats;
   repair?: string;
   streaming?: boolean;
+  toolCallBuild?: { name: string; chars: number; index?: number; readyCount?: number };
+  /**
+   * Populated on `step-progress` rows: the step id, optional title,
+   * completion counter, and optional notes. Rendered into the compact
+   * single-row layout — no other role reads these fields.
+   */
+  stepProgress?: {
+    stepId: string;
+    title?: string;
+    completed: number;
+    total: number;
+    notes?: string;
+  };
+  /**
+   * Populated on `plan-resumed` rows: the structured plan loaded from
+   * disk + the set of step ids the user had already completed +
+   * a relative-time hint for the header. Rendered as a bordered
+   * snapshot so the user picks back up immediately.
+   */
+  resumedPlan?: {
+    steps: PlanStep[];
+    completedStepIds: string[];
+    relativeTime: string;
+    /** Optional human-friendly title; rendered in the banner header when set. */
+    summary?: string;
+  };
+  /**
+   * Populated on `plan-replay` rows: the archived plan plus enough
+   * navigation context (index / total) for the user to know where
+   * they are in the archive history.
+   */
+  replayPlan?: {
+    summary?: string;
+    body?: string;
+    steps: PlanStep[];
+    completedStepIds: string[];
+    relativeTime: string;
+    archiveBasename: string;
+    index: number;
+    total: number;
+  };
+  /**
+   * Render a thin horizontal rule above this event. Used to mark
+   * "start of a new user turn" so long scrollbacks get visual
+   * pacing — without it, five-turn sessions read as one wall of
+   * text. Only the *first* user message in a session should leave
+   * this off; App.tsx sets it based on whether history is empty.
+   */
+  leadSeparator?: boolean;
 }
 
-export const EventRow = React.memo(function EventRow({ event }: { event: DisplayEvent }) {
+/**
+ * Reasonix visual language: every event is anchored by a geometric
+ * glyph in its role color. Together they form a consistent alphabet
+ * (◇ ◆ ▣ ▥ ▲ ✦) the eye learns fast — no text labels needed after
+ * the first couple of turns. `◈` is the brand mark, reserved for
+ * the app header.
+ */
+const ROLE_GLYPH = {
+  user: "◇",
+  assistant: "◆",
+  assistantPulse: "◇", // pulse alternate for streaming state
+  toolOk: "▣",
+  toolErr: "▥",
+  warning: "▲",
+  error: "✦",
+} as const;
+
+function RoleGlyph({
+  glyph,
+  color,
+}: {
+  glyph: string;
+  color: "cyan" | "green" | "yellow" | "red" | "magenta" | "blue";
+}) {
+  return (
+    <Text color={color} bold>
+      {glyph}
+    </Text>
+  );
+}
+
+/**
+ * Solid-background pill for tool names. Mirrors the StatsPanel's mode
+ * pills so the visual language stays consistent across the screen:
+ * status (auto/review/plan), tool name, model. Status drives the
+ * background color — yellow for ok/in-flight, red for errors — so a
+ * scrollback full of tool dispatches reads at a glance.
+ */
+function ToolPill({ label, status }: { label: string; status: "ok" | "err" }) {
+  const bg = status === "err" ? "red" : "yellow";
+  const symbol = status === "err" ? "✗" : "✓";
+  return (
+    <Text backgroundColor={bg} color="black" bold>
+      {` ${symbol} ${label} `}
+    </Text>
+  );
+}
+
+/**
+ * Pad continuation lines so wrapped multi-line text aligns under the
+ * glyph indent instead of jumping back to column 0. Header is `glyph
+ * (1 col) + "  " (2 cols)`, so subsequent lines need 3 leading spaces
+ * to land under the body's first character.
+ */
+function indentContinuationLines(text: string): string {
+  if (!text.includes("\n")) return text;
+  return text.split("\n").join("\n   ");
+}
+
+export const EventRow = React.memo(function EventRow({
+  event,
+  projectRoot,
+}: {
+  event: DisplayEvent;
+  projectRoot?: string;
+}) {
   if (event.role === "user") {
     return (
-      <Box>
-        <Text bold color="cyan">
-          you ›{" "}
-        </Text>
-        <Text>{event.text}</Text>
+      <Box flexDirection="column">
+        {event.leadSeparator ? <TurnSeparator /> : null}
+        <Box>
+          <RoleGlyph glyph={ROLE_GLYPH.user} color="cyan" />
+          <Text>{"  "}</Text>
+          <Box
+            flexDirection="column"
+            borderStyle="single"
+            borderTop={false}
+            borderRight={false}
+            borderBottom={false}
+            borderColor={COLOR.user}
+            paddingLeft={1}
+          >
+            <Text>{indentContinuationLines(event.text)}</Text>
+          </Box>
+        </Box>
       </Box>
     );
   }
@@ -37,43 +220,274 @@ export const EventRow = React.memo(function EventRow({ event }: { event: Display
     return (
       <Box flexDirection="column" marginTop={1}>
         <Box>
-          <Text bold color="green">
-            assistant
-          </Text>
+          <RoleGlyph glyph={ROLE_GLYPH.assistant} color="green" />
+          {event.stats ? (
+            <>
+              <Text>{"  "}</Text>
+              <Text backgroundColor={COLOR.assistant} color="black" bold>
+                {` ${event.stats.model.replace(/^deepseek-/, "")} `}
+              </Text>
+            </>
+          ) : null}
+        </Box>
+        <Box
+          flexDirection="column"
+          marginTop={1}
+          borderStyle="single"
+          borderTop={false}
+          borderRight={false}
+          borderBottom={false}
+          borderColor={COLOR.assistant}
+          paddingLeft={1}
+        >
+          {event.branch ? <BranchBlock branch={event.branch} /> : null}
+          {event.reasoning ? <ReasoningBlock reasoning={event.reasoning} /> : null}
+          {!isPlanStateEmpty(event.planState) ? (
+            <PlanStateBlock planState={event.planState!} />
+          ) : null}
+          {event.text ? (
+            <Markdown text={event.text} projectRoot={projectRoot} />
+          ) : (
+            <Text dimColor>(no content)</Text>
+          )}
+          {event.stats ? <StatsLine stats={event.stats} /> : null}
+          {event.repair ? <Text color={COLOR.accent}>{event.repair}</Text> : null}
         </Box>
-        {event.branch ? <BranchBlock branch={event.branch} /> : null}
-        {event.reasoning ? <ReasoningBlock reasoning={event.reasoning} /> : null}
-        {!isPlanStateEmpty(event.planState) ? (
-          <PlanStateBlock planState={event.planState!} />
-        ) : null}
-        {event.text ? <Markdown text={event.text} /> : <Text dimColor>(no content)</Text>}
-        {event.stats ? <StatsLine stats={event.stats} /> : null}
-        {event.repair ? <Text color="magenta">{event.repair}</Text> : null}
       </Box>
     );
   }
   if (event.role === "tool") {
+    // `edit_file` results get a dedicated multi-line 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.
+    const isExplicitError = event.text.startsWith("ERROR:");
+    const isEditFile =
+      (event.toolName === "edit_file" || event.toolName?.endsWith("_edit_file")) &&
+      !isExplicitError;
+    if (isEditFile) {
+      return (
+        <Box flexDirection="column" marginTop={1}>
+          <Box>
+            <ToolPill label={event.toolName ?? "?"} status="ok" />
+            <Text dimColor>{"   diff:"}</Text>
+          </Box>
+          <Box
+            flexDirection="column"
+            marginTop={1}
+            borderStyle="single"
+            borderTop={false}
+            borderRight={false}
+            borderBottom={false}
+            borderColor={COLOR.tool}
+            paddingLeft={1}
+          >
+            <EditFileDiff text={event.text} />
+          </Box>
+        </Box>
+      );
+    }
+    // Compact one-line render for everything else. The summarizer
+    // produces a tool-aware one-liner (exit code for shell, line
+    // count for read_file, error tag for failures, ...). Full content
+    // remains accessible via `/tool N`, hinted as a dim suffix.
+    const summary = summarizeToolResult(event.toolName ?? "?", event.text);
+    const status: "ok" | "err" = summary.isError ? "err" : "ok";
+    const durationLabel =
+      event.durationMs !== undefined && event.durationMs >= 100
+        ? formatDuration(event.durationMs)
+        : "";
+    const indexHint = event.toolIndex !== undefined ? `  /tool ${event.toolIndex}` : "";
     return (
-      <Box flexDirection="column" marginTop={1}>
-        <Text color="yellow">{`tool<${event.toolName ?? "?"}>  →`}</Text>
-        <Text dimColor> {truncate(event.text, 400)}</Text>
+      <Box>
+        <ToolPill label={event.toolName ?? "?"} status={status} />
+        {durationLabel ? <Text dimColor>{`  ${durationLabel}`}</Text> : null}
+        <Text dimColor>{"  "}</Text>
+        <Text color={status === "err" ? "red" : undefined} dimColor={status === "ok"}>
+          {summary.summary}
+        </Text>
+        {indexHint ? <Text dimColor>{indexHint}</Text> : null}
       </Box>
     );
   }
   if (event.role === "error") {
     return (
       <Box marginTop={1}>
-        <Text color="red" bold>
-          error{" "}
+        <Text backgroundColor="#f87171" color="black" bold>
+          {" ✦ ERROR "}
         </Text>
-        <Text color="red">{event.text}</Text>
+        <Text>{"  "}</Text>
+        <Text color="#f87171">{indentContinuationLines(event.text)}</Text>
       </Box>
     );
   }
   if (event.role === "info") {
+    // Detect tone from the text so the info row carries semantic
+    // weight: ▲/⚠ → warn, ✓ → ok, ✗/✖ → error, ↻ → reload, otherwise
+    // a neutral ▸. The leading glyph (if any) is consumed and the
+    // body renders dim.
+    const m = event.text.match(/^([▸▶▲⚠✓✗✖↻ⓘ])\s*(.*)$/s);
+    const lead = m?.[1] ?? "▸";
+    const body = m?.[2] ?? event.text;
+    let leadColor: string = COLOR.info;
+    if (lead === "▲" || lead === "⚠") leadColor = COLOR.warn;
+    else if (lead === "✓") leadColor = COLOR.ok;
+    else if (lead === "✗" || lead === "✖") leadColor = COLOR.err;
+    else if (lead === "↻") leadColor = COLOR.primary;
     return (
       <Box>
-        <Text dimColor>{event.text}</Text>
+        <Text color={leadColor} bold>
+          {lead}
+        </Text>
+        <Text> </Text>
+        <Text dimColor>{body}</Text>
+      </Box>
+    );
+  }
+  if (event.role === "plan") {
+    return (
+      <Box flexDirection="column" paddingX={1} marginY={1}>
+        <Box>
+          <Text bold color="cyan">
+            {"📋 plan proposed — pick a choice below"}
+          </Text>
+        </Box>
+        <Box marginTop={1} flexDirection="column">
+          <Markdown text={event.text} projectRoot={projectRoot} />
+        </Box>
+      </Box>
+    );
+  }
+  if (event.role === "step-progress") {
+    const sp = event.stepProgress;
+    const counter = sp && sp.total > 0 ? `${sp.completed}/${sp.total}` : "";
+    const label = sp?.title ? `${sp.stepId} · ${sp.title}` : (sp?.stepId ?? "");
+    return (
+      <Box flexDirection="column" marginTop={1}>
+        <Box>
+          <Text backgroundColor="#4ade80" color="black" bold>
+            {" ✓ STEP "}
+          </Text>
+          {counter ? (
+            <>
+              <Text>{"  "}</Text>
+              <Text color="#4ade80" bold>
+                {counter}
+              </Text>
+            </>
+          ) : null}
+          <Text>{"  "}</Text>
+          <Text color="#86efac">{label}</Text>
+        </Box>
+        {event.text ? (
+          <Box paddingLeft={2}>
+            <Text dimColor>{event.text}</Text>
+          </Box>
+        ) : null}
+        {sp?.notes ? (
+          <Box paddingLeft={2}>
+            <Text color="#fbbf24" dimColor>
+              {`note: ${sp.notes}`}
+            </Text>
+          </Box>
+        ) : null}
+      </Box>
+    );
+  }
+  if (event.role === "plan-resumed") {
+    const rp = event.resumedPlan;
+    if (!rp || rp.steps.length === 0) return null;
+    const total = rp.steps.length;
+    const done = rp.completedStepIds.length;
+    const completedSet = new Set(rp.completedStepIds);
+    const statuses = new Map(
+      rp.steps.map((s) => [
+        s.id,
+        completedSet.has(s.id) ? ("done" as const) : ("pending" as const),
+      ]),
+    );
+    // Focus the first pending step so the user immediately sees where
+    // execution will resume from. If the plan is fully done, no focus.
+    const nextStep = rp.steps.find((s) => !completedSet.has(s.id));
+    return (
+      <Box flexDirection="column" paddingX={1} marginY={1}>
+        <Box>
+          <Text backgroundColor="#67e8f9" color="black" bold>
+            {" ↻ RESUMED PLAN "}
+          </Text>
+          <Text>{"  "}</Text>
+          <Text color="#67e8f9" bold>
+            {`${done}/${total}`}
+          </Text>
+          <Text dimColor>{`  done  ·  last touched ${rp.relativeTime}`}</Text>
+        </Box>
+        {rp.summary ? (
+          <Box marginTop={1}>
+            <Text color="#67e8f9">{rp.summary}</Text>
+          </Box>
+        ) : null}
+        <Box marginTop={1} flexDirection="column">
+          <PlanStepList steps={rp.steps} statuses={statuses} focusStepId={nextStep?.id} />
+        </Box>
+      </Box>
+    );
+  }
+  if (event.role === "plan-replay") {
+    const r = event.replayPlan;
+    if (!r || r.steps.length === 0) return null;
+    const total = r.steps.length;
+    const completedSet = new Set(r.completedStepIds);
+    const done = completedSet.size;
+    const statuses = new Map(
+      r.steps.map((s) => [s.id, completedSet.has(s.id) ? ("done" as const) : ("pending" as const)]),
+    );
+    const navHint = r.total > 1 ? `  ·  ${r.index}/${r.total}` : "";
+    return (
+      <Box flexDirection="column" paddingX={1} marginY={1}>
+        <Box>
+          <Text backgroundColor="#94a3b8" color="black" bold>
+            {" ⏪ REPLAY "}
+          </Text>
+          <Text>{"  "}</Text>
+          <Text color="#94a3b8" bold>
+            {`${done}/${total}`}
+          </Text>
+          <Text dimColor>{`  done  ·  ${r.relativeTime}${navHint}`}</Text>
+        </Box>
+        {r.summary ? (
+          <Box marginTop={1}>
+            <Text color="#94a3b8">{r.summary}</Text>
+          </Box>
+        ) : null}
+        <Box>
+          <Text dimColor>{r.archiveBasename}</Text>
+        </Box>
+        {r.body ? (
+          <Box marginTop={1} flexDirection="column">
+            <Markdown text={r.body} projectRoot={projectRoot} />
+          </Box>
+        ) : null}
+        <Box marginTop={1} flexDirection="column">
+          <PlanStepList steps={r.steps} statuses={statuses} />
+        </Box>
+        <Box marginTop={1}>
+          <Text dimColor>
+            {r.total > 1
+              ? `(read-only · /replay ${r.index === 1 ? 2 : 1} for the ${r.index === 1 ? "next" : "newest"} archive)`
+              : "(read-only · this is an archived plan)"}
+          </Text>
+        </Box>
+      </Box>
+    );
+  }
+  if (event.role === "warning") {
+    return (
+      <Box>
+        <Text backgroundColor="#fbbf24" color="black" bold>
+          {" ▲ WARN "}
+        </Text>
+        <Text>{"  "}</Text>
+        <Text color="#fbbf24">{indentContinuationLines(event.text)}</Text>
       </Box>
     );
   }
@@ -84,54 +498,165 @@ export const EventRow = React.memo(function EventRow({ event }: { event: Display
   );
 });
 
-function BranchBlock({ branch }: { branch: BranchSummary }) {
-  const per = branch.uncertainties
-    .map((u, i) => {
-      const marker = i === branch.chosenIndex ? "▸" : " ";
-      const t = (branch.temperatures[i] ?? 0).toFixed(1);
-      return `${marker} #${i} T=${t} u=${u}`;
-    })
-    .join("  ");
+/**
+ * Decorative gradient rule between turns. Uses the brand gradient
+ * (teal → fuchsia) so the boundary between "old turn" and "new
+ * turn" reads as a designed accent rather than a dim minus-sign
+ * row. Static — past separators live inside Ink's `<Static>`, so
+ * animation would freeze at tick=0 anyway.
+ */
+function TurnSeparator() {
+  const { stdout } = useStdout();
+  const cols = stdout?.columns ?? 80;
+  const width = Math.max(16, cols - 2);
+  // Reserve 5 cells for `  ◆  ` in the middle. Split the remainder
+  // into two gradient halves so the brand mark sits on the seam.
+  const sideWidth = Math.max(2, Math.floor((width - 5) / 2));
+  const leftCells = gradientCells(sideWidth, "─");
+  const rightCells = gradientCells(sideWidth, "─");
   return (
-    <Box>
-      <Text color="blue">
-        {"🔀 branched "}
-        <Text bold>{branch.budget}</Text>
-        {` samples → picked #${branch.chosenIndex}   `}
-        <Text dimColor>{per}</Text>
+    <Box marginTop={1} marginBottom={1}>
+      {leftCells.map((c, i) => (
+        // biome-ignore lint/suspicious/noArrayIndexKey: fixed-width gradient row
+        <Text key={`tsep-l-${i}`} color={c.color}>
+          {c.ch}
+        </Text>
+      ))}
+      <Text color={COLOR.brand} bold>
+        {"  ◆  "}
       </Text>
-    </Box>
-  );
-}
-
-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(" · ")}`}
+      {rightCells.map((c, i) => (
+        // biome-ignore lint/suspicious/noArrayIndexKey: fixed-width gradient row
+        <Text key={`tsep-r-${i}`} color={c.color}>
+          {c.ch}
         </Text>
       ))}
     </Box>
   );
 }
 
+/**
+ * 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. The hunk header gets a magenta-bg pill —
+  // same idiom as the rest of the TUI — so it visually anchors each
+  // hunk. Body lines render with a colored gutter glyph + tinted bg
+  // for + and -, so the diff scans like a syntax-highlighted patch
+  // file rather than a wall of monochrome text.
+  const [statusHeader, hunkHeader, ...body] = lines;
+  return (
+    <Box flexDirection="column">
+      <Text dimColor>{` ${statusHeader ?? ""}`}</Text>
+      {hunkHeader !== undefined ? (
+        <Box marginTop={1}>
+          <Text backgroundColor="#c4b5fd" color="black" bold>
+            {` ${hunkHeader.trim()} `}
+          </Text>
+        </Box>
+      ) : 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)}`;
+        // Strip the leading "  " indent diff-preview adds to every
+        // body line so the gutter glyph is column 0 regardless of
+        // formatter changes upstream.
+        const stripped = line.replace(/^ {2}/, "");
+        if (stripped.startsWith("- ")) {
+          return (
+            <Box key={key}>
+              <Text color="#f87171" bold>
+                {"− "}
+              </Text>
+              <Text color="#fca5a5">{stripped.slice(2)}</Text>
+            </Box>
+          );
+        }
+        if (stripped.startsWith("+ ")) {
+          return (
+            <Box key={key}>
+              <Text color="#4ade80" bold>
+                {"+ "}
+              </Text>
+              <Text color="#86efac">{stripped.slice(2)}</Text>
+            </Box>
+          );
+        }
+        // Context line (starts with " ") or unknown — dim.
+        return (
+          <Box key={key}>
+            <Text dimColor>{"  "}</Text>
+            <Text dimColor>{stripped}</Text>
+          </Box>
+        );
+      })}
+    </Box>
+  );
+}
+
+function BranchBlock({ branch }: { branch: BranchSummary }) {
+  return (
+    <Box flexDirection="column" marginBottom={1}>
+      <Box>
+        <Text backgroundColor="#93c5fd" color="black" bold>
+          {` ⎇ BRANCH ×${branch.budget} `}
+        </Text>
+        <Text>{"  "}</Text>
+        <Text color="#93c5fd">picked </Text>
+        <Text color="#93c5fd" bold>
+          #{branch.chosenIndex}
+        </Text>
+      </Box>
+      <Box paddingLeft={2} marginTop={1}>
+        {branch.uncertainties.map((u, i) => {
+          const chosen = i === branch.chosenIndex;
+          const t = (branch.temperatures[i] ?? 0).toFixed(1);
+          return (
+            // biome-ignore lint/suspicious/noArrayIndexKey: branch index is positional and stable
+            <Text key={`b-${i}`}>
+              <Text color={chosen ? "#93c5fd" : "#475569"} bold={chosen}>
+                {chosen ? "▸ " : "  "}
+              </Text>
+              <Text color={chosen ? "#93c5fd" : "#94a3b8"} bold={chosen}>
+                {`#${i}`}
+              </Text>
+              <Text dimColor>{` T=${t}  u=${u}   `}</Text>
+            </Text>
+          );
+        })}
+      </Box>
+    </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>
-        {"↳ thinking: "}
+      <Text backgroundColor={COLOR.accent} color="black" bold>
+        {" ⋯ thinking "}
+      </Text>
+      <Text> </Text>
+      <Text color={COLOR.accent} italic dimColor>
         {preview}
       </Text>
     </Box>
@@ -144,17 +669,28 @@ 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>;
 }
 
+/**
+ * Animated role glyph for the actively-streaming assistant. Alternates
+ * ◆ ↔ ◇ every ~480ms so the user can see the model is alive even
+ * during R1's long pre-first-byte silence. Settles back to a static
+ * ◆ once the turn ends (StreamingAssistant is unmounted).
+ */
+function PulsingAssistantGlyph() {
+  const tick = useTick();
+  const on = Math.floor(tick / 4) % 2 === 0;
+  return (
+    <Text color="green" bold>
+      {on ? ROLE_GLYPH.assistant : ROLE_GLYPH.assistantPulse}
+    </Text>
+  );
+}
+
 function StreamingAssistant({ event }: { event: DisplayEvent }) {
   if (event.branchProgress) {
     const p = event.branchProgress;
@@ -163,15 +699,17 @@ function StreamingAssistant({ event }: { event: DisplayEvent }) {
       return (
         <Box flexDirection="column" marginTop={1}>
           <Box>
-            <Text bold color="green">
-              assistant{" "}
-            </Text>
+            <PulsingAssistantGlyph />
             <Text color="blue">
-              🔀 launching {p.total} parallel samples (R1 thinking in parallel)…{" "}
+              {"  ⎇ launching "}
+              {p.total}
+              {" parallel samples (R1 thinking in parallel)…  "}
             </Text>
             <Elapsed />
           </Box>
-          <Text dimColor>{"  "}spread across T=0.0/0.5/1.0 · typical wait 30-90s for reasoner</Text>
+          <Text color="yellow">
+            {"  "}spread across T=0.0/0.5/1.0 · reasoner typically takes 30-90s — this is normal
+          </Text>
         </Box>
       );
     }
@@ -179,11 +717,13 @@ function StreamingAssistant({ event }: { event: DisplayEvent }) {
     return (
       <Box flexDirection="column" marginTop={1}>
         <Box>
-          <Text bold color="green">
-            assistant{" "}
-          </Text>
+          <PulsingAssistantGlyph />
           <Text color="blue">
-            🔀 branching {p.completed}/{p.total} ({pct}%){" "}
+            {"  ⎇ branching "}
+            {p.completed}/{p.total}
+            {" ("}
+            {pct}
+            {"%)  "}
           </Text>
           <Elapsed />
         </Box>
@@ -202,34 +742,140 @@ 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;
+  // Phase pill — solid bg color per phase so the user reads
+  // "what's happening" at a glance from across the screen.
+  let pillBg: string;
+  let pillText: string;
+  let label: string;
+  if (preFirstByte) {
+    pillBg = "#fbbf24"; // amber
+    pillText = "WAITING";
+    label = "request sent · waiting for server";
+  } else if (reasoningOnly) {
+    pillBg = "#c4b5fd"; // violet
+    pillText = "THINKING";
+    label = `${event.reasoning?.length ?? 0} chars of thought`;
+  } else if (toolCallOnly) {
+    pillBg = "#f0abfc"; // fuchsia
+    pillText = "DISPATCH";
+    label = `assembling${formatToolCallIndex(toolCallBuild)} <${toolCallBuild.name}> · ${toolCallBuild.chars} chars${formatReadyTail(toolCallBuild)}`;
+  } else {
+    pillBg = "#86efac"; // green
+    pillText = "WRITING";
+    const parts: string[] = [`${event.text.length} chars`];
+    if (event.reasoning) parts.push(`after ${event.reasoning.length} reasoning`);
+    if (toolCallBuild) {
+      parts.push(
+        `tool${formatToolCallIndex(toolCallBuild)} <${toolCallBuild.name}> ${toolCallBuild.chars}c${formatReadyTail(toolCallBuild)}`,
+      );
+    }
+    label = parts.join(" · ");
+  }
   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){" "}
+        <PulsingAssistantGlyph />
+        <Text>{"  "}</Text>
+        <Pulse />
+        <Text> </Text>
+        <Text backgroundColor={pillBg} color="black" bold>
+          {` ${pillText} `}
         </Text>
+        <Text dimColor>{`  ${label}  `}</Text>
         <Elapsed />
       </Box>
       {reasoningTail ? (
-        <Text dimColor italic>
-          ↳ thinking: {reasoningTail}
-        </Text>
+        <Box paddingLeft={3}>
+          <Text color="#c4b5fd" italic dimColor>
+            ↳ {reasoningTail}
+          </Text>
+        </Box>
       ) : null}
       {tail ? (
-        <Text dimColor>▸ {tail}</Text>
-      ) : (
-        <Text dimColor italic>
-          {"  (waiting for first token…)"}
-        </Text>
-      )}
+        <Box paddingLeft={3}>
+          <Text dimColor>▸ {tail}</Text>
+        </Box>
+      ) : preFirstByte ? (
+        // Non-dim amber: first-time users misread the dim version as
+        // "app frozen". The reassurance has to be VISIBLE to do its job.
+        <Box paddingLeft={3}>
+          <Text color="#fbbf24" italic>
+            {"waiting for first byte — typical 5–60s depending on model + load"}
+          </Text>
+        </Box>
+      ) : reasoningOnly ? (
+        <Box paddingLeft={3}>
+          <Text color="#c4b5fd" italic>
+            {"R1 thinks before it speaks — body text arrives when reasoning finishes (20–90s)"}
+          </Text>
+        </Box>
+      ) : toolCallOnly ? (
+        <Box paddingLeft={3}>
+          <Text color="#f0abfc" italic>
+            {"tool-call arguments streaming — about to dispatch"}
+          </Text>
+        </Box>
+      ) : event.reasoning ? (
+        <Box paddingLeft={3}>
+          <Text color="#fbbf24" italic>
+            {"R1 still reasoning — body text or tool call arrives when thinking finishes"}
+          </Text>
+        </Box>
+      ) : 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>;
+}
+
+/**
+ * "(call 3)" suffix for the tool-call label when we have the index.
+ * Hides when the turn only has one call so the common case stays tidy.
+ */
+function formatToolCallIndex(tb: { index?: number; readyCount?: number } | undefined): string {
+  if (!tb || tb.index === undefined) return "";
+  // Only show the index when this isn't obviously the first + only call.
+  if (tb.index === 0 && (tb.readyCount ?? 0) === 0) return "";
+  return ` (call ${tb.index + 1})`;
+}
+
+/**
+ * "· 2 ready" tail that answers "how many tool calls have finished
+ * streaming so far this turn?" — user feedback for multi-file turns
+ * where the response takes 10–30s to stream. Hidden until readyCount
+ * > 0 so single-call turns aren't cluttered.
+ */
+function formatReadyTail(tb: { readyCount?: number } | undefined): string {
+  const n = tb?.readyCount ?? 0;
+  if (n <= 0) return "";
+  return ` · ${n} ready`;
+}
+
 function lastLine(s: string, maxChars: number): string {
   const flat = s.replace(/\s+/g, " ").trim();
   if (!flat) return "";
@@ -238,20 +884,26 @@ function lastLine(s: string, maxChars: number): string {
 
 function StatsLine({ stats }: { stats: TurnStats }) {
   const hit = (stats.cacheHitRatio * 100).toFixed(1);
+  const hitColor =
+    stats.cacheHitRatio >= 0.7 ? "#4ade80" : stats.cacheHitRatio >= 0.4 ? "#fcd34d" : "#f87171";
   return (
-    <Text dimColor>
-      {"  ↳ cache "}
-      {hit}
-      {"% · tokens "}
-      {stats.usage.promptTokens}
-      {"→"}
-      {stats.usage.completionTokens}
-      {" · $"}
-      {stats.cost.toFixed(6)}
-    </Text>
+    <Box marginTop={1}>
+      <Text color={hitColor} bold>
+        {`⌬ ${hit}%`}
+      </Text>
+      <Text dimColor>{"  ·  "}</Text>
+      <Text color="#94a3b8">
+        {"in "}
+        <Text color="#67e8f9" bold>
+          {stats.usage.promptTokens}
+        </Text>
+        {" → out "}
+        <Text color="#c4b5fd" bold>
+          {stats.usage.completionTokens}
+        </Text>
+      </Text>
+      <Text dimColor>{"  ·  "}</Text>
+      <Text color="#86efac" bold>{`$${stats.cost.toFixed(6)}`}</Text>
+    </Box>
   );
 }
-
-function truncate(s: string, max: number): string {
-  return s.length <= max ? s : `${s.slice(0, max)}… (+${s.length - max} chars)`;
-}

src/cli/ui/LiveRows.tsx

@@ -0,0 +1,335 @@
+import { Box, Text, useStdout } from "ink";
+// biome-ignore lint/style/useImportType: tsconfig jsx=react needs React as a runtime value (classic transform)
+import React from "react";
+import type { ApplyResult } from "../../code/edit-blocks.js";
+import type { EditMode } from "../../config.js";
+import type { JobRegistry } from "../../tools/jobs.js";
+import { useElapsedSeconds, useTick } from "./ticker.js";
+
+export const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+
+/**
+ * Transient "what's happening now" row shown during silent phases
+ * between the primary events — harvest round-trip, R1 thinking
+ * about a tool result before the next streaming delta, forced
+ * summary. Matches OngoingToolRow's visual language (braille
+ * spinner + elapsed seconds) so the user's eyes track the same
+ * spot regardless of which kind of wait it is.
+ */
+export function StatusRow({ text }: { text: string }) {
+  const tick = useTick();
+  const elapsed = useElapsedSeconds();
+  return (
+    <Box marginY={1} paddingX={1}>
+      <Text color="#c4b5fd" bold>
+        {SPINNER_FRAMES[tick % SPINNER_FRAMES.length]}
+      </Text>
+      <Text>{"  "}</Text>
+      <Text color="#c4b5fd">{text}</Text>
+      <Text dimColor>{`  ·  ${elapsed}s`}</Text>
+    </Box>
+  );
+}
+
+/**
+ * One-line bottom status bar showing the current edit mode, pending
+ * queue size (review only), an undo hint (auto only / after /apply),
+ * and the Shift+Tab nudge. Rendered immediately above PromptInput so
+ * the mode is always in peripheral vision when the user's eyes are at
+ * the prompt. Flashes briefly on mode change so Shift+Tab gives a
+ * visible acknowledgment without the user having to scan the header.
+ *
+ * The plan-mode pill takes precedence — when plan mode is on, writes
+ * are bounced regardless of edit mode, so surfacing it is more useful
+ * than the review/auto toggle.
+ */
+export function ModeStatusBar({
+  editMode,
+  pendingCount,
+  flash,
+  planMode,
+  undoArmed,
+  jobs,
+}: {
+  editMode: EditMode;
+  pendingCount: number;
+  flash: boolean;
+  planMode: boolean;
+  undoArmed: boolean;
+  jobs?: JobRegistry;
+}) {
+  // Subscribe to tick so the jobs count stays live — the registry is
+  // mutated outside React, so we need a periodic repaint to catch it.
+  // No-op when there's no registry (chat mode / tests).
+  useTick();
+  const running = jobs?.runningCount() ?? 0;
+  const jobsTag =
+    running > 0 ? (
+      <Text color="yellow" bold>{`  ·  ⏵ ${running} job${running === 1 ? "" : "s"}`}</Text>
+    ) : null;
+  // The same mode pill is already in the StatsPanel header — here we
+  // skip the pill and keep just a tight inline hint right above the
+  // input so the user has the actionable bit (what y/n/u/Shift+Tab
+  // do) without the whole tutorial.
+  if (planMode) {
+    return (
+      <ModeBarFrame>
+        <ModePill label="PLAN MODE" bg="red" flash={flash} />
+        <Text dimColor>{"   writes gated · /plan off to leave"}</Text>
+        {jobsTag}
+      </ModeBarFrame>
+    );
+  }
+  const label = editMode === "yolo" ? "YOLO" : editMode === "auto" ? "AUTO" : "REVIEW";
+  const bg = editMode === "yolo" ? "red" : editMode === "auto" ? "magenta" : "cyan";
+  const mid =
+    editMode === "yolo"
+      ? "edits + shell auto · /undo to roll back"
+      : editMode === "auto"
+        ? "edits land now · u to undo"
+        : pendingCount > 0
+          ? `${pendingCount} queued · y apply · n discard`
+          : "edits queued · y apply · n discard";
+  return (
+    <ModeBarFrame>
+      <ModePill label={label} bg={bg} flash={flash} />
+      <Text dimColor>{`   ${mid} · Shift+Tab to flip`}</Text>
+      {jobsTag}
+    </ModeBarFrame>
+  );
+}
+
+/**
+ * Wraps the bottom mode/jobs row in a dim top rule + side padding
+ * so the modeline reads as its own zone, separate from the prompt
+ * input above. Keeps the live region border-free (the rule is a
+ * single Text row, not a bordered Box) so Ink's eraseLines miscount
+ * stays out of it.
+ */
+function ModeBarFrame({ children }: { children: React.ReactNode }) {
+  const { stdout } = useStdout();
+  const cols = stdout?.columns ?? 80;
+  const ruleWidth = Math.max(20, cols - 2);
+  return (
+    <Box flexDirection="column">
+      <Box paddingX={1}>
+        <Text color="#475569" dimColor>
+          {"╌".repeat(ruleWidth)}
+        </Text>
+      </Box>
+      <Box paddingX={1}>{children}</Box>
+    </Box>
+  );
+}
+
+/**
+ * Solid-background mode badge so the bottom status bar reads at a
+ * glance like a real editor's modeline (vim/helix style) instead of a
+ * dim text label that blends into the prompt above. `flash` inverts
+ * briefly after a mode flip — the existing modeFlash signal — for a
+ * "yes, it changed" acknowledgement.
+ */
+function ModePill({
+  label,
+  bg,
+  flash,
+}: {
+  label: string;
+  bg: "magenta" | "cyan" | "red";
+  flash: boolean;
+}) {
+  return (
+    <Text backgroundColor={bg} color="white" bold inverse={flash}>
+      {` ${label} `}
+    </Text>
+  );
+}
+
+/**
+ * "Just auto-applied N edits — press u to undo" banner. Rendered below
+ * the live rows after an auto-mode edit batch lands, visible for 5s.
+ * `useTick` drives a crude live countdown so the user sees the window
+ * shrinking. State cleanup (the banner disappearing) happens in the
+ * parent's setTimeout — the component is purely display.
+ */
+export function UndoBanner({
+  banner,
+}: {
+  banner: { results: ApplyResult[]; expiresAt: number };
+}) {
+  useTick();
+  const remainingMs = Math.max(0, banner.expiresAt - Date.now());
+  const remainingSec = Math.ceil(remainingMs / 1000);
+  const ok = banner.results.filter((r) => r.status === "applied" || r.status === "created").length;
+  const total = banner.results.length;
+  const urgent = remainingSec <= 1;
+  return (
+    <Box marginY={1} paddingX={1}>
+      <Text backgroundColor="#c4b5fd" color="black" bold>
+        {` ✓ AUTO-APPLIED ${ok}/${total} `}
+      </Text>
+      <Text dimColor>{"   press "}</Text>
+      <Text backgroundColor="#67e8f9" color="black" bold>
+        {" u "}
+      </Text>
+      <Text dimColor>{" to undo   "}</Text>
+      <Text color={urgent ? "#f87171" : "#c4b5fd"} bold={urgent}>
+        {`${remainingSec}s`}
+      </Text>
+    </Box>
+  );
+}
+
+/**
+ * Live one-line indicator for a running subagent. Sits below the
+ * OngoingToolRow (the parent's tool dispatch row for `spawn_subagent`)
+ * so the user sees both layers at once: outer "spawn_subagent
+ * running…" + inner "⌬ subagent: <task> · iter N · 12.3s". Cleared
+ * when the subagent ends; a one-line summary lands in historical.
+ */
+export function SubagentRow({
+  activity,
+}: {
+  activity: { task: string; iter: number; elapsedMs: number };
+}) {
+  const tick = useTick();
+  const seconds = (activity.elapsedMs / 1000).toFixed(1);
+  return (
+    <Box paddingLeft={3}>
+      <Text color="#c4b5fd" bold>
+        {SPINNER_FRAMES[tick % SPINNER_FRAMES.length]}
+      </Text>
+      <Text>{"  "}</Text>
+      <Text backgroundColor="#c4b5fd" color="black" bold>
+        {" ⌬ subagent "}
+      </Text>
+      <Text color="#c4b5fd">{`  ${activity.task}`}</Text>
+      <Text dimColor>{`   iter ${activity.iter}  ·  ${seconds}s`}</Text>
+    </Box>
+  );
+}
+
+/**
+ * Live spinner row while a tool call is in flight. Without this the
+ * window between the model's `tool_calls` decision and the tool's
+ * result (often seconds for a multi-KB `filesystem_edit_file`) looks
+ * like the app has frozen — the streaming assistant display is
+ * already cleared and the input is disabled, so there's nothing to
+ * look at.
+ *
+ * Shows three signals: a braille spinner (liveness), an elapsed
+ * timer in seconds (so "long" has a number attached), and a
+ * per-tool summary of the most informative argument fields (path,
+ * edits count, pattern, etc.). As of 0.4.8, MCP progress frames
+ * (`notifications/progress`) land here too — bar + "n/N" when the
+ * server reports a total, free-form message when not.
+ */
+export function OngoingToolRow({
+  tool,
+  progress,
+}: {
+  tool: { name: string; args?: string };
+  progress: { progress: number; total?: number; message?: string } | null;
+}) {
+  const tick = useTick();
+  const elapsed = useElapsedSeconds();
+  const summary = summarizeToolArgs(tool.name, tool.args);
+  return (
+    <Box marginY={1} flexDirection="column" paddingX={1}>
+      <Box>
+        <Text color="#fcd34d" bold>
+          {SPINNER_FRAMES[tick % SPINNER_FRAMES.length]}
+        </Text>
+        <Text>{"  "}</Text>
+        <Text backgroundColor="#fcd34d" color="black" bold>
+          {` ⏵ ${tool.name} `}
+        </Text>
+        <Text color="#fcd34d">{" running"}</Text>
+        <Text dimColor>{`  ·  ${elapsed}s`}</Text>
+      </Box>
+      {progress ? (
+        <Box paddingLeft={3}>
+          <Text color="#67e8f9">{renderProgressLine(progress)}</Text>
+        </Box>
+      ) : null}
+      {summary ? (
+        <Box paddingLeft={3}>
+          <Text dimColor>{summary}</Text>
+        </Box>
+      ) : null}
+    </Box>
+  );
+}
+
+/**
+ * Render an MCP progress frame as a single line. When the server
+ * reports `total`, show an ASCII progress bar + "n/total pct%";
+ * otherwise just "progress" + optional message. Width is modest
+ * so the line fits even in a narrow terminal.
+ */
+function renderProgressLine(p: { progress: number; total?: number; message?: string }): string {
+  const msg = p.message ? `  ${p.message}` : "";
+  if (p.total && p.total > 0) {
+    const ratio = Math.max(0, Math.min(1, p.progress / p.total));
+    const width = 20;
+    const filled = Math.round(ratio * width);
+    const bar = "█".repeat(filled) + "░".repeat(width - filled);
+    const pct = (ratio * 100).toFixed(0);
+    return `[${bar}] ${p.progress}/${p.total} ${pct}%${msg}`;
+  }
+  return `progress: ${p.progress}${msg}`;
+}
+
+/**
+ * Turn raw JSON tool arguments into a one-line human summary. For
+ * common filesystem MCP tools we pull the actually-useful fields; for
+ * anything else we fall back to a truncated raw string so the user
+ * still sees *something* beyond the tool name.
+ *
+ * Match on suffix (e.g. `_read_file`) rather than exact name because
+ * `bridgeMcpTools({ namePrefix: "filesystem_" })` prepends the server
+ * namespace — tools arrive as `filesystem_read_file` in practice but
+ * callers might wire up anonymous too.
+ */
+function summarizeToolArgs(name: string, args?: string): string {
+  if (!args || args === "{}") return "";
+  let parsed: Record<string, unknown>;
+  try {
+    parsed = JSON.parse(args) as Record<string, unknown>;
+  } catch {
+    // Unparseable JSON — show a head slice so user at least sees
+    // what the model tried.
+    return args.length > 80 ? `${args.slice(0, 80)}…` : args;
+  }
+  const hasSuffix = (s: string) => name === s || name.endsWith(`_${s}`);
+  const path = typeof parsed.path === "string" ? parsed.path : undefined;
+  if (hasSuffix("read_file")) {
+    const head = typeof parsed.head === "number" ? `, head=${parsed.head}` : "";
+    const tail = typeof parsed.tail === "number" ? `, tail=${parsed.tail}` : "";
+    return `path: ${path ?? "?"}${head}${tail}`;
+  }
+  if (hasSuffix("write_file")) {
+    const content = typeof parsed.content === "string" ? parsed.content : "";
+    return `path: ${path ?? "?"} (${content.length} chars)`;
+  }
+  if (hasSuffix("edit_file")) {
+    const edits = Array.isArray(parsed.edits) ? parsed.edits.length : 0;
+    return `path: ${path ?? "?"} (${edits} edit${edits === 1 ? "" : "s"})`;
+  }
+  if (hasSuffix("list_directory") || hasSuffix("directory_tree")) {
+    return `path: ${path ?? "?"}`;
+  }
+  if (hasSuffix("search_files")) {
+    const pattern = typeof parsed.pattern === "string" ? parsed.pattern : "?";
+    return `path: ${path ?? "?"} · pattern: ${pattern}`;
+  }
+  if (hasSuffix("move_file")) {
+    const src = typeof parsed.source === "string" ? parsed.source : "?";
+    const dst = typeof parsed.destination === "string" ? parsed.destination : "?";
+    return `${src} → ${dst}`;
+  }
+  if (hasSuffix("get_file_info")) {
+    return `path: ${path ?? "?"}`;
+  }
+  return args.length > 80 ? `${args.slice(0, 80)}…` : args;
+}

src/cli/ui/ModalCard.tsx

@@ -0,0 +1,70 @@
+/**
+ * Shared visual frame for confirmation modals (ChoiceConfirm,
+ * PlanConfirm, ShellConfirm, EditConfirm, PlanCheckpointConfirm,
+ * PlanReviseConfirm). Each modal opens inside the live region — so
+ * we keep the frame to plain Text rules and bg-pill headers, no
+ * Ink `borderStyle` (that's the eraseLines miscount class of bug).
+ *
+ * Layout:
+ *
+ *   ▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔
+ *      [ ICON  TITLE ]    optional subtitle
+ *
+ *      <children — body of the modal>
+ *
+ *   ▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁
+ *
+ * Color drives the accent (top + bottom rules + title pill bg)
+ * so the user learns to recognize "magenta = choice", "cyan =
+ * plan", "red = shell", "yellow = edit review" by sight.
+ */
+
+import { Box, Text, useStdout } from "ink";
+// biome-ignore lint/style/useImportType: tsconfig jsx=react needs React in value scope
+import React from "react";
+
+export interface ModalCardProps {
+  /** Accent color — title pill bg + top/bottom rule color. */
+  accent: string;
+  /** Section title shown in the bg-pill header. */
+  title: string;
+  /** Optional dim subtitle next to the title. */
+  subtitle?: string;
+  /** Optional leading glyph inside the title pill (icon). */
+  icon?: string;
+  children: React.ReactNode;
+}
+
+export function ModalCard({
+  accent,
+  title,
+  subtitle,
+  icon,
+  children,
+}: ModalCardProps): React.ReactElement {
+  const { stdout } = useStdout();
+  const cols = stdout?.columns ?? 80;
+  const ruleWidth = Math.min(80, Math.max(28, cols - 4));
+  const titleText = icon ? ` ${icon}  ${title} ` : ` ${title} `;
+  return (
+    <Box flexDirection="column" paddingX={1} marginY={1}>
+      <Box>
+        <Text color={accent}>{"▔".repeat(ruleWidth)}</Text>
+      </Box>
+      <Box marginTop={1}>
+        <Text backgroundColor={accent} color="black" bold>
+          {titleText}
+        </Text>
+        {subtitle ? <Text dimColor>{`   ${subtitle}`}</Text> : null}
+      </Box>
+      <Box marginTop={1} flexDirection="column">
+        {children}
+      </Box>
+      <Box marginTop={1}>
+        <Text color={accent} dimColor>
+          {"▁".repeat(ruleWidth)}
+        </Text>
+      </Box>
+    </Box>
+  );
+}

src/cli/ui/PlanCheckpointConfirm.tsx

@@ -0,0 +1,118 @@
+/**
+ * Modal-style picker shown when `mark_step_complete` pauses the loop
+ * via `PlanCheckpointError`. Three choices:
+ *
+ *   1. Continue — push "Step X done, proceed." so the model starts
+ *      the next step on the next turn.
+ *   2. Revise   — open a feedback input; whatever the user types
+ *      becomes a synthetic "user feedback for remaining steps" message.
+ *      The model can then adjust its approach without starting the
+ *      whole plan over.
+ *   3. Stop     — push "User stopped the plan. Summarize what was
+ *      done." so the run ends cleanly rather than being abandoned.
+ *
+ * The ✓ step-progress scrollback row is pushed separately (by App.tsx
+ * at checkpoint detection time), so this modal stays a tight picker —
+ * no need to re-render the step body here.
+ */
+
+import { Box } from "ink";
+import React from "react";
+import type { PlanStep } from "../../tools/plan.js";
+import { ModalCard } from "./ModalCard.js";
+import { PlanStepList, type StepStatus } from "./PlanStepList.js";
+import { SingleSelect } from "./Select.js";
+
+export type CheckpointChoice = "continue" | "revise" | "stop";
+
+export interface PlanCheckpointConfirmProps {
+  stepId: string;
+  title?: string;
+  completed: number;
+  total: number;
+  /** Full step list from the approved plan, when available. */
+  steps?: PlanStep[];
+  /** Set of stepIds the model has marked complete so far. */
+  completedStepIds?: Set<string>;
+  onChoose: (choice: CheckpointChoice) => void;
+}
+
+function PlanCheckpointConfirmInner({
+  stepId,
+  title,
+  completed,
+  total,
+  steps,
+  completedStepIds,
+  onChoose,
+}: PlanCheckpointConfirmProps) {
+  const label = title ? `${stepId} · ${title}` : stepId;
+  const counter = total > 0 ? `${completed}/${total}` : "";
+  const isLast = total > 0 && completed >= total;
+  const statuses = buildStatusMap(steps, completedStepIds, stepId, isLast);
+  const subtitle = counter ? `${counter}  ·  ${label}` : label;
+  return (
+    <ModalCard accent="#86efac" icon="✓" title="checkpoint — step done" subtitle={subtitle}>
+      {steps && steps.length > 0 ? (
+        <Box marginBottom={1} flexDirection="column">
+          <PlanStepList steps={steps} statuses={statuses} focusStepId={stepId} />
+        </Box>
+      ) : null}
+      <SingleSelect
+        initialValue={isLast ? "stop" : "continue"}
+        items={[
+          {
+            value: "continue",
+            label: "Continue — run the next step",
+            hint: "Model resumes with the next step. Use this when the result looks right and you don't need to tweak the remaining plan.",
+          },
+          {
+            value: "revise",
+            label: "Revise — give feedback before the next step",
+            hint: "Stay paused, type guidance (scope changes, skip steps, alternative approach). The model adjusts the remaining plan based on your message.",
+          },
+          {
+            value: "stop",
+            label: "Stop — end the plan here",
+            hint: "Model summarizes what was done and ends. Remaining steps are skipped.",
+          },
+        ]}
+        onSubmit={(v) => onChoose(v as CheckpointChoice)}
+        onCancel={() => onChoose("stop")}
+        footer="[↑↓] navigate  ·  [Enter] select  ·  [Esc] stop"
+      />
+    </ModalCard>
+  );
+}
+
+export const PlanCheckpointConfirm = React.memo(PlanCheckpointConfirmInner);
+
+/**
+ * Derive a status map from the plan + completion set + current step.
+ * The currently-just-finished step always renders as "done" even if
+ * completedStepIds hasn't been flushed yet (it gets added in the
+ * same render cycle, order not guaranteed). Steps ahead of the
+ * cursor are "pending"; the next step after the current one isn't
+ * marked "running" because nothing is actually running while the
+ * picker is up — that belongs to the post-continue state.
+ */
+function buildStatusMap(
+  steps: PlanStep[] | undefined,
+  completedStepIds: Set<string> | undefined,
+  currentStepId: string,
+  isLast: boolean,
+): Map<string, StepStatus> {
+  const map = new Map<string, StepStatus>();
+  if (!steps) return map;
+  for (const step of steps) {
+    if (completedStepIds?.has(step.id) || step.id === currentStepId) {
+      map.set(step.id, "done");
+    } else {
+      map.set(step.id, "pending");
+    }
+  }
+  if (isLast) {
+    // Every step is done; leave as "done" — no "running" overlay.
+  }
+  return map;
+}

src/cli/ui/PlanConfirm.tsx

@@ -0,0 +1,100 @@
+/**
+ * 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.
+ *
+ * The plan BODY is NOT rendered inside this modal — App.tsx pushes it
+ * into the Static scrollback as a `role: "plan"` display event the
+ * moment submit_plan fires. That's a one-time markdown render into
+ * permanent history, so the user reads the full proposal above and
+ * the modal below stays a tight picker. The previous design (body
+ * rendered inside the modal with an aggressive line clamp) left users
+ * staring at "(25 more lines truncated)" and unable to approve safely.
+ */
+
+import { Box, Text } from "ink";
+import React from "react";
+import type { PlanStep } from "../../tools/plan.js";
+import { ModalCard } from "./ModalCard.js";
+import { PlanStepList } from "./PlanStepList.js";
+import { SingleSelect } from "./Select.js";
+
+export type PlanConfirmChoice = "approve" | "refine" | "cancel";
+
+export interface PlanConfirmProps {
+  plan: string;
+  steps?: PlanStep[];
+  /** Optional human-friendly title from the model — surfaced in the header. */
+  summary?: string;
+  onChoose: (choice: PlanConfirmChoice) => void;
+  projectRoot?: string;
+}
+
+function PlanConfirmInner({ plan, steps, summary, onChoose }: PlanConfirmProps) {
+  // 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 (
+    <ModalCard
+      accent="#67e8f9"
+      icon="📋"
+      title="plan proposed"
+      subtitle={summary ?? "approve / refine / cancel"}
+    >
+      {hasOpenQuestions ? (
+        <Box marginBottom={1}>
+          <Text color="#fbbf24">
+            ▲ the plan flags open questions or risks — pick{" "}
+            <Text bold>Refine / answer questions</Text> to write concrete answers before the model
+            moves on.
+          </Text>
+        </Box>
+      ) : null}
+      {steps && steps.length > 0 ? (
+        <Box marginBottom={1} flexDirection="column">
+          <PlanStepList steps={steps} />
+        </Box>
+      ) : null}
+      <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)}
+        onCancel={() => onChoose("cancel")}
+        footer="[↑↓] navigate  ·  [Enter] select  ·  [Esc] cancel"
+      />
+    </ModalCard>
+  );
+}
+
+// React.memo: parent App re-renders every 120ms while the global ticker
+// is running (even with the live status rows hidden — context changes
+// propagate). Unless props change, skip re-rendering the heavy Markdown
+// subtree. Default shallow prop compare is fine — `plan` + `onChoose`
+// identity + `projectRoot` are the only fields that change.
+export const PlanConfirm = React.memo(PlanConfirmInner);

src/cli/ui/PlanRefineInput.tsx

@@ -0,0 +1,133 @@
+/**
+ * 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 } from "ink";
+import React, { useState } from "react";
+import { ModalCard } from "./ModalCard.js";
+import { useKeystroke } from "./keystroke-context.js";
+import { useTick } from "./ticker.js";
+
+export interface PlanRefineInputProps {
+  /**
+   * Which path the user is on. approve = "implement with these last
+   * instructions"; refine = "revise the plan with this feedback";
+   * checkpoint-revise = mid-execution pause, user is tweaking the
+   * remaining plan after seeing a step's result; choice-custom = user
+   * typed an off-list answer to an ask_choice branch. Drives the
+   * header + hint text so users know what kind of message they're
+   * writing.
+   */
+  mode: "approve" | "refine" | "checkpoint-revise" | "choice-custom";
+  /** 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("");
+
+  useKeystroke((ev) => {
+    if (ev.paste) {
+      // Insert paste content as-is. Multi-line pastes flatten via
+      // newlines becoming spaces because this is a single-line input.
+      setValue((v) => v + ev.input.replace(/\r?\n/g, " "));
+      return;
+    }
+    if (ev.escape) {
+      onCancel();
+      return;
+    }
+    if (ev.return) {
+      onSubmit(value.trim());
+      return;
+    }
+    if (ev.backspace || ev.delete) {
+      setValue((v) => v.slice(0, -1));
+      return;
+    }
+    // Filter out non-printable chars; accept ordinary text + CJK.
+    if (ev.input && !ev.ctrl && !ev.meta) {
+      setValue((v) => v + ev.input);
+    }
+  });
+
+  const tick = useTick();
+  // Slow blink for the cursor block (~480 ms on/off). Same cadence
+  // as the wordmark's brand-mark pulse; reads as "input is alive".
+  const cursorOn = Math.floor(tick / 4) % 2 === 0;
+
+  const meta =
+    mode === "approve"
+      ? {
+          title: "approving — any last instructions?",
+          icon: "📋",
+          accent: "#67e8f9",
+        }
+      : mode === "checkpoint-revise"
+        ? {
+            title: "revising — what should change before the next step?",
+            icon: "✏",
+            accent: "#fbbf24",
+          }
+        : mode === "choice-custom"
+          ? {
+              title: "custom answer — type whatever fits",
+              icon: "🔀",
+              accent: "#f0abfc",
+            }
+          : {
+              title: "refining — what should the model change?",
+              icon: "✏",
+              accent: "#fbbf24",
+            };
+  const hint =
+    mode === "approve"
+      ? "Answer questions the plan raised, add constraints, or just press Enter to approve as-is."
+      : mode === "checkpoint-revise"
+        ? "Scope change, skip steps, alternative approach — the model adjusts the remaining plan."
+        : mode === "choice-custom"
+          ? "Free-form reply. The model reads it verbatim and proceeds — no need to match the listed options."
+          : "Describe what's wrong or missing, or answer questions the plan raised.";
+  const blankHint =
+    mode === "approve"
+      ? " (Enter with blank = approve without extra instructions.)"
+      : mode === "checkpoint-revise"
+        ? " (Enter with blank = continue with the current plan.)"
+        : mode === "choice-custom"
+          ? " (Enter with blank = ask the model what you actually want.)"
+          : " (Enter with blank = ask the model to list concrete questions.)";
+
+  return (
+    <ModalCard accent={meta.accent} icon={meta.icon} title={meta.title}>
+      <Box marginBottom={1}>
+        <Text dimColor>
+          {hint} Enter to send · Esc to return to the picker.
+          {value === "" ? blankHint : ""}
+        </Text>
+      </Box>
+      <Box>
+        <Text color={meta.accent} bold>
+          {"› "}
+        </Text>
+        <Text>{value}</Text>
+        <Text color={meta.accent} bold>
+          {cursorOn ? "▍" : " "}
+        </Text>
+      </Box>
+    </ModalCard>
+  );
+}

src/cli/ui/PlanReviseConfirm.tsx

@@ -0,0 +1,141 @@
+/**
+ * Modal shown when the model proposes a plan revision via
+ * `revise_plan`. Renders a step-level diff between the old remaining
+ * tail and the new proposed tail:
+ *
+ *    ●● ✓ step-2 · Wire middleware           (kept, dim)
+ *  − ●●● ✗ step-3 · Migrate session cookies  (removed, red)
+ *  + ●●  ▶ step-3 · Skip cookie migration    (added, green)
+ *  + ●●  ▶ step-4 · Update cookie tests      (added, green)
+ *
+ * Two buttons: Accept / Reject. Accept replaces the in-memory plan's
+ * remaining steps with the new ones; Reject leaves the original plan
+ * intact and lets the model continue. The picker's border is amber
+ * to distinguish from the green checkpoint picker — revisions are a
+ * different decision point, deserve a different visual lane.
+ */
+
+import { Box, Text } from "ink";
+import React from "react";
+import type { PlanStep } from "../../tools/plan.js";
+import { ModalCard } from "./ModalCard.js";
+import { SingleSelect } from "./Select.js";
+
+export type ReviseChoice = "accept" | "reject";
+
+export interface PlanReviseConfirmProps {
+  reason: string;
+  /** Remaining steps from the current plan (before this revision). */
+  oldRemaining: PlanStep[];
+  /** Remaining steps the model is proposing as a replacement. */
+  newRemaining: PlanStep[];
+  /** Optional updated plan summary. */
+  summary?: string;
+  onChoose: (choice: ReviseChoice) => void;
+}
+
+interface DiffRow {
+  kind: "kept" | "removed" | "added";
+  step: PlanStep;
+}
+
+function computeDiff(oldSteps: PlanStep[], newSteps: PlanStep[]): DiffRow[] {
+  const oldIds = new Set(oldSteps.map((s) => s.id));
+  const newIds = new Set(newSteps.map((s) => s.id));
+  const rows: DiffRow[] = [];
+  // Show removed (in old, not in new) first — preserve original order.
+  for (const s of oldSteps) {
+    if (!newIds.has(s.id)) rows.push({ kind: "removed", step: s });
+  }
+  // Then walk new list. Steps in both lists render as kept; new-only as added.
+  for (const s of newSteps) {
+    rows.push({ kind: oldIds.has(s.id) ? "kept" : "added", step: s });
+  }
+  return rows;
+}
+
+function riskDots(risk: PlanStep["risk"]): { dots: string; color: string } {
+  switch (risk) {
+    case "high":
+      return { dots: "●●●", color: "#f87171" };
+    case "med":
+      return { dots: "●● ", color: "#fbbf24" };
+    case "low":
+      return { dots: "●  ", color: "#4ade80" };
+    default:
+      return { dots: "   ", color: "#94a3b8" };
+  }
+}
+
+function PlanReviseConfirmInner({
+  reason,
+  oldRemaining,
+  newRemaining,
+  summary,
+  onChoose,
+}: PlanReviseConfirmProps) {
+  const rows = computeDiff(oldRemaining, newRemaining);
+  const removedCount = rows.filter((r) => r.kind === "removed").length;
+  const addedCount = rows.filter((r) => r.kind === "added").length;
+  const keptCount = rows.filter((r) => r.kind === "kept").length;
+  return (
+    <ModalCard
+      accent="#fbbf24"
+      icon="✏"
+      title="plan revision proposed"
+      subtitle={`−${removedCount}  +${addedCount}  ·  ${keptCount} kept`}
+    >
+      <Box marginBottom={1}>
+        <Text>{reason}</Text>
+      </Box>
+      {summary ? (
+        <Box marginBottom={1}>
+          <Text dimColor>{`updated summary: ${summary}`}</Text>
+        </Box>
+      ) : null}
+      <Box marginBottom={1} flexDirection="column">
+        {rows.map((row) => {
+          const risk = riskDots(row.step.risk);
+          const prefix = row.kind === "removed" ? "−" : row.kind === "added" ? "+" : " ";
+          const prefixColor =
+            row.kind === "removed" ? "#f87171" : row.kind === "added" ? "#4ade80" : "#94a3b8";
+          const dim = row.kind === "kept";
+          const strike = row.kind === "removed";
+          return (
+            <Box key={`${row.kind}-${row.step.id}`}>
+              <Text color={prefixColor} bold>
+                {`${prefix} `}
+              </Text>
+              <Text color={risk.color} bold dimColor={dim}>
+                {risk.dots}
+              </Text>
+              <Text dimColor={dim} strikethrough={strike}>
+                {` ${row.step.id} · ${row.step.title}`}
+              </Text>
+            </Box>
+          );
+        })}
+      </Box>
+      <SingleSelect
+        initialValue="accept"
+        items={[
+          {
+            value: "accept",
+            label: "Accept revision — apply the new step list",
+            hint: "Replaces the remaining plan with the proposed steps. Done steps are untouched.",
+          },
+          {
+            value: "reject",
+            label: "Reject — keep the original plan",
+            hint: "Drops the proposal. Model continues with the original remaining steps.",
+          },
+        ]}
+        onSubmit={(v) => onChoose(v as ReviseChoice)}
+        onCancel={() => onChoose("reject")}
+        footer="[↑↓] navigate  ·  [Enter] select  ·  [Esc] reject"
+      />
+    </ModalCard>
+  );
+}
+
+export const PlanReviseConfirm = React.memo(PlanReviseConfirmInner);

src/cli/ui/PlanStateBlock.tsx

@@ -0,0 +1,47 @@
+/**
+ * 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 = string;
+
+export function PlanStateBlock({ planState }: { planState: TypedPlanState }) {
+  const fields: Array<[string, string[], FieldColor, boolean]> = [];
+  if (planState.subgoals.length) fields.push(["subgoals", planState.subgoals, "#67e8f9", false]);
+  if (planState.hypotheses.length)
+    fields.push(["hypotheses", planState.hypotheses, "#86efac", false]);
+  if (planState.uncertainties.length)
+    fields.push(["uncertainties", planState.uncertainties, "#fcd34d", false]);
+  if (planState.rejectedPaths.length)
+    fields.push(["rejected", planState.rejectedPaths, "#94a3b8", true]);
+  if (fields.length === 0) return null;
+
+  return (
+    <Box flexDirection="column" marginBottom={1}>
+      {fields.map(([label, items, color, dim]) => (
+        <Box key={label}>
+          <Text backgroundColor={color} color="black" bold dimColor={dim}>
+            {` ${label} ${items.length} `}
+          </Text>
+          <Text>{"  "}</Text>
+          <Text dimColor={dim}>{items.join(" · ")}</Text>
+        </Box>
+      ))}
+    </Box>
+  );
+}

src/cli/ui/PlanStepList.tsx

@@ -0,0 +1,159 @@
+/**
+ * Shared compact renderer for a plan's structured step list. Used by
+ * PlanConfirm (on approval) and PlanCheckpointConfirm (mid-execution)
+ * so the user always sees the same visual representation of the plan.
+ *
+ * Layout per step:
+ *
+ *    ● ✓ step-1 · Extract tokens into a module
+ *    ●●▶ step-2 · Migrate session cookies
+ *    ●●●  step-3 · Update tests
+ *
+ * The risk gutter (1–3 dots, green/yellow/red) is the signal the user
+ * learns to scan: high-risk steps are what deserves review before
+ * approve; low-risk is noise.
+ */
+
+import { Box, Text } from "ink";
+import React from "react";
+import type { PlanStep, PlanStepRisk } from "../../tools/plan.js";
+
+export type StepStatus = "pending" | "running" | "done" | "skipped";
+
+export interface PlanStepListProps {
+  steps: PlanStep[];
+  /**
+   * Map of stepId → status. Missing ids default to "pending" so a
+   * plan just submitted (no completions yet) renders cleanly.
+   */
+  statuses?: Map<string, StepStatus> | Record<string, StepStatus>;
+  /**
+   * Optional current step — rendered with a `›` gutter mark so the
+   * user sees which one just completed / is about to run.
+   */
+  focusStepId?: string;
+}
+
+function riskDots(risk: PlanStep["risk"]): {
+  dots: string;
+  color: "green" | "yellow" | "red" | "gray";
+} {
+  switch (risk) {
+    case "high":
+      return { dots: "●●●", color: "red" };
+    case "med":
+      return { dots: "●● ", color: "yellow" };
+    case "low":
+      return { dots: "●  ", color: "green" };
+    default:
+      return { dots: "   ", color: "gray" };
+  }
+}
+
+function getStatus(stepId: string, statuses: PlanStepListProps["statuses"]): StepStatus {
+  if (!statuses) return "pending";
+  if (statuses instanceof Map) {
+    return statuses.get(stepId) ?? "pending";
+  }
+  return statuses[stepId] ?? "pending";
+}
+
+function PlanStepListInner({ steps, statuses, focusStepId }: PlanStepListProps) {
+  if (steps.length === 0) return null;
+  const hasAnyRisk = steps.some((s) => s.risk !== undefined);
+  const doneCount = Array.from({ length: steps.length }, (_, i) =>
+    getStatus(steps[i]!.id, statuses),
+  ).filter((s) => s === "done").length;
+  const pct = Math.round((doneCount / steps.length) * 100);
+
+  return (
+    <Box flexDirection="column">
+      <Box>
+        <Text dimColor>
+          {`${steps.length} step${steps.length === 1 ? "" : "s"}`}
+          {doneCount > 0 ? ` · ${doneCount}/${steps.length} done (${pct}%)` : ""}
+          {hasAnyRisk ? " · risk: " : ""}
+        </Text>
+        {hasAnyRisk ? <RiskLegend /> : null}
+      </Box>
+      <Box flexDirection="column" marginTop={1}>
+        {steps.map((step) => {
+          const status = getStatus(step.id, statuses);
+          const focus = focusStepId === step.id;
+          const risk = riskDots(step.risk);
+          const titleDim = status === "done" || status === "skipped";
+          return (
+            <Box key={step.id}>
+              <Text color={focus ? "#67e8f9" : "gray"} bold={focus}>
+                {focus ? "▸ " : "  "}
+              </Text>
+              <Text color={risk.color} bold>
+                {risk.dots}
+              </Text>
+              <Text> </Text>
+              <StatusBadge status={status} />
+              <Text> </Text>
+              <Text dimColor={titleDim} bold={focus}>
+                {`${step.id} · ${step.title}`}
+              </Text>
+            </Box>
+          );
+        })}
+      </Box>
+    </Box>
+  );
+}
+
+/**
+ * Status pill — solid-bg badge per step state. Reads at a glance
+ * better than a glyph + color text: ` DONE `, ` RUN `, ` SKIP `,
+ * ` PEND `. The label widths are normalized so the column under
+ * the badge stays aligned even when statuses mix.
+ */
+function StatusBadge({ status }: { status: StepStatus }) {
+  switch (status) {
+    case "done":
+      return (
+        <Text backgroundColor="#4ade80" color="black" bold>
+          {" ✓ DONE "}
+        </Text>
+      );
+    case "running":
+      return (
+        <Text backgroundColor="#67e8f9" color="black" bold>
+          {" ▶ RUN  "}
+        </Text>
+      );
+    case "skipped":
+      return (
+        <Text backgroundColor="#94a3b8" color="black" bold>
+          {" — SKIP "}
+        </Text>
+      );
+    default:
+      return (
+        <Text color="#94a3b8" dimColor>
+          {" ☐ PEND "}
+        </Text>
+      );
+  }
+}
+
+function RiskLegend() {
+  return (
+    <Box>
+      <Text color="green">●</Text>
+      <Text dimColor> low </Text>
+      <Text color="yellow">●●</Text>
+      <Text dimColor> med </Text>
+      <Text color="red">●●●</Text>
+      <Text dimColor> high</Text>
+    </Box>
+  );
+}
+
+export const PlanStepList = React.memo(PlanStepListInner);
+
+export function riskOf(step: PlanStep): PlanStepRisk | undefined {
+  return step.risk;
+}

src/cli/ui/PromptInput.tsx

@@ -1,6 +1,52 @@
-import { Box, Text } from "ink";
-import TextInput from "ink-text-input";
-import React from "react";
+import { Box, Text, useStdout } from "ink";
+// biome-ignore lint/style/useImportType: tsconfig jsx=react needs React as a runtime value (classic transform compiles JSX to React.createElement)
+import React, { useRef, useState } from "react";
+import { useKeystroke } from "./keystroke-context.js";
+import { type MultilineKey, lineAndColumn, processMultilineKey } from "./multiline-keys.js";
+import {
+  PASTE_SENTINEL_RANGE,
+  type PasteEntry,
+  encodePasteSentinel,
+  expandPasteSentinels,
+  listPasteIdsInBuffer,
+  makePasteEntry,
+} from "./paste-sentinels.js";
+import { type Segment, buildViewport, stringCells } from "./prompt-viewport.js";
+import { GRADIENT } from "./theme.js";
+
+/**
+ * Visual anchor: a left vertical rule (▎ + space) running down every
+ * line of the input. Colored with the accent color so disabled state
+ * dims it; gives the input area a clear "you type here" boundary
+ * without using bordered Boxes (those amplified Ink's eraseLines
+ * miscount on Windows). Length is fixed at 2 so the prefix-cell math
+ * stays trivial.
+ */
+const BAR = "▎ ";
+
+/**
+ * Prompt input v2 — no Ink useInput, no Yoga text wrapping, no
+ * cursor blink. Replaces the bordered-Box / multi-Text approach
+ * that was driving the Windows ghost-row regressions.
+ *
+ * Pipeline:
+ *   - Subscribes to the global keystroke bus (which is fed by our
+ *     own raw stdin parser, NOT Ink's parse-keypress).
+ *   - Pure events: `paste` events go to the paste registry; everything
+ *     else flows through `processMultilineKey` (the existing reducer
+ *     with all the cursor / submit / history-recall semantics).
+ *   - Render: one logical line per <Box> row. Each row renders as
+ *     EXACTLY one visual row — content longer than the visible cell
+ *     budget is clipped via `buildViewport`, with `‹` / `›` markers
+ *     where content is hidden. The cursor moves the viewport so it
+ *     stays visible.
+ *
+ * Cursor blinks at ~480 ms half-period. The ticker that drives the
+ * blink also flows the left-bar gradient and the wordmark, so
+ * we're already paying for re-render every tick — the cursor blink
+ * is free on top of that. Disabled state freezes the cursor solid
+ * so the disabled prompt doesn't compete with the active spinner.
+ */
 
 export interface PromptInputProps {
   value: string;
@@ -8,36 +54,507 @@ export interface PromptInputProps {
   onSubmit: (v: string) => void;
   disabled?: boolean;
   placeholder?: string;
+  /**
+   * History recall. Fired when ↑/↓ hits a buffer boundary (empty
+   * buffer, or cursor already at the first/last line of a multi-line
+   * buffer). Parent walks its prompt history and swaps the value via
+   * `onChange`. Absent → keys are consumed silently.
+   */
+  onHistoryPrev?: () => void;
+  onHistoryNext?: () => void;
 }
 
-/**
- * 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.
- */
 export function PromptInput({
   value,
   onChange,
   onSubmit,
   disabled,
   placeholder,
+  onHistoryPrev,
+  onHistoryNext,
 }: PromptInputProps) {
+  const [cursor, setCursor] = useState(value.length);
+
+  // Paste registry — keyed by sentinel id, holds original content.
+  const pastesRef = useRef<Map<number, PasteEntry>>(new Map());
+  const nextPasteIdRef = useRef<number>(0);
+
+  // Track external value replacement (history recall, slash completion).
+  // When the parent swaps `value` we snap cursor to end.
+  const lastLocalValueRef = useRef(value);
+  if (value !== lastLocalValueRef.current) {
+    lastLocalValueRef.current = value;
+    if (cursor !== value.length) setCursor(value.length);
+  }
+
+  /**
+   * Register one paste blob and insert its sentinel at the current
+   * cursor. Used both by `paste` events from the stdin reader (the
+   * normal path on terminals that support DECSET 2004) and by the
+   * fallback path inside `processMultilineKey` for chunks that
+   * arrived without bracketed-paste markers.
+   */
+  const registerPaste = (content: string) => {
+    const v = lastLocalValueRef.current;
+    const c = cursor;
+    const id = nextPasteIdRef.current % PASTE_SENTINEL_RANGE;
+    nextPasteIdRef.current = id + 1;
+    pastesRef.current.set(id, makePasteEntry(id, content));
+    const sentinel = encodePasteSentinel(id);
+    const next = v.slice(0, c) + sentinel + v.slice(c);
+    lastLocalValueRef.current = next;
+    onChange(next);
+    setCursor(c + 1);
+  };
+
+  useKeystroke((ev) => {
+    if (disabled) return;
+    if (ev.paste) {
+      // Bracketed-paste content delivered by the stdin reader.
+      // Insert as one sentinel regardless of length.
+      if (ev.input.length > 0) registerPaste(ev.input);
+      return;
+    }
+    const key: MultilineKey = {
+      input: ev.input,
+      return: ev.return,
+      shift: ev.shift,
+      ctrl: ev.ctrl,
+      meta: ev.meta,
+      backspace: ev.backspace,
+      delete: ev.delete,
+      tab: ev.tab,
+      upArrow: ev.upArrow,
+      downArrow: ev.downArrow,
+      leftArrow: ev.leftArrow,
+      rightArrow: ev.rightArrow,
+      escape: ev.escape,
+      pageUp: ev.pageUp,
+      pageDown: ev.pageDown,
+    };
+    const action = processMultilineKey(value, cursor, key);
+    if (action.pasteRequest) {
+      registerPaste(action.pasteRequest.content);
+      return;
+    }
+    if (action.next !== null) {
+      lastLocalValueRef.current = action.next;
+      onChange(action.next);
+    }
+    if (action.cursor !== null) {
+      setCursor(action.cursor);
+    }
+    if (action.submit) {
+      const raw = action.submitValue ?? value;
+      const expanded = expandPasteSentinels(raw, pastesRef.current);
+      // GC unreachable paste entries — anything backspace'd out of
+      // the buffer before submit. Keeps the registry from growing
+      // unbounded across many turns.
+      const reachable = new Set(listPasteIdsInBuffer(raw));
+      for (const id of pastesRef.current.keys()) {
+        if (!reachable.has(id)) pastesRef.current.delete(id);
+      }
+      onSubmit(expanded);
+    }
+    if (action.historyHandoff === "prev") onHistoryPrev?.();
+    if (action.historyHandoff === "next") onHistoryNext?.();
+  }, !disabled);
+
+  // ── Render ──────────────────────────────────────────────────────
+
+  const { stdout } = useStdout();
+  const cols = stdout?.columns ?? 80;
+  const narrow = cols <= 90;
+  const promptBody = narrow ? "› " : "you › ";
+  const promptPrefix = BAR + promptBody;
+  const continuationIndent = BAR + " ".repeat(promptBody.length);
+  const prefixCells = promptPrefix.length;
+  // Reserve 2 cells for the surrounding `paddingX={1}` plus 1 cell
+  // for the cursor block when at end-of-line. Net visible budget per
+  // line.
+  const visibleCells = Math.max(8, cols - prefixCells - 3);
+
+  const placeholderActive = narrow
+    ? "type a message, or /command"
+    : "type a message, or /command  ·  [Ctrl+J] newline  ·  [Ctrl+P/N] history";
   const effectivePlaceholder = disabled
     ? (placeholder ?? "…waiting for response…")
-    : (placeholder ?? "type a message, or /command");
+    : (placeholder ?? placeholderActive);
+
+  const lines = value.length > 0 ? value.split("\n") : [""];
+  const accentColor = disabled ? "gray" : "cyan";
+  // Static bar + static cursor. Earlier versions flowed the bar
+  // gradient and blinked the cursor via the global ticker; both
+  // drove per-tick re-renders that interleaved badly with terminal
+  // resize (Ink's eraseLines miscounts logical vs visual rows on
+  // wrap, ghost frames stack). The bar still gets a gradient — just
+  // a fixed sweep based on row index, no time component.
+  const barColorAt = (rowIdx: number): string =>
+    disabled ? "gray" : GRADIENT[((rowIdx % GRADIENT.length) + GRADIENT.length) % GRADIENT.length]!;
+  const cursorVisible = true;
+  const { line: cursorLine, col: cursorCol } = lineAndColumn(value, cursor);
+
+  // Big-buffer mitigation: if the buffer has many logical lines,
+  // collapse middle rows so Ink isn't redrawing 500+ rows per
+  // keystroke.
+  const renderItems = collapseLinesForDisplay(lines, cursorLine);
+  const showHugeBufferHints = lines.length > 20;
+
   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 flexDirection="column" paddingX={1}>
+      {renderItems.map((item, renderIdx) => {
+        if (item.kind === "skip") {
+          return (
+            // biome-ignore lint/suspicious/noArrayIndexKey: stable — collapse markers derive from a fixed sliding window
+            <Box key={`skip-${renderIdx}`}>
+              <Text color={barColorAt(renderIdx)}>{BAR}</Text>
+              <Text dimColor>{continuationIndent.slice(BAR.length)}</Text>
+              <Text dimColor>
+                {`[… ${item.linesHidden} line${item.linesHidden === 1 ? "" : "s"} hidden — full content kept, submitted on Enter …]`}
+              </Text>
+            </Box>
+          );
+        }
+        const i = item.originalIndex;
+        const line = item.line;
+        const isFirst = i === 0;
+        const isCursorLine = i === cursorLine;
+        const showPlaceholder = isFirst && value.length === 0;
+        return (
+          <PromptLine
+            key={`ln-${i}`}
+            line={line}
+            isFirst={isFirst}
+            isCursorLine={isCursorLine && !disabled}
+            cursorCol={isCursorLine ? cursorCol : null}
+            cursorVisible={cursorVisible}
+            showPlaceholder={showPlaceholder}
+            placeholderText={effectivePlaceholder}
+            promptPrefix={promptPrefix}
+            continuationIndent={continuationIndent}
+            visibleCells={visibleCells}
+            accentColor={accentColor}
+            barColor={barColorAt(i)}
+            pastes={pastesRef.current}
+            disabled={disabled === true}
+          />
+        );
+      })}
+      {showHugeBufferHints && !disabled ? (
+        <Box>
+          <Text color={barColorAt(0)}>{BAR}</Text>
+          <Text dimColor>{continuationIndent.slice(BAR.length)}</Text>
+          <Text dimColor>
+            {`[${lines.length} lines · PageUp/PageDown jump to top/bottom · Ctrl+U clear · Ctrl+W del word]`}
+          </Text>
+        </Box>
+      ) : null}
+      {!disabled && !narrow && value.length > 0 && !value.includes("\n") ? (
+        <Box>
+          <Text color={barColorAt(0)}>{BAR}</Text>
+          <Text dimColor>{continuationIndent.slice(BAR.length)}</Text>
+          <Text dimColor>
+            [Ctrl+J] newline · [Enter] submit · ends with \ for line continuation
+          </Text>
+        </Box>
+      ) : null}
+      {disabled ? (
+        <Box>
+          <Text color={barColorAt(0)}>{BAR}</Text>
+          <Text dimColor>{continuationIndent.slice(BAR.length)}</Text>
+          <Text dimColor>[Esc] to stop</Text>
+        </Box>
+      ) : null}
     </Box>
   );
 }
+
+// ── PromptLine ────────────────────────────────────────────────────
+
+interface PromptLineProps {
+  line: string;
+  isFirst: boolean;
+  isCursorLine: boolean;
+  cursorCol: number | null;
+  /** True when the cursor block / inverse char should be drawn this tick. */
+  cursorVisible: boolean;
+  showPlaceholder: boolean;
+  placeholderText: string;
+  promptPrefix: string;
+  continuationIndent: string;
+  visibleCells: number;
+  accentColor: "cyan" | "gray";
+  /** Animated gradient color for the leading ▎ bar. Differs per row + tick. */
+  barColor: string;
+  pastes: ReadonlyMap<number, PasteEntry>;
+  disabled: boolean;
+}
+
+function PromptLine({
+  line,
+  isFirst,
+  isCursorLine,
+  cursorCol,
+  cursorVisible,
+  showPlaceholder,
+  placeholderText,
+  promptPrefix,
+  continuationIndent,
+  visibleCells,
+  accentColor,
+  barColor,
+  pastes,
+  disabled,
+}: PromptLineProps) {
+  // The leading BAR cells of every prefix/continuation are the left
+  // anchor bar — render them as a separate span colored by the
+  // animated gradient so the bar appears to flow vertically.
+  const barText = promptPrefix.slice(0, BAR.length);
+  const bodyPrefix = promptPrefix.slice(BAR.length);
+  const bodyContinuation = continuationIndent.slice(BAR.length);
+  if (showPlaceholder) {
+    return (
+      <Box>
+        <Text color={barColor}>{barText}</Text>
+        <Text bold color={accentColor}>
+          {bodyPrefix}
+        </Text>
+        {!disabled ? <Text color={accentColor}>{cursorVisible ? "▌" : " "}</Text> : null}
+        <Text dimColor>{placeholderText}</Text>
+      </Box>
+    );
+  }
+
+  const viewport = buildViewport(line, isCursorLine ? cursorCol : null, visibleCells, pastes);
+
+  // Render: prefix + (left marker?) + segments-with-cursor + (right marker?)
+  return (
+    <Box>
+      <Text color={barColor}>{barText}</Text>
+      {isFirst ? (
+        <Text bold color={accentColor}>
+          {bodyPrefix}
+        </Text>
+      ) : (
+        <Text dimColor>{bodyContinuation}</Text>
+      )}
+      {viewport.hiddenLeft ? (
+        <Text color="gray" dimColor>
+          ‹
+        </Text>
+      ) : null}
+      <ViewportContent
+        segments={viewport.segments}
+        cursorCell={isCursorLine ? viewport.cursorCell : null}
+        accentColor={accentColor}
+        cursorVisible={cursorVisible}
+      />
+      {viewport.hiddenRight ? (
+        <Text color="gray" dimColor>
+          ›
+        </Text>
+      ) : null}
+    </Box>
+  );
+}
+
+// ── ViewportContent ────────────────────────────────────────────────
+
+/**
+ * Render a viewport's segments with a cursor block at `cursorCell`.
+ * Walks segments in order; the cursor splits at most one segment
+ * (the one containing the cursor cell), producing an inverted char
+ * at that position.
+ *
+ * End-of-line cursor (cursorCell points past the last cell of the
+ * last segment): emit a trailing block.
+ */
+function ViewportContent({
+  segments,
+  cursorCell,
+  accentColor,
+  cursorVisible,
+}: {
+  segments: Segment[];
+  cursorCell: number | null;
+  accentColor: "cyan" | "gray";
+  cursorVisible: boolean;
+}) {
+  // No cursor on this line — straight render.
+  if (cursorCell === null) {
+    return <>{segments.map((seg, i) => renderSegment(seg, i, false))}</>;
+  }
+
+  // Walk segments tallying cells; once we reach `cursorCell`, split
+  // the segment to insert the cursor block.
+  const out: React.ReactNode[] = [];
+  let cells = 0;
+  let placed = false;
+  for (let i = 0; i < segments.length; i++) {
+    const seg = segments[i]!;
+    const segCells = segmentCells(seg);
+    if (placed) {
+      out.push(renderSegment(seg, i, false));
+      continue;
+    }
+    if (cursorCell >= cells + segCells) {
+      // Cursor isn't in this segment.
+      out.push(renderSegment(seg, i, false));
+      cells += segCells;
+      continue;
+    }
+    // Cursor lands inside this segment.
+    if (seg.kind === "paste") {
+      // The cursor is "on" the paste sentinel — render the paste
+      // block inversed so the user sees they're at it. Inverse
+      // toggles with the blink so the paste sentinel stays
+      // legible during the cursor's "off" half-cycle.
+      out.push(
+        <Text key={`p-${i}-cursor`} color="magenta" bold inverse={cursorVisible}>
+          {seg.label}
+        </Text>,
+      );
+      placed = true;
+      cells += segCells;
+      continue;
+    }
+    // text segment — split before/at-cursor/after by cell offset.
+    const offsetIntoSeg = cursorCell - cells;
+    const split = splitTextByCells(seg.text, offsetIntoSeg);
+    if (split.before.length > 0) {
+      out.push(<Text key={`t-${i}-b`}>{split.before}</Text>);
+    }
+    if (split.atCursor.length > 0) {
+      out.push(
+        <Text key={`t-${i}-c`} inverse={cursorVisible} color={accentColor}>
+          {split.atCursor}
+        </Text>,
+      );
+    } else {
+      // Cursor sits past the segment's last char (end-of-text in this
+      // segment). Render block here, blinking with the tick.
+      out.push(
+        <Text key={`t-${i}-c-eol`} color={accentColor}>
+          {cursorVisible ? "▌" : " "}
+        </Text>,
+      );
+    }
+    if (split.after.length > 0) {
+      out.push(<Text key={`t-${i}-a`}>{split.after}</Text>);
+    }
+    placed = true;
+    cells += segCells;
+  }
+
+  // Cursor sits past every segment (end of line).
+  if (!placed) {
+    out.push(
+      <Text key="cursor-eol" color={accentColor}>
+        {cursorVisible ? "▌" : " "}
+      </Text>,
+    );
+  }
+
+  return <>{out}</>;
+}
+
+function segmentCells(seg: Segment): number {
+  if (seg.kind === "paste") return seg.label.length;
+  return stringCells(seg.text);
+}
+
+/**
+ * Split a text string at a cell offset, returning the chars before
+ * the offset, the char AT the offset (the cursor block highlights
+ * it), and the chars after. A wide char that straddles the offset
+ * is treated as the cursor's char.
+ */
+function splitTextByCells(
+  text: string,
+  cellOffset: number,
+): { before: string; atCursor: string; after: string } {
+  let cells = 0;
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i]!;
+    const cw = charCellsForText(ch);
+    if (cells === cellOffset) {
+      return { before: text.slice(0, i), atCursor: ch, after: text.slice(i + 1) };
+    }
+    if (cells + cw > cellOffset) {
+      // The wide char straddles the offset — show it as the cursor char.
+      return { before: text.slice(0, i), atCursor: ch, after: text.slice(i + 1) };
+    }
+    cells += cw;
+  }
+  // Cursor at end of text.
+  return { before: text, atCursor: "", after: "" };
+}
+
+/**
+ * Local cell-counting helper — duplicates `charCells` from
+ * prompt-viewport but inlined to avoid a back-and-forth import (this
+ * function is hot per-keystroke). Keep in sync.
+ */
+function charCellsForText(ch: string): number {
+  const code = ch.charCodeAt(0);
+  if (code < 0x20 || code === 0x7f) return 0;
+  if (code < 0x1100) return 1;
+  if (code >= 0x1100 && code <= 0x115f) return 2;
+  if (code >= 0x2e80 && code <= 0x303e) return 2;
+  if (code >= 0x3041 && code <= 0x33ff) return 2;
+  if (code >= 0x3400 && code <= 0x4dbf) return 2;
+  if (code >= 0x4e00 && code <= 0x9fff) return 2;
+  if (code >= 0xa000 && code <= 0xa4cf) return 2;
+  if (code >= 0xac00 && code <= 0xd7a3) return 2;
+  if (code >= 0xf900 && code <= 0xfaff) return 2;
+  if (code >= 0xfe30 && code <= 0xfe4f) return 2;
+  if (code >= 0xff00 && code <= 0xff60) return 2;
+  if (code >= 0xffe0 && code <= 0xffe6) return 2;
+  return 1;
+}
+
+function renderSegment(seg: Segment, key: number, _inverse: boolean): React.ReactNode {
+  if (seg.kind === "text") {
+    return <Text key={`s-${key}`}>{seg.text}</Text>;
+  }
+  // Paste sentinels render as a fuchsia bg-pill so they're visually
+  // distinct from typed text — the user can see "this is the
+  // collapsed paste, not 47 lines of code I typed". Matches the
+  // bg-pill idiom used elsewhere (mode bars, tool names).
+  return (
+    <Text key={`s-${key}`} backgroundColor="#f0abfc" color="black" bold>
+      {seg.label}
+    </Text>
+  );
+}
+
+// ── collapse helper (preserved from v1) ────────────────────────────
+
+type RenderItem =
+  | { kind: "line"; line: string; originalIndex: number }
+  | { kind: "skip"; linesHidden: number };
+
+const COLLAPSE_THRESHOLD = 20;
+const COLLAPSE_HEAD_LINES = 3;
+const COLLAPSE_TAIL_LINES = 2;
+
+export function collapseLinesForDisplay(lines: string[], cursorLine: number): RenderItem[] {
+  if (lines.length <= COLLAPSE_THRESHOLD) {
+    return lines.map((line, i) => ({ kind: "line" as const, line, originalIndex: i }));
+  }
+  const keep = new Set<number>();
+  for (let i = 0; i < COLLAPSE_HEAD_LINES && i < lines.length; i++) keep.add(i);
+  for (let i = Math.max(0, lines.length - COLLAPSE_TAIL_LINES); i < lines.length; i++) keep.add(i);
+  if (cursorLine >= 0 && cursorLine < lines.length) keep.add(cursorLine);
+  const sorted = [...keep].sort((a, b) => a - b);
+  const out: RenderItem[] = [];
+  let prev = -1;
+  for (const idx of sorted) {
+    if (idx - prev > 1) {
+      out.push({ kind: "skip", linesHidden: idx - prev - 1 });
+    }
+    out.push({ kind: "line", line: lines[idx] ?? "", originalIndex: idx });
+    prev = idx;
+  }
+  return out;
+}

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;
@@ -27,12 +28,18 @@ export function RecordView({ rec, compact = false }: RecordViewProps) {
   const toolContentMax = compact ? 200 : 400;
 
   if (rec.role === "user") {
+    // Continuation indent of 6 spaces matches the `you › ` prefix width
+    // so wrapped multi-line user messages align under the body text
+    // instead of jumping to column 0.
+    const content = rec.content.includes("\n")
+      ? rec.content.split("\n").join("\n      ")
+      : rec.content;
     return (
       <Box marginTop={1}>
         <Text bold color="cyan">
           you ›{" "}
         </Text>
-        <Text>{rec.content}</Text>
+        <Text>{content}</Text>
       </Box>
     );
   }
@@ -51,6 +58,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,14 @@ 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,
+    lastTurnCostUsd: 0,
   };
 
   const prefixHash =

src/cli/ui/Select.tsx

@@ -0,0 +1,198 @@
+/**
+ * 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 } from "ink";
+import React, { useState } from "react";
+import { useKeystroke } from "./keystroke-context.js";
+
+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;
+  /**
+   * Optional footer rendered dim beneath the list, e.g.
+   * `"[↑↓] navigate · [Enter] select · [Esc] cancel"`. Makes keyboard
+   * affordances discoverable — otherwise new users hit `y`/`n` and
+   * wonder why nothing happens.
+   */
+  footer?: string;
+}
+
+export function SingleSelect<V extends string>({
+  items,
+  initialValue,
+  onSubmit,
+  onCancel,
+  footer,
+}: SingleSelectProps<V>) {
+  const initialIndex = Math.max(
+    0,
+    items.findIndex((i) => i.value === initialValue && !i.disabled),
+  );
+  const [index, setIndex] = useState(initialIndex === -1 ? 0 : initialIndex);
+
+  useKeystroke((ev) => {
+    if (ev.paste) return;
+    if (ev.upArrow) {
+      setIndex((i) => findNextEnabled(items, i, -1));
+    } else if (ev.downArrow) {
+      setIndex((i) => findNextEnabled(items, i, +1));
+    } else if (ev.return) {
+      const chosen = items[index];
+      if (chosen && !chosen.disabled) onSubmit(chosen.value);
+    } else if (ev.escape && onCancel) {
+      onCancel();
+    }
+  });
+
+  return (
+    <Box flexDirection="column">
+      {items.map((item, i) => (
+        <SelectRow
+          key={item.value}
+          item={item}
+          active={i === index}
+          marker={i === index ? "▸" : " "}
+        />
+      ))}
+      {footer ? (
+        <Box marginTop={1}>
+          <Text dimColor>{footer}</Text>
+        </Box>
+      ) : null}
+    </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));
+
+  useKeystroke((ev) => {
+    if (ev.paste) return;
+    if (ev.upArrow) {
+      setIndex((i) => findNextEnabled(items, i, -1));
+    } else if (ev.downArrow) {
+      setIndex((i) => findNextEnabled(items, i, +1));
+    } else if (ev.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 (ev.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 (ev.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>[↑↓] navigate · [Enter] select</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,117 @@
+import { Box, Text } from "ink";
+import React from "react";
+import { ModalCard } from "./ModalCard.js";
+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;
+  /**
+   * Which tool is asking. `run_background` spawns via JobRegistry and
+   * returns early; `run_command` (default) blocks until the process
+   * exits. Shown as a hint in the modal so the user knows whether
+   * approving will block the TUI or not.
+   */
+  kind?: "run_command" | "run_background";
+  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, kind, onChoose }: ShellConfirmProps) {
+  const isBackground = kind === "run_background";
+  const subtitle = isBackground
+    ? "long-running process — keeps running after approval, /kill to stop"
+    : "model wants to run a shell command";
+  return (
+    <ModalCard
+      accent="#f87171"
+      icon={isBackground ? "⏱" : "⚡"}
+      title={isBackground ? "background process" : "shell command"}
+      subtitle={subtitle}
+    >
+      <Box marginBottom={1}>
+        <Text dimColor>{"$ "}</Text>
+        <Text color="#67e8f9" bold>
+          {command}
+        </Text>
+      </Box>
+      <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)}
+        onCancel={() => onChoose("deny")}
+        footer="[↑↓] navigate  ·  [Enter] select  ·  [Esc] deny"
+      />
+    </ModalCard>
+  );
+}
+
+/**
+ * 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/SlashArgPicker.tsx

@@ -0,0 +1,108 @@
+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 SlashArgPickerProps {
+  /**
+   * When set, render a picker with these matches (filter already
+   * applied upstream). Null → not in picker mode; check `hintSpec`
+   * for a usage hint instead.
+   */
+  matches: readonly string[] | null;
+  /** Highlighted row within `matches`. */
+  selectedIndex: number;
+  /**
+   * Spec of the command the user is typing args for. Used to render
+   * the header label ("/edit <file>") even when matches is empty or
+   * the caller wants a hint instead of a picker.
+   */
+  spec: SlashCommandSpec;
+  /** What kind of arg guidance to render. */
+  kind: "picker" | "hint";
+  /** The user's partial input — shown in the "no matches" hint. */
+  partial: string;
+}
+
+/**
+ * Argument-level picker for a slash command. Mirrors the visual
+ * layout of SlashSuggestions / AtMentionSuggestions so the UI stays
+ * consistent across all three picker surfaces.
+ */
+export function SlashArgPicker({
+  matches,
+  selectedIndex,
+  spec,
+  kind,
+  partial,
+}: SlashArgPickerProps): React.ReactElement | null {
+  // Hint mode: a single dim row explaining the argsHint + summary.
+  if (kind === "hint") {
+    return (
+      <Box paddingX={1} marginTop={1}>
+        <Text dimColor>
+          {"  "}
+          <Text bold>/{spec.cmd}</Text>
+          {spec.argsHint ? ` ${spec.argsHint}` : ""} — {spec.summary}
+        </Text>
+      </Box>
+    );
+  }
+
+  if (matches === null) return null;
+  if (matches.length === 0) {
+    return (
+      <Box flexDirection="column" paddingX={1} marginTop={1}>
+        <Text dimColor>
+          {"  "}
+          <Text bold>/{spec.cmd}</Text>
+          {spec.argsHint ? ` ${spec.argsHint}` : ""} — {spec.summary}
+        </Text>
+        <Text color="yellow"> no match for "{partial}" — keep typing, or Backspace to edit</Text>
+      </Box>
+    );
+  }
+
+  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} marginTop={1}>
+      <Text dimColor>
+        {"  "}
+        <Text bold>/{spec.cmd}</Text>
+        {spec.argsHint ? ` ${spec.argsHint}` : ""} — {spec.summary}
+      </Text>
+      {hiddenAbove > 0 ? <Text dimColor> ↑ {hiddenAbove} more above</Text> : null}
+      {shown.map((value, i) => (
+        <ArgRow key={value} value={value} isSelected={windowStart + i === selectedIndex} />
+      ))}
+      {hiddenBelow > 0 ? <Text dimColor> ↓ {hiddenBelow} more below</Text> : null}
+      <Text dimColor> [↑↓] navigate · [Tab]/[Enter] pick</Text>
+    </Box>
+  );
+}
+
+function ArgRow({ value, isSelected }: { value: string; isSelected: boolean }) {
+  const marker = isSelected ? "▸" : " ";
+  if (isSelected) {
+    return (
+      <Box>
+        <Text bold color="cyan">
+          {marker} {value}
+        </Text>
+      </Box>
+    );
+  }
+  return (
+    <Box>
+      <Text dimColor>
+        {marker} {value}
+      </Text>
+    </Box>
+  );
+}

src/cli/ui/SlashSuggestions.tsx

@@ -0,0 +1,79 @@
+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} marginTop={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} marginTop={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]/[Enter] pick</Text>
+    </Box>
+  );
+}
+
+function SuggestionRow({ spec, isSelected }: { spec: SlashCommandSpec; isSelected: boolean }) {
+  const name = `/${spec.cmd}`;
+  const argsSuffix = spec.argsHint ? ` ${spec.argsHint}` : "";
+  // Selected row gets a solid-bg highlight (cyan) so it pops like
+  // an editor's focused autocomplete entry. Non-selected rows stay
+  // dim with a leading bullet for vertical rhythm.
+  if (isSelected) {
+    return (
+      <Box>
+        <Text backgroundColor="#67e8f9" color="black" bold>
+          {` ▸ ${name.padEnd(12)}${argsSuffix.padEnd(16)}  ${spec.summary} `}
+        </Text>
+      </Box>
+    );
+  }
+  return (
+    <Box>
+      <Text color="#94a3b8">{`   ${name.padEnd(12)}${argsSuffix.padEnd(16)} ${spec.summary}`}</Text>
+    </Box>
+  );
+}

src/cli/ui/StatsPanel.tsx

@@ -1,6 +1,54 @@
-import { Box, Text } from "ink";
+import { Box, Text, useStdout } from "ink";
 import React from "react";
+import type { EditMode } from "../../config.js";
+import { DEEPSEEK_CONTEXT_TOKENS, DEFAULT_CONTEXT_TOKENS } from "../../telemetry.js";
 import type { SessionSummary } from "../../telemetry.js";
+import { VERSION } from "../../version.js";
+import { COLOR, GRADIENT } from "./theme.js";
+
+const WORDMARK_LETTERS: ReadonlyArray<string> = ["R", "E", "A", "S", "O", "N", "I", "X"];
+
+/**
+ * Gradient-flowing wordmark. Every tick the gradient shifts one
+ * position so the colors visibly travel across the letters — like
+ * a neon sign. Brand mark `◈` rides the same flow but also pulses
+ * bold on/off (slow when idle, fast when busy) so a glance at the
+ * top of the screen tells you whether the app is thinking.
+ *
+ * Tick is ~120 ms. `rotateEvery=4` ticks → one shift every ~480 ms
+ * idle, ~240 ms when busy. Slow enough to be ambient, fast enough
+ * to feel alive. Truecolor terminals get the smooth flow; 8-color
+ * fallbacks just see all-cyan, which is still legible.
+ */
+function Wordmark({
+  busy: _busy,
+  animate: _animate,
+}: {
+  busy: boolean;
+  animate: boolean;
+}) {
+  // Static gradient. The brand sweep teal → fuchsia is precomputed
+  // once per render — no useTick subscription, no per-tick
+  // re-render. Earlier versions flowed the colors over time, but
+  // the per-tick re-render interleaved badly with terminal resize
+  // (Ink's eraseLines misjudges row count when bars / wide text
+  // wrap, ghost frames stack). Keeping this static eliminates the
+  // multiplier; resize artifacts at most leave a single stale
+  // frame instead of N.
+  return (
+    <Text>
+      <Text color={GRADIENT[0]} bold>
+        ◈
+      </Text>
+      <Text> </Text>
+      {WORDMARK_LETTERS.map((letter, i) => (
+        <Text key={letter} color={GRADIENT[i % GRADIENT.length]} bold>
+          {letter}
+        </Text>
+      ))}
+    </Text>
+  );
+}
 
 export interface StatsPanelProps {
   summary: SessionSummary;
@@ -8,57 +56,527 @@ export interface StatsPanelProps {
   prefixHash: string;
   harvestOn?: boolean;
   branchBudget?: number;
+  /**
+   * Current `reasoning_effort` cap. Shown as a green "· max" / yellow
+   * "· high" tag in the header so the user always sees which tier the
+   * next turn will use. Absent/undefined hides the tag (e.g. before
+   * the loop is constructed).
+   */
+  reasoningEffort?: "high" | "max";
+  /**
+   * 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;
+  /**
+   * Edit-gate mode. Surfaced as a small pill in the header so the user
+   * can see at a glance whether edits will be queued for review or
+   * applied immediately. Omitted in chat (non-code) mode.
+   */
+  editMode?: EditMode;
+  /**
+   * 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;
+  /**
+   * True when the loop is currently mid-turn — drives the wordmark's
+   * "busy breathing" animation. Visual signal that the app is thinking,
+   * visible at a glance from anywhere on screen.
+   */
+  busy?: boolean;
+  /**
+   * /pro is queued — the next turn will run on v4-pro regardless of
+   * `model`. Rendered as a yellow `⇧ pro armed` pill in the header so
+   * the user has a clear "this turn will be expensive" signal before
+   * submitting their message.
+   */
+  proArmed?: boolean;
+  /**
+   * The CURRENT turn is running on v4-pro because the failure-
+   * escalation threshold fired mid-turn. Rendered as a red `⇧ pro
+   * escalated` pill. Clears at turn end.
+   */
+  escalated?: boolean;
 }
 
+/**
+ * Terminal width under which we switch from one-line metrics to a
+ * stacked layout. Below 120 cols the wide version wraps mid-number
+ * and the parens ("in $X · out $Y") get split across lines — which
+ * looks broken. Stacking costs one row but stays readable on every
+ * SSH / split-pane case we've hit.
+ */
+const NARROW_BREAKPOINT = 120;
+
+/**
+ * Cache-hit ratio is always zero on turn 1 (there's literally no cache
+ * to hit yet). Showing that as red "0.0%" is a false alarm — new users
+ * read it as "something is broken." We suppress the gradient until a
+ * few turns have landed; by turn 4 the cache has had time to warm up.
+ */
+const COLD_START_TURNS = 3;
+
 export function StatsPanel({
   summary,
   model,
   prefixHash,
   harvestOn,
   branchBudget,
+  reasoningEffort,
+  planMode,
+  editMode,
+  balance,
+  updateAvailable,
+  busy,
+  proArmed,
+  escalated,
 }: 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 { stdout } = useStdout();
+  const columns = stdout?.columns ?? 80;
+  const narrow = columns < NARROW_BREAKPOINT;
+
+  // Cold-start: first few turns render cache+cost muted so a 0.0% hit
+  // rate on turn 1 doesn't look like an error. Once the cache has
+  // actually had a chance to build, we flip to the live gradient.
+  const coldStart = summary.turns <= COLD_START_TURNS;
+
+  // No gradient bars, no animation. Earlier versions had truecolor
+  // gradient rules top+bottom and a tick-driven wordmark/bar flow,
+  // but those are exactly the elements Ink's eraseLines miscounts
+  // on resize: ~100-char gradient strings wrap 2-3 visual rows at
+  // narrow widths, the per-tick re-render writes new frames before
+  // the stale rows are erased, and ghost panels stack vertically
+  // (the user-reported "刷屏" / multi-frame artifact). Fixed-row
+  // panel + no per-tick churn keeps Ink's row math honest.
   return (
-    <Box borderStyle="round" borderColor="cyan" flexDirection="column" paddingX={1}>
-      <Box justifyContent="space-between">
-        <Text>
-          <Text color="cyan" bold>
-            Reasonix
-          </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}
-        </Text>
-        <Text dimColor>turns {summary.turns} · type /help</Text>
-      </Box>
-      <Box marginTop={1} gap={3}>
-        <Text>
-          <Text dimColor>cache hit </Text>
-          <Text color={hitColor} bold>
-            {hitPct}%
-          </Text>
-        </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)}%
-          </Text>
-        </Text>
-      </Box>
+    <Box flexDirection="column" paddingX={1} marginBottom={1}>
+      <Header
+        model={model}
+        prefixHash={prefixHash}
+        harvestOn={harvestOn}
+        branchOn={branchOn}
+        branchBudget={branchBudget ?? 1}
+        reasoningEffort={reasoningEffort}
+        planMode={planMode}
+        editMode={editMode}
+        turns={summary.turns}
+        updateAvailable={updateAvailable}
+        narrow={narrow}
+        busy={busy ?? false}
+        proArmed={proArmed ?? false}
+        escalated={escalated ?? false}
+        animate={false}
+      />
+      {narrow ? (
+        <StackedMetrics
+          summary={summary}
+          ctxRatio={ctxRatio}
+          ctxMax={ctxMax}
+          balance={balance}
+          coldStart={coldStart}
+        />
+      ) : (
+        <InlineMetrics
+          summary={summary}
+          ctxRatio={ctxRatio}
+          ctxMax={ctxMax}
+          balance={balance}
+          coldStart={coldStart}
+        />
+      )}
     </Box>
   );
 }
+
+function Header({
+  model,
+  prefixHash,
+  harvestOn,
+  branchOn,
+  branchBudget,
+  reasoningEffort,
+  planMode,
+  editMode,
+  turns,
+  updateAvailable,
+  narrow,
+  busy,
+  proArmed,
+  escalated,
+  animate,
+}: {
+  model: string;
+  prefixHash: string;
+  harvestOn?: boolean;
+  branchOn: boolean;
+  branchBudget: number;
+  reasoningEffort?: "high" | "max";
+  planMode?: boolean;
+  editMode?: EditMode;
+  turns: number;
+  updateAvailable?: string | null;
+  narrow: boolean;
+  busy: boolean;
+  proArmed: boolean;
+  escalated: boolean;
+  /** When false, suppress optional pills + animation to avoid wraps. */
+  animate: boolean;
+}) {
+  // Mode pill — pick the most informative one to surface in the
+  // header. PLAN beats AUTO/review beats nothing. Pro armed/escalated
+  // gets its own pill alongside.
+  const modePill = planMode
+    ? { label: "PLAN", bg: "red" as const }
+    : editMode === "auto"
+      ? { label: "AUTO", bg: "magenta" as const }
+      : editMode === "review"
+        ? { label: "REVIEW", bg: "cyan" as const }
+        : null;
+  const proPill = escalated
+    ? { label: "⇧ PRO", bg: "red" as const }
+    : proArmed
+      ? { label: "⇧ PRO", bg: "yellow" as const }
+      : null;
+  // Narrow / non-animate mode hides the secondary pills (harvest,
+  // branch, reasoning effort) so the header always fits on one
+  // visual row. Wrapping the header is the main amplifier of the
+  // eraseLines miscount that produces the "screen flashing" effect.
+  const showSecondary = animate && !narrow;
+  return (
+    <Box justifyContent="space-between">
+      <Box>
+        <Wordmark busy={busy} animate={animate} />
+        <Text dimColor>{`  ${VERSION}`}</Text>
+        <Text dimColor>{"   "}</Text>
+        <Text color="yellow" bold>
+          {model.replace(/^deepseek-/, "")}
+        </Text>
+        {modePill ? (
+          <>
+            <Text>{"  "}</Text>
+            <Pill label={modePill.label} bg={modePill.bg} />
+          </>
+        ) : null}
+        {proPill ? (
+          <>
+            <Text>{"  "}</Text>
+            <Pill label={proPill.label} bg={proPill.bg} />
+          </>
+        ) : null}
+        {showSecondary && harvestOn ? (
+          <Text dimColor>
+            <Text>{"  "}</Text>
+            <Text color="magenta">harvest</Text>
+          </Text>
+        ) : null}
+        {showSecondary && branchOn ? (
+          <Text dimColor>
+            <Text>{"  "}</Text>
+            <Text color="blue">{`branch×${branchBudget}`}</Text>
+          </Text>
+        ) : null}
+        {showSecondary && reasoningEffort === "max" ? (
+          <>
+            <Text>{"  "}</Text>
+            <Text color="green" dimColor>
+              max
+            </Text>
+          </>
+        ) : null}
+        {showSecondary && reasoningEffort === "high" ? (
+          <>
+            <Text>{"  "}</Text>
+            <Text color="yellow" dimColor>
+              high
+            </Text>
+          </>
+        ) : null}
+      </Box>
+      <Text>
+        {updateAvailable ? <Text color="yellow" bold>{`↑ ${updateAvailable}   `}</Text> : null}
+        <Text dimColor>{narrow ? `t${turns}` : `turn ${turns} · /help`}</Text>
+      </Text>
+    </Box>
+  );
+}
+
+/** Solid-background tag, used for primary mode + pro indicators. */
+function Pill({ label, bg }: { label: string; bg: "red" | "magenta" | "cyan" | "yellow" }) {
+  return (
+    <Text backgroundColor={bg} color="white" bold>
+      {` ${label} `}
+    </Text>
+  );
+}
+
+/**
+ * Wide-terminal layout (≥120 cols): single metrics row. Matches the
+ * original panel, just with calmer spacing and the cold-start
+ * treatment folded in.
+ */
+function InlineMetrics({
+  summary,
+  ctxRatio,
+  ctxMax,
+  balance,
+  coldStart,
+}: {
+  summary: SessionSummary;
+  ctxRatio: number;
+  ctxMax: number;
+  balance?: { currency: string; total: number } | null;
+  coldStart: boolean;
+}) {
+  return (
+    <Box marginTop={1} gap={3}>
+      <ContextCell ratio={ctxRatio} promptTokens={summary.lastPromptTokens} ctxMax={ctxMax} />
+      <CacheCell hitRatio={summary.cacheHitRatio} coldStart={coldStart} turns={summary.turns} />
+      <CostCell summary={summary} coldStart={coldStart} />
+      {balance ? <BalanceCell balance={balance} /> : null}
+    </Box>
+  );
+}
+
+/**
+ * Narrow-terminal layout (<120 cols): one metric per line, in priority
+ * order (ctx → balance → cache → cost). Order matters because users
+ * scanning a cramped terminal want "am I about to hit a wall?" answered
+ * first; dollars spent comes later.
+ */
+function StackedMetrics({
+  summary,
+  ctxRatio,
+  ctxMax,
+  balance,
+  coldStart,
+}: {
+  summary: SessionSummary;
+  ctxRatio: number;
+  ctxMax: number;
+  balance?: { currency: string; total: number } | null;
+  coldStart: boolean;
+}) {
+  return (
+    <Box marginTop={1} flexDirection="column">
+      <ContextCell
+        ratio={ctxRatio}
+        promptTokens={summary.lastPromptTokens}
+        ctxMax={ctxMax}
+        showBar
+      />
+      {balance ? <BalanceCell balance={balance} /> : null}
+      <CacheCell hitRatio={summary.cacheHitRatio} coldStart={coldStart} turns={summary.turns} />
+      <CostCell summary={summary} coldStart={coldStart} />
+    </Box>
+  );
+}
+
+function ContextCell({
+  ratio,
+  promptTokens,
+  ctxMax,
+  showBar,
+}: {
+  ratio: number;
+  promptTokens: number;
+  ctxMax: number;
+  showBar?: boolean;
+}) {
+  if (promptTokens === 0) {
+    return (
+      <Text>
+        <Text color={COLOR.info} dimColor>
+          {"▣ ctx "}
+        </Text>
+        <Text dimColor>— (no turns yet)</Text>
+      </Text>
+    );
+  }
+  const color = ratio >= 0.8 ? COLOR.err : ratio >= 0.6 ? COLOR.warn : COLOR.ok;
+  const pct = Math.round(ratio * 100);
+  return (
+    <Text>
+      <Text color={COLOR.info}>{"▣ ctx  "}</Text>
+      <Bar ratio={ratio} color={color} cells={showBar ? 14 : 10} />
+      <Text> </Text>
+      <Text color={color} bold>
+        {formatTokens(promptTokens)}/{formatTokens(ctxMax)}
+      </Text>
+      <Text dimColor> ({pct}%)</Text>
+      {ratio >= 0.8 ? (
+        <Text color={COLOR.err} bold>
+          {"  ·  /compact"}
+        </Text>
+      ) : null}
+    </Text>
+  );
+}
+
+function CacheCell({
+  hitRatio,
+  coldStart,
+  turns,
+}: {
+  hitRatio: number;
+  coldStart: boolean;
+  turns: number;
+}) {
+  const pct = (hitRatio * 100).toFixed(1);
+  if (turns === 0) {
+    return (
+      <Text>
+        <Text color={COLOR.info} dimColor>
+          {"⌬ cache "}
+        </Text>
+        <Text dimColor>—</Text>
+      </Text>
+    );
+  }
+  if (coldStart) {
+    return (
+      <Text>
+        <Text color={COLOR.info} dimColor>
+          {"⌬ cache "}
+        </Text>
+        <Text dimColor>{pct}% </Text>
+        <Text dimColor italic>
+          (cold start)
+        </Text>
+      </Text>
+    );
+  }
+  const color = hitRatio >= 0.7 ? COLOR.ok : hitRatio >= 0.4 ? COLOR.warn : COLOR.err;
+  return (
+    <Text>
+      <Text color={COLOR.info}>{"⌬ cache  "}</Text>
+      <Text color={color} bold>
+        {pct}%
+      </Text>
+    </Text>
+  );
+}
+
+/**
+ * Color thresholds. Per-turn and session cumulative scale roughly 10×
+ * apart — a $0.20 single turn should feel just as warn-worthy as a $2
+ * session total. Values are rough "notice this" points, not hard caps.
+ */
+function turnCostColor(cost: number): string | undefined {
+  if (cost <= 0) return undefined;
+  if (cost >= 0.2) return COLOR.err;
+  if (cost >= 0.05) return COLOR.warn;
+  return COLOR.ok;
+}
+function sessionCostColor(cost: number): string | undefined {
+  if (cost <= 0) return undefined;
+  if (cost >= 5) return COLOR.err;
+  if (cost >= 0.5) return COLOR.warn;
+  return COLOR.ok;
+}
+
+function CostCell({
+  summary,
+  coldStart,
+}: {
+  summary: SessionSummary;
+  coldStart: boolean;
+}) {
+  if (summary.turns === 0) {
+    return (
+      <Text>
+        <Text color={COLOR.info} dimColor>
+          {"◴ cost "}
+        </Text>
+        <Text dimColor>—</Text>
+      </Text>
+    );
+  }
+  // The first turn is unavoidably a cache-miss (nothing to hit),
+  // so the dollar figure is front-loaded. Muting it during the
+  // cold-start window keeps the "expensive first turn" from
+  // reading as "something is wrong."
+  const turnColor = coldStart ? undefined : turnCostColor(summary.lastTurnCostUsd);
+  const sessionColor = coldStart ? undefined : sessionCostColor(summary.totalCostUsd);
+  return (
+    <Text>
+      <Text color={COLOR.info}>{"◴ turn  "}</Text>
+      <Text color={turnColor} bold={!coldStart} dimColor={coldStart}>
+        ${summary.lastTurnCostUsd.toFixed(4)}
+      </Text>
+      <Text dimColor>{" · session "}</Text>
+      <Text color={sessionColor} bold={!coldStart} dimColor={coldStart}>
+        ${summary.totalCostUsd.toFixed(4)}
+      </Text>
+    </Text>
+  );
+}
+
+function BalanceCell({ balance }: { balance: { currency: string; total: number } }) {
+  const color = balance.total < 1 ? COLOR.err : balance.total < 5 ? COLOR.warn : COLOR.ok;
+  return (
+    <Text>
+      <Text color={COLOR.info}>{"◐ balance  "}</Text>
+      <Text color={color} bold>
+        {balance.currency === "USD" ? "$" : ""}
+        {balance.total.toFixed(2)}
+        {balance.currency !== "USD" ? ` ${balance.currency}` : ""}
+      </Text>
+    </Text>
+  );
+}
+
+/**
+ * Truecolor progress bar. Filled cells use the threshold color (green
+ * → amber → rose) so the bar communicates pressure at a glance;
+ * empty cells use a dim shade so the empty portion is visible
+ * without dominating. ▰/▱ have distinct shapes (filled vs hollow)
+ * so the boundary is clear even when colors snap to 8-color slots
+ * on legacy terminals.
+ */
+function Bar({
+  ratio,
+  color,
+  cells = 14,
+}: {
+  ratio: number;
+  color: string;
+  cells?: number;
+}) {
+  const filled = Math.max(0, Math.min(cells, Math.round(ratio * cells)));
+  return (
+    <Text>
+      <Text color={color}>{"▰".repeat(filled)}</Text>
+      <Text dimColor>{"▱".repeat(cells - filled)}</Text>
+    </Text>
+  );
+}
+
+/**
+ * Compact token formatter using binary K (÷1024): 1234 → "1.2K",
+ * 131072 → "128K". Matches DeepSeek's marketing label of "128K context
+ * length" — showing "131k" confused users (the actual limit is
+ * 128×1024 = 131,072 tokens, but the doc consistently says "128K").
+ * Uppercase K signals binary-K to anyone who notices.
+ */
+function formatTokens(n: number): string {
+  if (n < 1024) return String(n);
+  const k = n / 1024;
+  return k >= 100 ? `${k.toFixed(0)}K` : `${k.toFixed(1)}K`;
+}

src/cli/ui/WelcomeBanner.tsx

@@ -0,0 +1,113 @@
+/**
+ * Welcome card on the empty session. The first thing a user sees
+ * after launching `reasonix code` — needs to communicate, in the
+ * ~5 seconds before they type, three things: brand, what to type,
+ * how to escape. Card framing uses a gradient top rule + left-side
+ * accent bar + sectioned hints so it reads as a designed surface
+ * rather than a bare list. No bordered Boxes — those amplified
+ * Ink's Windows eraseLines miscount.
+ */
+
+import { Box, Text, useStdout } from "ink";
+// biome-ignore lint/style/useImportType: tsconfig jsx=react needs React in value scope
+import React from "react";
+import { COLOR, gradientCells } from "./theme.js";
+
+export interface WelcomeBannerProps {
+  /** True when running `reasonix code`. Surfaces code-mode hints. */
+  inCodeMode?: boolean;
+}
+
+export function WelcomeBanner({ inCodeMode }: WelcomeBannerProps): React.ReactElement {
+  const { stdout } = useStdout();
+  const cols = stdout?.columns ?? 80;
+  const ruleWidth = Math.min(60, Math.max(28, cols - 4));
+  return (
+    <Box flexDirection="column" paddingX={1} marginY={1}>
+      <GradientRule width={ruleWidth} />
+      <BarRow>
+        <Text bold color={COLOR.brand}>
+          ◈ welcome
+        </Text>
+        <Text dimColor>{"  ·  type a message to start"}</Text>
+      </BarRow>
+      <BarRow />
+      <BarRow>
+        <Text bold color={COLOR.primary}>
+          quick start
+        </Text>
+      </BarRow>
+      <Hint cmd="/help" desc="every command + keyboard shortcut" />
+      <Hint cmd="/skill" desc="invoke a stored playbook" />
+      {inCodeMode ? (
+        <>
+          <Hint cmd="@path" desc="inline a file in your message" />
+          <Hint cmd="!cmd" desc="run a shell command, output goes to context" />
+        </>
+      ) : null}
+      <Hint cmd="/exit" desc="quit (Ctrl+C also works)" />
+      <BarRow />
+      <BarRow>
+        <Text dimColor italic>
+          tip:
+        </Text>
+        <Text dimColor>{"  Ctrl+J inserts a newline · trailing \\ also continues"}</Text>
+      </BarRow>
+      <Box marginTop={1}>
+        <GradientRule width={ruleWidth} thin />
+      </Box>
+    </Box>
+  );
+}
+
+/**
+ * One-line gradient rule. `thin` swaps the half-block top/bottom so
+ * the top of the card reads as a "header band" (▄ — bottom-half
+ * filled) and the bottom as "section close" (▁ — minimal pixel
+ * row). Same primitive the StatsPanel uses, kept consistent.
+ */
+function GradientRule({ width, thin }: { width: number; thin?: boolean }) {
+  const cells = gradientCells(width, thin ? "▁" : "▄");
+  return (
+    <Box>
+      {cells.map((c, i) => (
+        // biome-ignore lint/suspicious/noArrayIndexKey: fixed-width gradient row, never reordered
+        <Text key={`wrule-${i}`} color={c.color}>
+          {c.ch}
+        </Text>
+      ))}
+    </Box>
+  );
+}
+
+/**
+ * Card row — left-side accent bar followed by content. Children
+ * optional so we can use this for blank spacer rows (bar only).
+ */
+function BarRow({ children }: { children?: React.ReactNode }) {
+  return (
+    <Box>
+      <Text color={COLOR.brand} bold>
+        ▎
+      </Text>
+      <Text> </Text>
+      {children}
+    </Box>
+  );
+}
+
+/**
+ * Single hint row — bold accent cmd token + dim description.
+ * Padded so all cmd tokens line up regardless of length, like a
+ * man-page synopsis.
+ */
+function Hint({ cmd, desc }: { cmd: string; desc: string }) {
+  return (
+    <BarRow>
+      <Text bold color={COLOR.accent}>
+        {cmd.padEnd(8)}
+      </Text>
+      <Text dimColor>{`  ${desc}`}</Text>
+    </BarRow>
+  );
+}

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>[↑↓] navigate · [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="[↑↓] navigate  ·  [Space] toggle  ·  [Enter] confirm  ·  [Esc] cancel  ·  empty = 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>[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 (["auto", "flash", "pro"] as const).map((name) => ({
+    value: name as PresetName,
+    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/WorkspaceConfirm.tsx

@@ -0,0 +1,69 @@
+import { Box, Text } from "ink";
+import React from "react";
+import { ModalCard } from "./ModalCard.js";
+import { SingleSelect } from "./Select.js";
+
+export type WorkspaceConfirmChoice = "switch" | "deny";
+
+export interface WorkspaceConfirmProps {
+  /** Resolved absolute path the model wants to switch to. */
+  path: string;
+  /** Current session root, shown above the target so the user sees the diff. */
+  currentRoot: string;
+  /** Number of MCP servers still attached — surfaced so the user knows
+   * those won't follow the switch (their child processes were spawned
+   * with the original cwd). 0 means no warning. */
+  mcpServerCount: number;
+  onChoose: (choice: WorkspaceConfirmChoice) => void;
+}
+
+/**
+ * Modal-style approval for a `change_workspace` tool call. Two
+ * choices, Enter / Esc bindings. No "always allow" — workspace
+ * switches are per-target by nature.
+ */
+export function WorkspaceConfirm({
+  path,
+  currentRoot,
+  mcpServerCount,
+  onChoose,
+}: WorkspaceConfirmProps) {
+  const subtitle =
+    mcpServerCount > 0
+      ? `MCP servers (${mcpServerCount}) stay anchored to the original launch root.`
+      : "Re-registers filesystem / shell / memory tools at the new path.";
+  return (
+    <ModalCard accent="#f59e0b" icon="⇄" title="switch workspace" subtitle={subtitle}>
+      <Box flexDirection="column" marginBottom={1}>
+        <Box>
+          <Text dimColor>{"from "}</Text>
+          <Text color="#a3a3a3">{currentRoot}</Text>
+        </Box>
+        <Box>
+          <Text dimColor>{"to   "}</Text>
+          <Text color="#67e8f9" bold>
+            {path}
+          </Text>
+        </Box>
+      </Box>
+      <SingleSelect
+        initialValue="switch"
+        items={[
+          {
+            value: "switch",
+            label: "Switch",
+            hint: "Re-register filesystem / shell / memory tools against the new root.",
+          },
+          {
+            value: "deny",
+            label: "Deny",
+            hint: "Tell the model the user refused; it will continue without changing directories.",
+          },
+        ]}
+        onSubmit={(v) => onChoose(v as WorkspaceConfirmChoice)}
+        onCancel={() => onChoose("deny")}
+        footer="[↑↓] navigate  ·  [Enter] select  ·  [Esc] deny"
+      />
+    </ModalCard>
+  );
+}

src/cli/ui/bang.ts

@@ -0,0 +1,39 @@
+/**
+ * Bash-mode (`!cmd`) prefix parsing.
+ *
+ * A `!` at the start of the user's input means "run this as a shell
+ * command in the sandbox root, and put both the command and its output
+ * into the conversation so the model sees it next turn." Same idea as
+ * Claude Code's `!` prefix — faster than round-tripping through the
+ * model just to cat a file or check git status.
+ *
+ * Design choice: user-typed `!` commands skip the allowlist. The
+ * allowlist exists to bound what the MODEL can do with run_command;
+ * the user typing `!git push` by hand is explicit consent. If a user
+ * wants stricter gating they can set `REASONIX_BANG_CONFIRM=1` in a
+ * future iteration.
+ */
+
+/**
+ * Return the command portion of a `!`-prefixed input, or `null` if
+ * the text isn't a bang invocation. Trims leading/trailing whitespace
+ * from the command body. `!` alone (or `!` followed by only whitespace)
+ * returns `null` — no command to run.
+ */
+export function detectBangCommand(text: string): string | null {
+  if (!text.startsWith("!")) return null;
+  const body = text.slice(1).trim();
+  if (!body) return null;
+  return body;
+}
+
+/**
+ * Format a bang command + its output into a single user-role message
+ * body that the model will see on the next turn. The `[!cmd]` header
+ * marks the run explicitly so the model can distinguish
+ * user-typed shell output from its own `run_command` tool results
+ * (which are `role: tool`, different message shape entirely).
+ */
+export function formatBangUserMessage(cmd: string, output: string): string {
+  return `[!${cmd}]\n${output}`;
+}

src/cli/ui/edit-history.ts

@@ -0,0 +1,182 @@
+import { formatAllBlockDiffs } from "../../code/diff-preview.js";
+import type { ApplyResult, EditBlock, EditSnapshot } from "../../code/edit-blocks.js";
+
+/**
+ * One batch of edits that actually landed on disk — durable enough for
+ * `/undo`, `/history`, and `/show` within a session. Not persisted
+ * across restarts: restoring pre-apply content from a process that
+ * crashed last week is git's job, not ours.
+ */
+export interface EditHistoryEntry {
+  /** Sequence number within the session, stable for `/show <id>`. */
+  id: number;
+  /** Epoch ms when the entry was opened (first edit landed). */
+  at: number;
+  /**
+   * Short tag for what produced the batch — "auto" (auto-mode tool
+   * call), "auto-text" (auto-mode text SEARCH/REPLACE at turn end),
+   * "review-apply" (user-approved modal edit or /apply flush).
+   */
+  source: string;
+  /** Edit blocks included in this batch, in arrival order. */
+  blocks: EditBlock[];
+  /** Per-block outcome — some may be "not-found" if SEARCH drifted. */
+  results: ApplyResult[];
+  /**
+   * First-snapshot-per-path wins: this is what `/undo` restores to.
+   * Deduped so multi-edit turns still roll back to pre-turn state.
+   */
+  snapshots: EditSnapshot[];
+  /**
+   * Paths within this entry that have already been reverted (via
+   * `/undo <id>`, `/undo <id> <path>`, or the newest-non-undone /undo
+   * shortcut). Per-path instead of entry-level so a batch can be
+   * partially undone — user reverts src/foo.ts out of a 3-file batch
+   * without rolling back the other two.
+   */
+  undoneFiles: Set<string>;
+}
+
+/** True when every path in the entry has been undone. */
+export function isEntryFullyUndone(e: EditHistoryEntry): boolean {
+  return e.snapshots.length > 0 && e.snapshots.every((s) => e.undoneFiles.has(s.path));
+}
+
+/** Per-entry three-state status label for display. */
+export function entryStatus(e: EditHistoryEntry): "applied" | "UNDONE" | "PARTIAL" {
+  if (e.undoneFiles.size === 0) return "applied";
+  if (isEntryFullyUndone(e)) return "UNDONE";
+  return "PARTIAL";
+}
+
+/**
+ * Render a batch of SEARCH/REPLACE application results as one
+ * human-scannable info line per edit. Prefixes denote status so the
+ * line reads well even without color (e.g. when piped to a log file
+ * or stripped for screenshots):
+ *   ✓ applied  src/foo.ts
+ *   ✓ created  src/new.ts
+ *   ✗ not-found  src/bar.ts (SEARCH text does not match…)
+ */
+export function formatEditResults(results: ApplyResult[]): string {
+  const lines = results.map((r) => {
+    const mark = r.status === "applied" || r.status === "created" ? "✓" : "✗";
+    const detail = r.message ? ` (${r.message})` : "";
+    return `  ${mark} ${r.status.padEnd(11)} ${r.path}${detail}`;
+  });
+  const ok = results.filter((r) => r.status === "applied" || r.status === "created").length;
+  const total = results.length;
+  const header = `▸ edit blocks: ${ok}/${total} applied — /undo to roll back, or \`git diff\` to review`;
+  return [header, ...lines].join("\n");
+}
+
+/**
+ * Pending-edits preview shown after each assistant turn that proposed
+ * changes. Per-block path header + ±line-count, then a unified-diff-
+ * style preview (context trimmed to 2 lines each side, total capped
+ * at 20 lines per block). Users can eyeball what's about to land
+ * BEFORE pressing `y` — the old summary-only view was a common
+ * mistake surface.
+ *
+ * Each block gets a `[N]` label so users can target a subset via
+ * `/apply 1` / `/apply 1,3-4` / `/discard 2` instead of being forced
+ * into all-or-nothing.
+ */
+export function formatPendingPreview(blocks: EditBlock[]): string {
+  const partial = blocks.length > 1 ? "  ·  /apply N or 1,3-4 for partial" : "";
+  const header = `▸ ${blocks.length} pending edit block(s) — /apply (or y) to commit · /discard (or n) to drop${partial}`;
+  const diffLines = formatAllBlockDiffs(blocks, { numbered: blocks.length > 1 });
+  return [header, ...diffLines].join("\n");
+}
+
+/**
+ * Parse a `/apply <N>` / `/discard <N>` argument into a deduplicated,
+ * sorted list of 1-based indices. Accepts:
+ *   - single value: `"3"`         → [3]
+ *   - comma list:   `"1,3,5"`     → [1, 3, 5]
+ *   - range:        `"2-4"`        → [2, 3, 4]
+ *   - mixed:        `"1,3-5,7"`    → [1, 3, 4, 5, 7]
+ *   - whitespace + trailing commas tolerated.
+ *
+ * Bounds-checked against `max` (the count of pending blocks); any
+ * out-of-range or malformed token returns `{ error }` so the caller
+ * can surface a usage hint instead of silently applying the wrong
+ * subset. Empty input returns `{ ok: [] }` so callers can detect
+ * "user passed no indices" and treat that as the all-blocks default.
+ */
+export function parseEditIndices(raw: string, max: number): { ok: number[] } | { error: string } {
+  const trimmed = raw.trim();
+  if (!trimmed) return { ok: [] };
+  if (max <= 0) return { error: "no pending edits to address" };
+  const seen = new Set<number>();
+  const tokens = trimmed
+    .split(",")
+    .map((t) => t.trim())
+    .filter((t) => t.length > 0);
+  if (tokens.length === 0) return { ok: [] };
+  for (const tok of tokens) {
+    const range = tok.match(/^(\d+)-(\d+)$/);
+    if (range) {
+      const a = Number.parseInt(range[1] ?? "", 10);
+      const b = Number.parseInt(range[2] ?? "", 10);
+      if (!Number.isFinite(a) || !Number.isFinite(b) || a < 1 || b < 1) {
+        return { error: `invalid range: "${tok}"` };
+      }
+      const lo = Math.min(a, b);
+      const hi = Math.max(a, b);
+      if (hi > max) return { error: `index ${hi} out of range (max ${max})` };
+      for (let i = lo; i <= hi; i++) seen.add(i);
+      continue;
+    }
+    if (!/^\d+$/.test(tok)) return { error: `invalid index: "${tok}"` };
+    const n = Number.parseInt(tok, 10);
+    if (!Number.isFinite(n) || n < 1) return { error: `invalid index: "${tok}"` };
+    if (n > max) return { error: `index ${n} out of range (max ${max})` };
+    seen.add(n);
+  }
+  return { ok: [...seen].sort((a, b) => a - b) };
+}
+
+/**
+ * Partition `edits` into the subset addressed by `indices1Based` and
+ * everything else (preserves original order). Pure helper so the
+ * pending-edits queue can be sliced from the slash handler in App.tsx
+ * without any React-state plumbing in the test path.
+ */
+export function partitionEdits<T>(
+  edits: readonly T[],
+  indices1Based: readonly number[],
+): { selected: T[]; remaining: T[] } {
+  const picked = new Set(indices1Based);
+  const selected: T[] = [];
+  const remaining: T[] = [];
+  for (let i = 0; i < edits.length; i++) {
+    if (picked.has(i + 1)) selected.push(edits[i] as T);
+    else remaining.push(edits[i] as T);
+  }
+  return { selected, remaining };
+}
+
+/**
+ * Per-file rows for the multi-level `/undo` output, without the
+ * single-batch header (the caller prepends its own).
+ */
+export function formatUndoRows(results: ApplyResult[]): string[] {
+  return results.map((r) => {
+    const mark = r.status === "applied" ? "✓" : "✗";
+    const detail = r.message ? ` (${r.message})` : "";
+    return `  ${mark} ${r.path}${detail}`;
+  });
+}
+
+export function describeRepair(repair: {
+  scavenged: number;
+  truncationsFixed: number;
+  stormsBroken: number;
+}): string {
+  const parts: string[] = [];
+  if (repair.scavenged) parts.push(`scavenged ${repair.scavenged}`);
+  if (repair.truncationsFixed) parts.push(`repaired ${repair.truncationsFixed} truncation`);
+  if (repair.stormsBroken) parts.push(`broke ${repair.stormsBroken} storm`);
+  return parts.length ? `[repair] ${parts.join(", ")}` : "";
+}

src/cli/ui/hash-memory.ts

@@ -0,0 +1,154 @@
+/**
+ * Hash-mode (`#note` / `#g note`) prefix parsing — instant memory write.
+ *
+ * A `#` at the start of the user's input writes a one-liner to memory
+ * pinned in the prefix from now on. Two scopes:
+ *
+ *   - `#<note>`        → project memory   `<rootDir>/REASONIX.md`
+ *                          (committable, team-shared)
+ *   - `#g <note>`      → global memory    `~/.reasonix/REASONIX.md`
+ *                          (private, cross-project — never committed)
+ *
+ * Same idea as Claude Code's `#` prefix — faster than going through
+ * a `/memory remember ...` slash for a one-liner like "always use pnpm".
+ *
+ * Trigger shape:
+ *   - `#` followed by zero-or-more spaces, then a non-empty body
+ *   - NOT `##` / `###` / etc. — those stay markdown headings to the model
+ *   - `\#foo` escape → not a memory write, leading backslash stripped before
+ *     submission so the model sees `#foo` literally
+ *
+ * Each call appends one bullet at the bottom; we don't try to parse
+ * section structure. The user can reorganize manually whenever they
+ * want.
+ */
+
+import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { PROJECT_MEMORY_FILE } from "../../project-memory.js";
+
+const PROJECT_HEADER = `# Reasonix project memory
+
+Notes the user pinned via the \`#\` prompt prefix. The whole file is
+loaded into the immutable system prefix every session — keep it terse.
+
+`;
+
+const GLOBAL_HEADER = `# Reasonix global memory
+
+Cross-project notes the user pinned via the \`#g\` prompt prefix. Loaded
+into every Reasonix session's prefix regardless of working directory.
+Private to this machine — not committed anywhere.
+
+`;
+
+/**
+ * Result of `detectHashMemory`.
+ *
+ *   - `kind: "memory"`  — input is `#<note>`; write to project REASONIX.md.
+ *   - `kind: "memory-global"` — input is `#g <note>`; write to global file.
+ *   - `kind: "escape"`  — input started with `\#`; submit `#foo` literally.
+ *   - returning `null`  — input is unrelated to hash mode.
+ */
+export type HashMemoryParse =
+  | { kind: "memory"; note: string }
+  | { kind: "memory-global"; note: string }
+  | { kind: "escape"; text: string };
+
+/**
+ * Classify a hash-prefixed input. Pure — no filesystem touch — so it's
+ * trivially testable and can run before any I/O decision in handleSubmit.
+ *
+ * Order of checks matters:
+ *   1. `\#…` escape (so `\#g foo` ALSO escapes — user can send `#g foo`
+ *      to the model verbatim).
+ *   2. `##…` markdown heading (level-2+ passes through unchanged).
+ *   3. `#g <body>` — global memory. Requires whitespace after the `g` so
+ *      a note that happens to start with `g` (e.g. `#good idea`) doesn't
+ *      route to global by accident.
+ *   4. `#<body>` — project memory.
+ */
+export function detectHashMemory(text: string): HashMemoryParse | null {
+  if (text.startsWith("\\#")) {
+    return { kind: "escape", text: text.slice(1) };
+  }
+  if (!text.startsWith("#")) return null;
+  // Markdown headings of level 2+ pass through to the model unchanged.
+  // Only a single leading `#` (level-1 heading shape) is ambiguous; we
+  // resolve that ambiguity in favor of memory write and document the
+  // `\#` escape for users who want a literal H1 in the prompt.
+  if (text.startsWith("##")) return null;
+  // `#g <note>` — global memory. The space after `g` is mandatory so
+  // notes like `#golang preference` route to project memory, not global.
+  // `#g` alone (or `#g` + only whitespace) is treated as null — the
+  // user clearly wanted the global form but typed no body, so we don't
+  // silently fall back to project memory with body=`g`.
+  if (/^#g\s*$/.test(text)) return null;
+  const globalMatch = /^#g\s+(.+)$/s.exec(text);
+  if (globalMatch) {
+    const body = globalMatch[1]!.trim();
+    if (!body) return null;
+    return { kind: "memory-global", note: body };
+  }
+  const body = text.slice(1).trim();
+  if (!body) return null;
+  return { kind: "memory", note: body };
+}
+
+export interface AppendMemoryResult {
+  /** Absolute path written to. */
+  path: string;
+  /** True iff the file did not exist before this call. */
+  created: boolean;
+}
+
+/**
+ * Append `note` as a single bullet to `<rootDir>/REASONIX.md`. Creates
+ * the file with a short header when absent. Inserts a leading newline
+ * if the existing file doesn't end with one, so bullets don't collide
+ * with the previous section's last line.
+ */
+export function appendProjectMemory(rootDir: string, note: string): AppendMemoryResult {
+  return appendBulletToFile(join(rootDir, PROJECT_MEMORY_FILE), note, PROJECT_HEADER);
+}
+
+export const GLOBAL_MEMORY_DIR = ".reasonix";
+export const GLOBAL_MEMORY_FILE = "REASONIX.md";
+
+/**
+ * Resolve the path to the global memory file. Defaults to
+ * `~/.reasonix/REASONIX.md`; callers (mainly tests) can override the
+ * home dir to point at a tmpdir.
+ */
+export function globalMemoryPath(homeDir: string = homedir()): string {
+  return join(homeDir, GLOBAL_MEMORY_DIR, GLOBAL_MEMORY_FILE);
+}
+
+/**
+ * Append `note` to `~/.reasonix/REASONIX.md`. Creates the parent
+ * directory + file if either is missing.
+ */
+export function appendGlobalMemory(note: string, homeDir?: string): AppendMemoryResult {
+  return appendBulletToFile(globalMemoryPath(homeDir), note, GLOBAL_HEADER);
+}
+
+function appendBulletToFile(path: string, note: string, newFileHeader: string): AppendMemoryResult {
+  const trimmed = note.trim();
+  if (!trimmed) throw new Error("note body cannot be empty");
+  const bullet = `- ${trimmed}\n`;
+  if (!existsSync(path)) {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, `${newFileHeader}${bullet}`, "utf8");
+    return { path, created: true };
+  }
+  let prefix = "";
+  try {
+    const existing = readFileSync(path, "utf8");
+    if (existing.length > 0 && !existing.endsWith("\n")) prefix = "\n";
+  } catch {
+    // Unreadable but exists — let appendFileSync surface the real error.
+  }
+  appendFileSync(path, `${prefix}${bullet}`, "utf8");
+  return { path, created: false };
+}

src/cli/ui/key-normalize.ts

@@ -0,0 +1,144 @@
+/**
+ * CSI sequence recovery for Ink's `useInput`.
+ *
+ * Why this exists. Ink delivers keyboard events through `parse-keypress`,
+ * which reads stdin and recognises ANSI control-sequence-introducer
+ * (CSI) sequences with a state machine plus a short timeout. On most
+ * terminals this works: the byte stream `\x1b [ A` arrives in one
+ * read, parse-keypress emits `{key.upArrow:true, input:""}`, life is
+ * good.
+ *
+ * On Windows PowerShell + ConPTY (and a handful of embedded shells)
+ * the bytes don't always arrive together. parse-keypress's timeout
+ * expires between chunks, so it dispatches the lone `\x1b` as
+ * `key.escape:true` and then dispatches the trailing `[A` as a
+ * regular character event — `input:"[A", key.upArrow:undefined`. The
+ * useInput consumer sees `[A` as plain text, inserts it into the
+ * buffer, and the cursor never moves. Same shape on `[C` (right
+ * arrow), `[Z` (Shift+Tab), `[5~` (PgUp), `[201~` (bracketed-paste
+ * end), etc.
+ *
+ * Every Reasonix UI component that calls `useInput` is exposed to
+ * this. Patching each one to re-recognise the bare CSI tail was
+ * fragile — every release a new symptom appeared (cursor stuck,
+ * paste markers leaking, Shift+Tab not toggling). So this module is
+ * the single source of truth for CSI recovery: every input handler
+ * runs the raw event through `recoverCsiTail` before reading
+ * structured key flags.
+ *
+ * Recovery is conservative. We only rewrite when:
+ *   1. None of the structured key flags Ink already populated for
+ *      this event is set (so a real upArrow press isn't second-
+ *      guessed).
+ *   2. `input` exactly matches a recognised tail in either form —
+ *      the full `\x1b[X` sequence (in case the timeout merged it)
+ *      or the bare `[X` ConPTY-stripped variant.
+ *
+ * Anything else passes through unchanged.
+ */
+
+/**
+ * Subset of Ink's `Key` interface that contains the structured flags
+ * we know how to recover. Optional everywhere because callers from
+ * different Ink versions may not populate every field.
+ */
+export interface CsiKeyFlags {
+  upArrow?: boolean;
+  downArrow?: boolean;
+  leftArrow?: boolean;
+  rightArrow?: boolean;
+  pageUp?: boolean;
+  pageDown?: boolean;
+  delete?: boolean;
+  shift?: boolean;
+  tab?: boolean;
+}
+
+/**
+ * CSI tails we recognise. Each maps the printable bytes of a CSI
+ * tail (the part after the `\x1b`) to the structured key flags they
+ * should set. Bracketed-paste markers `[200~` / `[201~` are
+ * intentionally absent — they're handled by PromptInput's paste
+ * accumulator, which has different semantics (collect content
+ * between markers rather than emit one keystroke).
+ */
+const CSI_TAIL_TO_FLAGS: ReadonlyArray<{ tail: string; flags: CsiKeyFlags }> = [
+  // Arrow keys — the most common ConPTY victim.
+  { tail: "[A", flags: { upArrow: true } },
+  { tail: "[B", flags: { downArrow: true } },
+  { tail: "[C", flags: { rightArrow: true } },
+  { tail: "[D", flags: { leftArrow: true } },
+  // Page navigation.
+  { tail: "[5~", flags: { pageUp: true } },
+  { tail: "[6~", flags: { pageDown: true } },
+  // Forward-delete (the key labelled Delete on most keyboards).
+  { tail: "[3~", flags: { delete: true } },
+  // Shift+Tab — terminal sends `\x1b[Z` rather than tab-with-shift.
+  { tail: "[Z", flags: { shift: true, tab: true } },
+];
+
+/**
+ * Did Ink already give us a structured key for this event? When
+ * `true`, recovery is unnecessary and would risk overriding a real
+ * keypress that happens to share `input` with a CSI tail.
+ */
+function alreadyStructured(flags: CsiKeyFlags): boolean {
+  return Boolean(
+    flags.upArrow ||
+      flags.downArrow ||
+      flags.leftArrow ||
+      flags.rightArrow ||
+      flags.pageUp ||
+      flags.pageDown ||
+      flags.delete ||
+      (flags.tab && flags.shift),
+  );
+}
+
+/**
+ * If `input` is a recognisable CSI tail (with or without the leading
+ * `\x1b`), return the structured flags it should produce. Otherwise
+ * `null`. Bracketed-paste markers always return `null` here — those
+ * are handled by their own accumulator.
+ *
+ * Pure function. Pass already-structured events through (they
+ * short-circuit) so a real arrow press doesn't get rewritten.
+ */
+export function recoverCsiTail(input: string, existing: CsiKeyFlags = {}): CsiKeyFlags | null {
+  if (alreadyStructured(existing)) return null;
+  for (const entry of CSI_TAIL_TO_FLAGS) {
+    if (input === entry.tail || input === `\x1b${entry.tail}`) {
+      return entry.flags;
+    }
+  }
+  return null;
+}
+
+/**
+ * Tail forms (with and without the leading `\x1b`) that should never
+ * end up as literal text in a user's prompt buffer. Used as a final
+ * defensive pass before treating input as printable — if a CSI
+ * fragment slipped past structured-key recovery (e.g. arrived
+ * embedded inside a paste burst), at least drop the raw bytes
+ * rather than insert them as garbage text.
+ *
+ * Includes the bracketed-paste markers `[200~` / `[201~` because a
+ * paste whose start/end markers got chunked across reads can leave
+ * those bytes in the printable input.
+ */
+export const STRIPPABLE_CSI_FRAGMENTS: readonly string[] = [
+  "\u001b[200~",
+  "\u001b[201~",
+  "[200~",
+  "[201~",
+  ...CSI_TAIL_TO_FLAGS.flatMap((e) => [`\u001b${e.tail}`, e.tail]),
+];
+
+/** Remove every recognised CSI fragment from a string. */
+export function stripCsiFragments(input: string): string {
+  let out = input;
+  for (const frag of STRIPPABLE_CSI_FRAGMENTS) {
+    if (out.includes(frag)) out = out.replaceAll(frag, "");
+  }
+  return out;
+}

src/cli/ui/keystroke-context.tsx

@@ -0,0 +1,120 @@
+/**
+ * KeystrokeContext — React surface in front of the raw stdin reader.
+ *
+ * Replaces Ink's `useInput` chain. Reasonix's components no longer
+ * import `useInput` from "ink"; they call `useKeystroke(handler,
+ * isActive)` from this module. The provider mounted once at App
+ * level owns a `StdinReader`, subscribes a single fan-out function
+ * to it, and dispatches each parsed `KeyEvent` to every active
+ * consumer.
+ *
+ * Why a Context instead of a singleton import: the provider can be
+ * disabled in tests / replay mode without touching the components,
+ * and the lifecycle (start/stop on mount/unmount) is tied to the
+ * React tree rather than a global side effect.
+ *
+ * Why not just keep Ink's useInput: Ink's parse-keypress uses a
+ * 100 ms intra-CSI timeout that's too short for Windows ConPTY,
+ * leaking arrow-key bytes / paste markers into the buffer. Our
+ * reader uses 250 ms and recognises the ESC-stripped variants too
+ * — see `stdin-reader.ts`.
+ */
+
+// biome-ignore lint/style/useImportType: tsconfig jsx=react needs React as a runtime value
+import React, { createContext, useContext, useEffect, useRef } from "react";
+import { type KeyEvent, type StdinReader, getStdinReader } from "./stdin-reader.js";
+
+interface KeystrokeBus {
+  /** Subscribe — returns an unsubscribe function. */
+  subscribe(handler: KeystrokeHandler): () => void;
+}
+
+export type KeystrokeHandler = (ev: KeyEvent) => void;
+
+const KeystrokeContext = createContext<KeystrokeBus | null>(null);
+
+export interface KeystrokeProviderProps {
+  children: React.ReactNode;
+  /**
+   * Optional reader override. Tests inject a synthetic reader so
+   * they can `feed()` chunks instead of touching real stdin. Production
+   * callers leave this unset and get the singleton.
+   */
+  reader?: StdinReader;
+}
+
+export function KeystrokeProvider({
+  children,
+  reader: providedReader,
+}: KeystrokeProviderProps): React.ReactElement {
+  const handlersRef = useRef<Set<KeystrokeHandler>>(new Set());
+  // Ref so the bus value's identity is stable across re-renders —
+  // consumers don't accidentally re-subscribe every render.
+  const busRef = useRef<KeystrokeBus | null>(null);
+  if (busRef.current === null) {
+    busRef.current = {
+      subscribe(handler) {
+        handlersRef.current.add(handler);
+        return () => {
+          handlersRef.current.delete(handler);
+        };
+      },
+    };
+  }
+
+  useEffect(() => {
+    const reader = providedReader ?? getStdinReader();
+    reader.start();
+    const unsubscribe = reader.subscribe((ev) => {
+      // Snapshot the handler set so handlers added/removed during
+      // dispatch don't perturb iteration. Cheap — typical N=1-3.
+      for (const fn of [...handlersRef.current]) fn(ev);
+    });
+    return () => {
+      unsubscribe();
+      // Don't `stop()` the singleton on every unmount — multiple
+      // mounts (test reruns, hot-reload) must not tear down stdin.
+      // The singleton's own start() is idempotent; stop() is the
+      // process-exit handler's job.
+    };
+  }, [providedReader]);
+
+  return <KeystrokeContext.Provider value={busRef.current}>{children}</KeystrokeContext.Provider>;
+}
+
+/**
+ * Subscribe to keystroke events. Mirrors Ink's `useInput` shape —
+ * `handler(ev)` runs on every event while `isActive` is truthy
+ * (default true). Set `isActive=false` to suspend the handler
+ * (e.g. while a modal is up and shouldn't respond to global keys).
+ *
+ * Handler identity changes are tolerated — we re-subscribe via
+ * useEffect on every render. Wrap your handler in `useCallback` if
+ * you want to avoid that.
+ */
+export function useKeystroke(handler: KeystrokeHandler, isActive = true): void {
+  const bus = useContext(KeystrokeContext);
+  // Latest-handler ref so we can subscribe ONCE per active toggle
+  // and still call the freshest closure on each event.
+  const handlerRef = useRef(handler);
+  handlerRef.current = handler;
+
+  useEffect(() => {
+    if (!bus || !isActive) return undefined;
+    return bus.subscribe((ev) => handlerRef.current(ev));
+  }, [bus, isActive]);
+}
+
+/**
+ * Lower-level hook for components that need a stable subscription
+ * across the lifetime of the consumer (typically StdinReader-aware
+ * unit tests).
+ */
+export function useKeystrokeBus(): KeystrokeBus | null {
+  return useContext(KeystrokeContext);
+}
+
+/** Test helper — assemble a KeyEvent with sensible defaults. */
+export function makeKeyEvent(overrides: Partial<KeyEvent> = {}): KeyEvent {
+  return { input: "", ...overrides };
+}

src/cli/ui/loop.ts

@@ -0,0 +1,148 @@
+/**
+ * `/loop <interval> <prompt>` parsing + status formatting.
+ *
+ * Claude-Code-style recurring prompt: at every `<interval>` tick, the
+ * App auto-submits `<prompt>` as if the user typed it. Useful for "keep
+ * checking the deploy" / "rerun tests" / "watch the build status until
+ * green" — anything the user wants probed periodically without holding
+ * the keyboard.
+ *
+ * Cancellation contract (enforced in App.tsx, not here — this file is
+ * pure):
+ *   - `/loop stop`               → explicit stop slash
+ *   - user types anything else   → loop dies, user takes over
+ *   - Esc / /new / /clear / exit → loop dies
+ *   - one loop per session       → re-issuing /loop replaces the prior
+ *
+ * Interval bounds:
+ *   - Minimum: 5 seconds (anything tighter and the model couldn't even
+ *     finish a turn before the next firing — we'd queue submits and
+ *     drift forever).
+ *   - Maximum: 6 hours (the upper end of "let it run while I sleep";
+ *     beyond that you should be writing a cron, not a TUI loop).
+ */
+
+/** Lower bound on loop interval (ms). Faster than this would queue submits faster than turns finish. */
+export const MIN_LOOP_INTERVAL_MS = 5_000;
+/** Upper bound on loop interval (ms). Beyond a few hours, use cron. */
+export const MAX_LOOP_INTERVAL_MS = 6 * 60 * 60_000;
+
+/**
+ * Parse a duration string into milliseconds.
+ *
+ * Accepted forms (case-insensitive on the unit):
+ *   - `45`      → 45_000   (bare number = seconds)
+ *   - `30s`     → 30_000
+ *   - `5m`      → 300_000
+ *   - `2h`      → 7_200_000
+ *   - `1.5m`    → 90_000   (fractional supported)
+ *
+ * Returns `null` on:
+ *   - empty input
+ *   - non-numeric / unknown unit
+ *   - negative or zero values
+ *   - values outside [MIN_LOOP_INTERVAL_MS, MAX_LOOP_INTERVAL_MS]
+ *
+ * Caller surfaces `null` as a usage hint to the user. Pure.
+ */
+export function parseLoopInterval(raw: string): { ms: number } | null {
+  const s = raw.trim().toLowerCase();
+  if (!s) return null;
+  const m = /^([0-9]+(?:\.[0-9]+)?)(s|sec|secs|m|min|mins|h|hr|hrs)?$/.exec(s);
+  if (!m) return null;
+  const n = Number.parseFloat(m[1] ?? "");
+  if (!Number.isFinite(n) || n <= 0) return null;
+  const unit = m[2] ?? "s";
+  let ms: number;
+  if (unit === "s" || unit === "sec" || unit === "secs") ms = Math.round(n * 1000);
+  else if (unit === "m" || unit === "min" || unit === "mins") ms = Math.round(n * 60_000);
+  else if (unit === "h" || unit === "hr" || unit === "hrs") ms = Math.round(n * 60 * 60_000);
+  else return null;
+  if (ms < MIN_LOOP_INTERVAL_MS) return null;
+  if (ms > MAX_LOOP_INTERVAL_MS) return null;
+  return { ms };
+}
+
+export interface ParsedLoopArgs {
+  intervalMs: number;
+  prompt: string;
+}
+
+/**
+ * Parse the full `/loop <interval> <prompt>` invocation. Args is the
+ * commander-style tail (already split on whitespace, slash command
+ * stripped). Returns `null` when the shape is wrong; caller emits a
+ * usage hint.
+ *
+ * Special tokens:
+ *   - `stop` (case-insensitive) as the only arg → caller should stop
+ *     the active loop. Returns a sentinel: `{ stop: true }`.
+ *   - empty args → returns `{ status: true }` so the caller can print
+ *     the active-loop status (or "no loop active").
+ *
+ * Otherwise the first token is the interval, the rest is the prompt.
+ * The prompt may itself be a slash command (`/loop 30s /status` is a
+ * valid way to keep refreshing the status panel).
+ */
+export type LoopCommand =
+  | { kind: "start"; intervalMs: number; prompt: string }
+  | { kind: "stop" }
+  | { kind: "status" }
+  | { kind: "error"; message: string };
+
+export function parseLoopCommand(args: readonly string[]): LoopCommand {
+  if (args.length === 0) return { kind: "status" };
+  const first = (args[0] ?? "").toLowerCase();
+  if (args.length === 1 && (first === "stop" || first === "off" || first === "cancel")) {
+    return { kind: "stop" };
+  }
+  const interval = parseLoopInterval(args[0] ?? "");
+  if (!interval) {
+    return {
+      kind: "error",
+      message:
+        "usage: /loop <interval> <prompt>   (interval = 5s..6h, e.g. 30s, 5m, 1h)\n" +
+        "       /loop stop                  (cancel an active loop)\n" +
+        "       /loop                       (show active-loop status)",
+    };
+  }
+  const prompt = args.slice(1).join(" ").trim();
+  if (!prompt) {
+    return {
+      kind: "error",
+      message: `usage: /loop ${args[0]} <prompt>   — interval is fine but the prompt is missing.`,
+    };
+  }
+  return { kind: "start", intervalMs: interval.ms, prompt };
+}
+
+/**
+ * Format the active loop into a single-line status pill for the
+ * modeline. `nextFireMs` is wall-clock ms until next firing; the
+ * caller computes it from the stored `nextFireAt - Date.now()`.
+ *
+ * Examples:
+ *   "loop: `npm test` · next in 28s · iter 3"
+ *   "loop: `check deploy status` · firing now · iter 1"
+ */
+export function formatLoopStatus(prompt: string, nextFireMs: number, iter: number): string {
+  const preview = prompt.length > 36 ? `${prompt.slice(0, 33)}…` : prompt;
+  const when = nextFireMs <= 0 ? "firing now" : `next in ${formatDuration(nextFireMs)}`;
+  return `loop: \`${preview}\` · ${when} · iter ${iter}`;
+}
+
+/**
+ * Human-friendly duration. Used by the loop status pill so a 4-minute
+ * 23-second wait reads as "4m23s" instead of "263000".
+ */
+export function formatDuration(ms: number): string {
+  if (ms < 1000) return `${ms}ms`;
+  const totalSec = Math.round(ms / 1000);
+  if (totalSec < 60) return `${totalSec}s`;
+  const m = Math.floor(totalSec / 60);
+  const s = totalSec % 60;
+  if (m < 60) return s === 0 ? `${m}m` : `${m}m${s}s`;
+  const h = Math.floor(m / 60);
+  const mm = m % 60;
+  return mm === 0 ? `${h}h` : `${h}h${mm}m`;
+}

src/cli/ui/mcp-browse.ts

@@ -0,0 +1,242 @@
+/**
+ * `/resource` and `/prompt` slash handlers for the chat/code TUI.
+ *
+ * The slash-command registry (slash.ts) advertises both commands so the
+ * argument-level picker and /help surface them, but the actual read/fetch
+ * work is async — McpClient.readResource and getPrompt both round-trip to
+ * the server — so it doesn't fit the synchronous `handleSlash` shape used
+ * by every other slash command. App.tsx intercepts the commands directly
+ * and calls into the helpers below.
+ *
+ * Split by effect boundary:
+ *   - formatters (resource list, contents, prompt list, messages) are
+ *     pure over already-fetched data and unit-tested
+ *   - find-server helpers are pure lookups against inspection reports
+ *   - `handleMcpBrowseSlash` is the async orchestrator App.tsx calls
+ *
+ * v1 intentionally does NOT inject the fetched resource/prompt into the
+ * next model turn. It's a display-only browser so users can see what
+ * their MCP servers expose. A future version may add a Tab-to-inject
+ * hotkey once the UX is settled.
+ */
+
+import type { McpClient } from "../../mcp/client.js";
+import type {
+  GetPromptResult,
+  McpPromptMessage,
+  McpResourceContents,
+  ReadResourceResult,
+} from "../../mcp/types.js";
+import type { DisplayEvent } from "./EventLog.js";
+import type { McpServerSummary } from "./slash.js";
+
+/**
+ * React setState for Historical — typed loose because the App state
+ * shape is App-internal. We only ever append, so `(prev) => prev.concat(row)`
+ * works against any array-of-DisplayEvent state.
+ */
+export type HistoricalSetter = (updater: (prev: DisplayEvent[]) => DisplayEvent[]) => void;
+
+export function formatResourceList(servers: readonly McpServerSummary[]): string {
+  const lines: string[] = [];
+  let total = 0;
+  for (const s of servers) {
+    if (!s.report.resources.supported) continue;
+    const items = s.report.resources.items;
+    if (items.length === 0) continue;
+    lines.push(`[${s.label}] ${items.length} resource(s):`);
+    for (const r of items.slice(0, 20)) {
+      const name = r.name && r.name !== r.uri ? `  ${r.name}` : "";
+      const mime = r.mimeType ? ` · ${r.mimeType}` : "";
+      lines.push(`  · ${r.uri}${name}${mime}`);
+      total++;
+    }
+    if (items.length > 20) lines.push(`  (+${items.length - 20} more)`);
+    lines.push("");
+  }
+  if (total === 0) {
+    return "No resources on any connected MCP server (or no servers connected). `/mcp` shows the current set.";
+  }
+  lines.push("Read one: `/resource <uri>` — or use Tab in the picker.");
+  return lines.join("\n");
+}
+
+export function formatPromptList(servers: readonly McpServerSummary[]): string {
+  const lines: string[] = [];
+  let total = 0;
+  for (const s of servers) {
+    if (!s.report.prompts.supported) continue;
+    const items = s.report.prompts.items;
+    if (items.length === 0) continue;
+    lines.push(`[${s.label}] ${items.length} prompt(s):`);
+    for (const p of items.slice(0, 20)) {
+      const desc = p.description ? ` — ${p.description}` : "";
+      const argHint =
+        p.arguments && p.arguments.length > 0
+          ? ` (args: ${p.arguments.map((a) => a.name + (a.required ? "*" : "?")).join(", ")})`
+          : "";
+      lines.push(`  · ${p.name}${argHint}${desc}`);
+      total++;
+    }
+    if (items.length > 20) lines.push(`  (+${items.length - 20} more)`);
+    lines.push("");
+  }
+  if (total === 0) {
+    return "No prompts on any connected MCP server (or no servers connected). `/mcp` shows the current set.";
+  }
+  lines.push(
+    "Fetch one: `/prompt <name>` — args are not supported yet; prompts with required args will surface an error from the server.",
+  );
+  return lines.join("\n");
+}
+
+export function findServerForResource(
+  servers: readonly McpServerSummary[],
+  uri: string,
+): McpServerSummary | null {
+  for (const s of servers) {
+    if (!s.report.resources.supported) continue;
+    if (s.report.resources.items.some((r) => r.uri === uri)) return s;
+  }
+  return null;
+}
+
+export function findServerForPrompt(
+  servers: readonly McpServerSummary[],
+  name: string,
+): McpServerSummary | null {
+  for (const s of servers) {
+    if (!s.report.prompts.supported) continue;
+    if (s.report.prompts.items.some((p) => p.name === name)) return s;
+  }
+  return null;
+}
+
+export function formatResourceContents(uri: string, result: ReadResourceResult): string {
+  const lines: string[] = [`Resource ${uri} (${result.contents.length} content block(s)):`, ""];
+  for (let i = 0; i < result.contents.length; i++) {
+    const c = result.contents[i]!;
+    const header = `— block ${i + 1}${c.mimeType ? ` · ${c.mimeType}` : ""}`;
+    lines.push(header);
+    lines.push(formatOneResourceContent(c));
+    lines.push("");
+  }
+  return lines.join("\n").trimEnd();
+}
+
+function formatOneResourceContent(c: McpResourceContents): string {
+  if ("text" in c) {
+    const MAX = 8_000;
+    if (c.text.length > MAX) {
+      return `${c.text.slice(0, MAX)}\n\n[…truncated ${c.text.length - MAX} chars; full contents available via McpClient.readResource in library mode.]`;
+    }
+    return c.text;
+  }
+  // blob — we can't render arbitrary binary in the TUI; give the size.
+  const bytes = typeof c.blob === "string" ? approximateBase64ByteSize(c.blob) : 0;
+  return `[binary · ~${bytes.toLocaleString()} bytes · base64]`;
+}
+
+function approximateBase64ByteSize(b64: string): number {
+  // 4 base64 chars encode 3 bytes; padding `=` trims the output.
+  const padding = b64.endsWith("==") ? 2 : b64.endsWith("=") ? 1 : 0;
+  return Math.floor((b64.length * 3) / 4) - padding;
+}
+
+export function formatPromptMessages(name: string, result: GetPromptResult): string {
+  const lines: string[] = [
+    `Prompt ${name}${result.description ? ` — ${result.description}` : ""}`,
+    `(${result.messages.length} message(s))`,
+    "",
+  ];
+  for (let i = 0; i < result.messages.length; i++) {
+    const m = result.messages[i]!;
+    lines.push(`— ${i + 1}. ${m.role}`);
+    lines.push(formatOnePromptMessage(m));
+    lines.push("");
+  }
+  return lines.join("\n").trimEnd();
+}
+
+function formatOnePromptMessage(m: McpPromptMessage): string {
+  const block = m.content as { type?: string; text?: string; resource?: McpResourceContents };
+  if (block.type === "text" && typeof block.text === "string") return block.text;
+  if (block.type === "resource" && block.resource) {
+    return `[resource: ${block.resource.uri}]\n${formatOneResourceContent(block.resource)}`;
+  }
+  return `[non-text content: ${block.type ?? "unknown"}]`;
+}
+
+/**
+ * Orchestrator. Looks up the right server, calls readResource/getPrompt
+ * via its `client`, and pushes one info row into `Historical`. Errors
+ * (server missing, -32601, network) surface as a warning row; the user
+ * can always fall back to `reasonix mcp inspect <spec>` for diagnostics.
+ */
+export async function handleMcpBrowseSlash(
+  kind: "resource" | "prompt",
+  arg: string,
+  servers: readonly McpServerSummary[],
+  setHistorical: HistoricalSetter,
+): Promise<void> {
+  const ts = Date.now();
+  const push = (role: DisplayEvent["role"], text: string) => {
+    setHistorical((prev) => [...prev, { id: `mcp-${role}-${ts}-${prev.length}`, role, text }]);
+  };
+
+  // No arg → list mode.
+  if (!arg) {
+    push("info", kind === "resource" ? formatResourceList(servers) : formatPromptList(servers));
+    return;
+  }
+
+  if (kind === "resource") {
+    const server = findServerForResource(servers, arg);
+    if (!server) {
+      push(
+        "warning",
+        `no server exposes resource "${arg}". \`/resource\` with no arg lists what's available.`,
+      );
+      return;
+    }
+    const client: McpClient | undefined = server.client;
+    if (!client) {
+      push(
+        "warning",
+        `server [${server.label}] is not connected (display-only). Resource read requires a live MCP client.`,
+      );
+      return;
+    }
+    try {
+      const result = await client.readResource(arg);
+      push("info", formatResourceContents(arg, result));
+    } catch (err) {
+      push("warning", `readResource failed: ${(err as Error).message}`);
+    }
+    return;
+  }
+
+  // prompt
+  const server = findServerForPrompt(servers, arg);
+  if (!server) {
+    push(
+      "warning",
+      `no server exposes prompt "${arg}". \`/prompt\` with no arg lists what's available.`,
+    );
+    return;
+  }
+  const client: McpClient | undefined = server.client;
+  if (!client) {
+    push(
+      "warning",
+      `server [${server.label}] is not connected (display-only). Prompt fetch requires a live MCP client.`,
+    );
+    return;
+  }
+  try {
+    const result = await client.getPrompt(arg);
+    push("info", formatPromptMessages(arg, result));
+  } catch (err) {
+    push("warning", `getPrompt failed: ${(err as Error).message}`);
+  }
+}

src/cli/ui/multiline-keys.ts

@@ -0,0 +1,318 @@
+/**
+ * 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).
+ *
+ * CSI recovery is delegated to `key-normalize.ts` — see there for
+ * the rationale. Every event flows through `recoverCsiTail` first,
+ * which is the single source of truth for the Windows ConPTY case
+ * (parse-keypress eats the leading `\x1b` and routes the bare
+ * `[A`/`[C`/`[201~`/etc. through useInput as plain text).
+ */
+
+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;
+  /**
+   * When set, the key was ↑/↓ at a buffer boundary (empty buffer, or
+   * cursor already at first/last line) and the component should hand
+   * off to the parent's history-recall handler. The child's cursor
+   * didn't move; the parent decides whether to swap in a prior
+   * prompt. Lets users escape out of a multi-line buffer into
+   * history without first emptying it — previously NOOP felt stuck.
+   */
+  historyHandoff?: "prev" | "next";
+  /**
+   * Multi-char paste detected. The reducer is pure so it can't
+   * allocate a sentinel id or write to the registry — it hands the
+   * raw normalized payload up to PromptInput, which registers the
+   * paste, picks a sentinel codepoint, and inserts THAT (one char)
+   * into the buffer. Result: the user sees a `[paste #N · M lines]`
+   * placeholder instead of the full content drowning the typed text.
+   */
+  pasteRequest?: { content: string };
+}
+
+import { recoverCsiTail, stripCsiFragments } from "./key-normalize.js";
+
+const BACKSLASH_SUFFIX = /\\$/;
+
+const NOOP: MultilineAction = { next: null, cursor: null, submit: false };
+
+export function processMultilineKey(
+  value: string,
+  cursor: number,
+  keyIn: MultilineKey,
+): MultilineAction {
+  // CSI recovery — bare `[A` / `[C` / `[Z` / `[5~` / etc. that
+  // Windows ConPTY leaves in `input` after parse-keypress eats the
+  // leading `\x1b`. See key-normalize.ts for the long version.
+  const recovered = recoverCsiTail(keyIn.input, keyIn);
+  const key: MultilineKey = recovered ? { ...keyIn, ...recovered, input: "" } : keyIn;
+
+  // Parent-owned keys: Tab (slash-complete), Esc (abort).
+  if (key.tab || key.escape) {
+    return NOOP;
+  }
+
+  // Buffer-wide navigation. Per-line motion (↑/↓ / Ctrl+A / Ctrl+E)
+  // is already covered; PageUp/PageDown are the missing "jump to
+  // top / bottom of the WHOLE buffer" pair, useful after pasting a
+  // 500-line blob where ↑×500 is absurd. Repurposed from the
+  // previous NOOP behavior (PageUp/Down had no binding).
+  if (key.pageUp) {
+    return cursor === 0 ? NOOP : { next: null, cursor: 0, submit: false };
+  }
+  if (key.pageDown) {
+    return cursor === value.length ? NOOP : { next: null, cursor: value.length, submit: false };
+  }
+
+  // History recall is bound to Ctrl+P / Ctrl+N (bash readline
+  // convention) rather than ↑/↓. Reason: Windows Terminal + ConPTY
+  // translates mouse wheel events to ↑/↓ keystrokes for raw-mode
+  // child processes — indistinguishable at the byte level. If ↑/↓
+  // recalled history, every wheel-scroll would corrupt the prompt
+  // with a prior message. Ctrl+P/N is wheel-immune.
+  if (key.ctrl && key.input === "p") {
+    return { ...NOOP, historyHandoff: "prev" };
+  }
+  if (key.ctrl && key.input === "n") {
+    return { ...NOOP, historyHandoff: "next" };
+  }
+
+  // Cursor motion. Empty single-line buffer + ↑/↓ is now a no-op
+  // (used to recall history; see Ctrl+P/N comment above).
+  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 };
+  }
+  // Bash / readline conventions:
+  //   Ctrl+U — clear the whole buffer (readline treats this as
+  //     "clear from cursor to start"; for our text-area we treat it
+  //     as "clear all" because there's no ergonomic way to clear a
+  //     huge paste otherwise).
+  //   Ctrl+W — delete the word before the cursor.
+  if (key.ctrl && key.input === "u") {
+    return value.length === 0 ? NOOP : { next: "", cursor: 0, submit: false };
+  }
+  if (key.ctrl && key.input === "w") {
+    if (cursor === 0) return NOOP;
+    const wordStart = previousWordStart(value, cursor);
+    return {
+      next: value.slice(0, wordStart) + value.slice(cursor),
+      cursor: wordStart,
+      submit: false,
+    };
+  }
+
+  // Paste-burst detection. If `input` contains a newline (or
+  // bracketed-paste markers from a terminal that supports them),
+  // this is a paste — surface it as a `pasteRequest` so the parent
+  // can register the blob and insert ONE sentinel codepoint instead
+  // of the full content. The buffer stays small + readable; the
+  // user sees `[paste #N · M lines]` where the paste lives.
+  //
+  // Always overrides `key.return` for pastes: Ink occasionally sets
+  // key.return when a paste's trailing \n looks like Enter, which
+  // would submit the partial buffer mid-paste and silently truncate
+  // the content. Pastes always insert; Enter only submits typed
+  // content. We normalize \r\n and bare \r to \n so mixed-line-
+  // ending pastes (Windows clipboard, web copy) land cleanly.
+  // Strip every recognised CSI fragment (paste markers, arrow tails,
+  // etc.) defensively — if any leaked past structured-key recovery
+  // they shouldn't get inserted into the buffer as text.
+  const stripped = stripCsiFragments(key.input);
+  // Paste = newline-containing input with MORE than just the newline
+  // itself. A bare "\n" is Ctrl+J / one-keystroke newline (handled
+  // below); only multi-char input wrapped around a newline is a real
+  // paste burst that warrants a sentinel.
+  const looksLikePaste =
+    stripped.length > 1 && (stripped.includes("\n") || stripped.includes("\r"));
+  if (looksLikePaste) {
+    const normalized = stripped.replace(/\r\n?/g, "\n");
+    return {
+      next: null,
+      cursor: null,
+      submit: false,
+      pasteRequest: { content: normalized },
+    };
+  }
+  // Single-char Ctrl+J / LF: insert one newline.
+  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;
+}
+
+/**
+ * Find the start of the word immediately to the left of the cursor.
+ * Skips trailing whitespace first (so Ctrl+W after typing space
+ * still removes the previous word, not just the space), then walks
+ * back over the word characters until a whitespace boundary or
+ * start-of-buffer. Newlines count as whitespace, so Ctrl+W at the
+ * start of a line deletes the preceding line's last word — same
+ * behavior as bash/readline.
+ */
+function previousWordStart(value: string, cursor: number): number {
+  let i = cursor;
+  while (i > 0 && /\s/.test(value[i - 1] ?? "")) i--;
+  while (i > 0 && !/\s/.test(value[i - 1] ?? "")) i--;
+  return i;
+}
+
+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/paste-collapse.ts

@@ -0,0 +1,81 @@
+/**
+ * Collapse long user-typed input for display purposes.
+ *
+ * Problem: pasting a stack trace, log dump, or sample file into the
+ * prompt box floods the Historical scrollback with a huge block — the
+ * user can't see their previous turns, the assistant's replies, or
+ * where the cursor is. Terminal UIs have shipped this shape for
+ * years (iTerm's "pasted text" notation, Claude Code's preview).
+ *
+ * Split of concerns: the MODEL still gets the full text. This helper
+ * only rewrites what we render in the Historical row. `@` expansions
+ * and `!` bang outputs have their own display paths (unaffected).
+ */
+
+/** Defaults tuned to typical prose vs. typical code-paste shapes. */
+export const DEFAULT_PASTE_LINE_THRESHOLD = 40;
+export const DEFAULT_PASTE_CHAR_THRESHOLD = 2000;
+/** Lines kept visible at the head of a collapsed paste. */
+export const DEFAULT_PASTE_HEAD_LINES = 10;
+
+export interface PasteCollapseOptions {
+  lineThreshold?: number;
+  charThreshold?: number;
+  headLines?: number;
+}
+
+export interface PasteCollapseResult {
+  /** Text to render in the Historical row (possibly collapsed). */
+  displayText: string;
+  /** True when collapsing happened. False = input passed through verbatim. */
+  collapsed: boolean;
+  /** Original char length — exposed so callers can log/annotate. */
+  originalChars: number;
+  /** Original line count. */
+  originalLines: number;
+}
+
+/**
+ * Collapse `input` when it exceeds either the line OR char threshold.
+ * Display shape:
+ *
+ *     ▸ pasted 2.3 KB (84 lines) — first 10 shown, full text sent to model
+ *     line 1
+ *     line 2
+ *     …
+ *     line 10
+ *     … (74 more lines)
+ *
+ * Short input passes through unchanged — collapsed = false.
+ */
+export function formatLongPaste(
+  input: string,
+  opts: PasteCollapseOptions = {},
+): PasteCollapseResult {
+  const lineCap = opts.lineThreshold ?? DEFAULT_PASTE_LINE_THRESHOLD;
+  const charCap = opts.charThreshold ?? DEFAULT_PASTE_CHAR_THRESHOLD;
+  const headN = Math.max(1, opts.headLines ?? DEFAULT_PASTE_HEAD_LINES);
+
+  const originalChars = input.length;
+  const lines = input.split("\n");
+  const originalLines = lines.length;
+
+  if (originalChars <= charCap && originalLines <= lineCap) {
+    return { displayText: input, collapsed: false, originalChars, originalLines };
+  }
+
+  const header = `▸ pasted ${formatBytes(originalChars)} (${originalLines} lines) — first ${Math.min(headN, originalLines)} shown, full text sent to model`;
+  const head = lines.slice(0, headN).join("\n");
+  const remaining = originalLines - headN;
+  const footer = remaining > 0 ? `… (${remaining} more line${remaining === 1 ? "" : "s"})` : "";
+  const displayText = footer ? `${header}\n${head}\n${footer}` : `${header}\n${head}`;
+  return { displayText, collapsed: true, originalChars, originalLines };
+}
+
+function formatBytes(n: number): string {
+  if (n < 1024) return `${n} B`;
+  const kb = n / 1024;
+  if (kb < 1024) return `${kb.toFixed(kb >= 10 ? 0 : 1)} KB`;
+  const mb = kb / 1024;
+  return `${mb.toFixed(mb >= 10 ? 0 : 1)} MB`;
+}

src/cli/ui/paste-sentinels.ts

@@ -0,0 +1,133 @@
+/**
+ * Paste sentinels — represent a pasted blob as a single codepoint in
+ * the input buffer instead of inlining its full contents.
+ *
+ * Why: a 3000-line paste shoved verbatim into the buffer drowns the
+ * surrounding typed text, costs a lot to render per keystroke, and
+ * makes navigation/clear awkward. Replace it with one PUA char (a
+ * "sentinel") and store the real content in a side registry. The
+ * buffer string stays small, the user types around the sentinel as
+ * if it were a single character, and a Backspace at the sentinel
+ * deletes the whole paste in one stroke. On submit we expand the
+ * sentinels back to real content.
+ *
+ * Encoding:
+ *   - One codepoint per paste, in PUA range U+E100..U+E1FF (256 slots).
+ *   - The codepoint's offset within that range is the paste id.
+ *   - That gives us 256 distinct paste blobs per session before ids
+ *     wrap. In practice users paste a handful per session — wrap is
+ *     a non-issue, but if it happens, the new paste overwrites the
+ *     oldest registry entry; any stale sentinels still in the buffer
+ *     will render with a "(missing)" badge so the user can clean up.
+ *
+ * Range chosen from the Supplementary PUA-A region's neighbor (BMP
+ * PUA) so a single `String.fromCharCode` works — no surrogate pairs,
+ * no `length === 2` weirdness for cursor arithmetic.
+ */
+
+export const PASTE_SENTINEL_BASE = 0xe100;
+export const PASTE_SENTINEL_RANGE = 256;
+export const PASTE_SENTINEL_END = PASTE_SENTINEL_BASE + PASTE_SENTINEL_RANGE;
+
+export interface PasteEntry {
+  id: number;
+  content: string;
+  lineCount: number;
+  charCount: number;
+}
+
+export function encodePasteSentinel(id: number): string {
+  if (id < 0 || id >= PASTE_SENTINEL_RANGE) {
+    throw new Error(`paste sentinel id ${id} out of range [0, ${PASTE_SENTINEL_RANGE})`);
+  }
+  return String.fromCharCode(PASTE_SENTINEL_BASE + id);
+}
+
+/** Returns the paste id, or `null` if `ch` is not a sentinel codepoint. */
+export function decodePasteSentinel(ch: string): number | null {
+  if (ch.length === 0) return null;
+  const cp = ch.charCodeAt(0);
+  if (cp < PASTE_SENTINEL_BASE || cp >= PASTE_SENTINEL_END) return null;
+  return cp - PASTE_SENTINEL_BASE;
+}
+
+export function isPasteSentinel(ch: string): boolean {
+  return decodePasteSentinel(ch) !== null;
+}
+
+/**
+ * Build a PasteEntry from raw paste content. Computes line + char
+ * counts once at registration time so the renderer doesn't re-count
+ * on every keystroke.
+ */
+export function makePasteEntry(id: number, content: string): PasteEntry {
+  return {
+    id,
+    content,
+    lineCount: content.split("\n").length,
+    charCount: content.length,
+  };
+}
+
+/**
+ * Expand every sentinel in `text` back to its registered paste
+ * content. Unknown sentinels (entry missing — registry was wiped, or
+ * id wrap collision) drop to empty string so the resulting prompt
+ * doesn't carry a literal PUA codepoint to the model.
+ *
+ * Used at submit time to recover the full prompt the user composed.
+ */
+export function expandPasteSentinels(
+  text: string,
+  pastes: ReadonlyMap<number, PasteEntry>,
+): string {
+  let out = "";
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i]!;
+    const id = decodePasteSentinel(ch);
+    if (id === null) {
+      out += ch;
+      continue;
+    }
+    const entry = pastes.get(id);
+    out += entry?.content ?? "";
+  }
+  return out;
+}
+
+/**
+ * Quick check: does the buffer contain ANY sentinel? Used to gate
+ * UI hints (the "paste #N" listing in the prompt-box footer) without
+ * walking the whole buffer twice.
+ */
+export function bufferHasPaste(text: string): boolean {
+  for (let i = 0; i < text.length; i++) {
+    if (decodePasteSentinel(text[i]!) !== null) return true;
+  }
+  return false;
+}
+
+/**
+ * Walk the buffer and return the ids of every sentinel still
+ * present, in source order. Used by the registry's GC pass at
+ * submit time so unreachable paste entries don't accumulate.
+ * (No-op when the buffer is sentinel-free.)
+ */
+export function listPasteIdsInBuffer(text: string): number[] {
+  const ids: number[] = [];
+  for (let i = 0; i < text.length; i++) {
+    const id = decodePasteSentinel(text[i]!);
+    if (id !== null) ids.push(id);
+  }
+  return ids;
+}
+
+/**
+ * Format `1234` chars as `1.2KB` etc. Tiny helper used in placeholder
+ * labels — kept here so paste-related display logic is co-located.
+ */
+export function formatBytesShort(n: number): string {
+  if (n < 1024) return `${n}B`;
+  if (n < 1024 * 1024) return `${(n / 1024).toFixed(n < 1024 * 10 ? 1 : 0)}KB`;
+  return `${(n / (1024 * 1024)).toFixed(1)}MB`;
+}

src/cli/ui/presets.ts

@@ -0,0 +1,118 @@
+/**
+ * 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, reasoning effort, or thinking mode independently
+ * — they pick "fast / smart / max" and we translate.
+ *
+ * Design rules (v0.6+):
+ *   - Branching (`branch >= 2`) is NEVER in a preset. Self-consistency
+ *     sampling is `N×` cost; auto-enabling it would ambush users into
+ *     multi-dollar turns without asking. Opt-in only via `/branch N`.
+ *   - Harvest (Pillar-2 plan-state extraction) is NEVER in a preset.
+ *     In practice it's display sugar — the typed plan state hasn't
+ *     fed back into orchestration decisions (branch trigger) often
+ *     enough to pay for the extra round-trip. Opt-in only via
+ *     `/harvest on`.
+ *   - The three tiers differ on only TWO knobs: model (flash/pro) and
+ *     reasoning effort (high/max). Same on-the-wire billing axis,
+ *     easy to reason about, easy to budget.
+ */
+
+import type { PresetName } from "../../config.js";
+
+export interface PresetSettings {
+  model: string;
+  /**
+   * Reasoning-effort cap. `high` = shorter chain of thought; `max` =
+   * agent-class default (deeper, more output). Effort is now decoupled
+   * from preset — a separate `/effort` knob lets users tune it
+   * orthogonally. The PRESETS table just picks the safest default.
+   */
+  reasoningEffort: "high" | "max";
+  /**
+   * Auto-escalation switch. `auto` keeps the legacy NEEDS_PRO + failure
+   * threshold behavior; `flash` and `pro` lock to the chosen model.
+   */
+  autoEscalate: boolean;
+  /** Pillar-2 harvest. Always false in presets — opt-in via /harvest. */
+  harvest: boolean;
+  /** Branch budget. Always 1 in presets — opt-in via /branch. */
+  branch: number;
+}
+
+/**
+ * The three real presets. Old names (`fast / smart / max`) stay alive
+ * as aliases mapped through `resolvePreset` so a config.json that
+ * predates this rename still works without a migration script.
+ */
+export const PRESETS: Record<"auto" | "flash" | "pro", PresetSettings> = {
+  // auto — flash baseline + auto-escalate to pro when the model emits
+  // <<<NEEDS_PRO>>> OR after 3+ tool failure signals in one turn.
+  // The default: cheap when easy, smart when hard.
+  auto: {
+    model: "deepseek-v4-flash",
+    reasoningEffort: "max",
+    autoEscalate: true,
+    harvest: false,
+    branch: 1,
+  },
+  // flash — always flash, never escalate. `/pro` still arms a single
+  // manual turn; auto-promotion is the thing this disables. Use when
+  // you want predictable cost per turn.
+  flash: {
+    model: "deepseek-v4-flash",
+    reasoningEffort: "max",
+    autoEscalate: false,
+    harvest: false,
+    branch: 1,
+  },
+  // pro — always pro. Hard pin; the model never downgrades. Use for
+  // multi-turn architecture work where flash is just going to keep
+  // escalating anyway and the back-and-forth wastes turns.
+  pro: {
+    model: "deepseek-v4-pro",
+    reasoningEffort: "max",
+    autoEscalate: false,
+    harvest: false,
+    branch: 1,
+  },
+};
+
+export const PRESET_DESCRIPTIONS: Record<
+  "auto" | "flash" | "pro",
+  { headline: string; cost: string }
+> = {
+  auto: {
+    headline: "flash → pro on hard turns",
+    cost: "default · ~96% turns stay on flash · pro kicks in only when needed",
+  },
+  flash: {
+    headline: "v4-flash always",
+    cost: "cheapest · predictable · /pro still works for a one-turn bump",
+  },
+  pro: {
+    headline: "v4-pro always",
+    cost: "~3× flash (5/31 discount) / ~12× full price · for hard multi-turn work",
+  },
+};
+
+/**
+ * Resolve a preset name (canonical or unknown) to its settings.
+ * Anything that isn't `auto | flash | pro` — including the dropped
+ * legacy `fast / smart / max` aliases — collapses to `auto`. Simpler
+ * than mapping legacy values (each legacy name had its own semantics
+ * that don't 1:1 onto the new model-commitment vocabulary); auto is
+ * the safe default and the user can re-pick explicitly.
+ */
+export function resolvePreset(name: PresetName | undefined): PresetSettings {
+  if (name === "auto" || name === "flash" || name === "pro") return PRESETS[name];
+  return PRESETS.auto;
+}
+
+/** Canonical name for storage / display — unknown values become auto. */
+export function canonicalPresetName(name: PresetName | undefined): "auto" | "flash" | "pro" {
+  if (name === "auto" || name === "flash" || name === "pro") return name;
+  return "auto";
+}

src/cli/ui/prompt-viewport.ts

@@ -0,0 +1,318 @@
+/**
+ * Pure helpers for rendering one logical line of the prompt input as
+ * exactly one visual row, regardless of how wide the line's content
+ * is. Splitting this out from PromptInput so the math is testable
+ * without React/Ink.
+ *
+ * Why we can't trust Ink/Yoga's text wrap: Ink uses `string-width` to
+ * measure cells, but on CJK Windows terminals some glyphs render at
+ * a different cell count than `string-width` reports. The terminal
+ * wraps to a 2nd visual row, Ink's eraseLines miscounts, and the
+ * scrollback fills with ghost rows from the previous frame's leak.
+ *
+ * Our fix is to never let the line wrap. We slice the text down to
+ * the visible-cell budget ourselves and feed Ink a single Text whose
+ * width is known to fit.
+ *
+ * Cursor visibility: when the user types past the visible width the
+ * window slides so the cursor stays in view. `‹` and `›` markers
+ * appear at the trimmed edges so the user can see content is hidden
+ * to one side.
+ */
+
+import { type PasteEntry, decodePasteSentinel, formatBytesShort } from "./paste-sentinels.js";
+
+/**
+ * One renderable atom of a viewport. The line's content is broken
+ * into a sequence of these so a paste sentinel becomes a magenta
+ * `[paste #N · Ml · KKB]` block while the surrounding text stays
+ * normal.
+ */
+export type Segment = { kind: "text"; text: string } | { kind: "paste"; id: number; label: string };
+
+export interface Viewport {
+  /** Segments to render left-to-right. Sum of cells <= visibleCells. */
+  segments: Segment[];
+  /**
+   * Visual cell column at which to draw the cursor block, measured
+   * from the start of the viewport (0 = leftmost cell after the
+   * prompt prefix). `null` means cursor is not on this line — the
+   * caller renders a static line.
+   */
+  cursorCell: number | null;
+  /** True when content was clipped on the left side. */
+  hiddenLeft: boolean;
+  /** True when content was clipped on the right side. */
+  hiddenRight: boolean;
+}
+
+/**
+ * Cell width of a single character in a typical terminal grid.
+ *
+ * Approximation of Unicode East Asian Width=Wide / W treatment.
+ * Range table is intentionally compact — covers the codepoints we
+ * see in practice (CJK ideographs, fullwidth forms, Hangul syllables,
+ * Hiragana / Katakana). Anything outside the wide ranges counts as
+ * one cell. Control characters count as zero so we don't over-budget
+ * for them.
+ *
+ * Not a full `string-width` clone. We deliberately don't honour the
+ * "Ambiguous=2 in CJK locale" rule because it produces inconsistent
+ * results across terminals and is the very source of Ink's wrap
+ * miscount. Treating ambiguous chars as 1 cell here matches what
+ * Ink/Yoga also does, so our slice math agrees with what Ink would
+ * have rendered (had it not wrapped).
+ */
+export function charCells(ch: string): number {
+  if (ch.length === 0) return 0;
+  const code = ch.charCodeAt(0);
+  if (code < 0x20 || code === 0x7f) return 0;
+  if (code < 0x1100) return 1;
+  // Hangul Jamo
+  if (code >= 0x1100 && code <= 0x115f) return 2;
+  // CJK Radicals, Kangxi Radicals, Ideographic Description, CJK Symbols
+  if (code >= 0x2e80 && code <= 0x303e) return 2;
+  // Hiragana, Katakana, Bopomofo, Hangul Compat Jamo, Kanbun
+  if (code >= 0x3041 && code <= 0x33ff) return 2;
+  // CJK Unified Ext A
+  if (code >= 0x3400 && code <= 0x4dbf) return 2;
+  // CJK Unified Ideographs
+  if (code >= 0x4e00 && code <= 0x9fff) return 2;
+  // Yi Syllables
+  if (code >= 0xa000 && code <= 0xa4cf) return 2;
+  // Hangul Syllables
+  if (code >= 0xac00 && code <= 0xd7a3) return 2;
+  // CJK Compatibility Ideographs
+  if (code >= 0xf900 && code <= 0xfaff) return 2;
+  // CJK Compatibility Forms
+  if (code >= 0xfe30 && code <= 0xfe4f) return 2;
+  // Halfwidth and Fullwidth Forms (fullwidth half is wide)
+  if (code >= 0xff00 && code <= 0xff60) return 2;
+  // Fullwidth signs
+  if (code >= 0xffe0 && code <= 0xffe6) return 2;
+  return 1;
+}
+
+/** Total cells of a string, with paste sentinels expanded to placeholder width. */
+export function stringCells(s: string, pastes?: ReadonlyMap<number, PasteEntry>): number {
+  let n = 0;
+  for (let i = 0; i < s.length; i++) {
+    const ch = s[i]!;
+    const id = decodePasteSentinel(ch);
+    if (id !== null) {
+      n += pasteSentinelCells(id, pastes);
+    } else {
+      n += charCells(ch);
+    }
+  }
+  return n;
+}
+
+/** Paste sentinel placeholder width — what we'd render for that sentinel. */
+export function pasteSentinelLabel(id: number, entry: PasteEntry | undefined): string {
+  if (!entry) return `[paste #${id + 1} · (missing)]`;
+  return `[paste #${id + 1} · ${entry.lineCount}l · ${formatBytesShort(entry.charCount)}]`;
+}
+
+function pasteSentinelCells(id: number, pastes?: ReadonlyMap<number, PasteEntry>): number {
+  const entry = pastes?.get(id);
+  return pasteSentinelLabel(id, entry).length;
+}
+
+/**
+ * Compute the viewport for a line, keeping the cursor visible. When
+ * the line's total cells fit in `visibleCells`, return the whole
+ * line. Otherwise slice a window centred on the cursor with `‹` /
+ * `›` markers indicating clipped sides.
+ *
+ * `cursorCol` is the cursor's char index within `line` (0 = before
+ * first char; `line.length` = past last char). Pass `null` for
+ * lines that don't host the cursor — the function returns a left-
+ * aligned static viewport with truncation on the right.
+ */
+export function buildViewport(
+  line: string,
+  cursorCol: number | null,
+  visibleCells: number,
+  pastes?: ReadonlyMap<number, PasteEntry>,
+): Viewport {
+  if (visibleCells <= 0) {
+    return {
+      segments: [],
+      cursorCell: cursorCol === null ? null : 0,
+      hiddenLeft: false,
+      hiddenRight: line.length > 0,
+    };
+  }
+  const totalCells = stringCells(line, pastes);
+
+  // Fast path: whole line fits.
+  if (totalCells <= visibleCells) {
+    const segments = textToSegments(line, pastes);
+    let cursorCell: number | null = null;
+    if (cursorCol !== null) {
+      cursorCell = stringCells(line.slice(0, cursorCol), pastes);
+    }
+    return { segments, cursorCell, hiddenLeft: false, hiddenRight: false };
+  }
+
+  // Static viewport (cursor not on this line) — clip from the right.
+  if (cursorCol === null) {
+    return clipFromLeft(line, visibleCells, pastes);
+  }
+
+  // Cursor-bearing line: slide a window so cursor stays visible.
+  // Reserve 1 cell on each potentially-clipped side for the marker.
+  return clipAroundCursor(line, cursorCol, visibleCells, pastes);
+}
+
+function clipFromLeft(
+  line: string,
+  visibleCells: number,
+  pastes?: ReadonlyMap<number, PasteEntry>,
+): Viewport {
+  // Show as much of the head as fits; mark the right edge as hidden.
+  // Reserve 1 cell for the `›` marker.
+  const budget = Math.max(1, visibleCells - 1);
+  let used = 0;
+  let end = 0;
+  while (end < line.length) {
+    const ch = line[end]!;
+    const cw = charCellsAt(line, end, pastes);
+    if (used + cw > budget) break;
+    used += cw;
+    end++;
+  }
+  const segments = textToSegments(line.slice(0, end), pastes);
+  return { segments, cursorCell: null, hiddenLeft: false, hiddenRight: end < line.length };
+}
+
+/**
+ * Sliding window around the cursor. Algorithm:
+ *
+ *  1. Start with `start` and `end` both at the cursor index.
+ *  2. Expand `end` rightward while there's budget, until cursor cell
+ *     visible or we hit end-of-line.
+ *  3. Expand `start` leftward to fill remaining budget.
+ *  4. Reserve 1 cell on each clipped side for the `‹`/`›` marker.
+ *
+ * The cursor cell is computed AFTER the slice is fixed, by counting
+ * cells from `start` up to `cursorCol`.
+ */
+function clipAroundCursor(
+  line: string,
+  cursorCol: number,
+  visibleCells: number,
+  pastes?: ReadonlyMap<number, PasteEntry>,
+): Viewport {
+  // `cursorCol` is between 0 and line.length (inclusive). The cursor
+  // visually sits BEFORE the char at line[cursorCol] (or after the
+  // last char when cursorCol === line.length).
+  // We want both the char at the cursor (if any) AND a cell of cursor
+  // padding visible.
+
+  // Budget — leave 1 cell for each marker we may need.
+  let budget = visibleCells;
+  // Right marker: needed if we don't reach end of line.
+  // Left marker: needed if start > 0.
+  // We don't know in advance, so allocate conservatively: -2 cells.
+  const reservedForMarkers = 2;
+  budget = Math.max(1, budget - reservedForMarkers);
+
+  // Try to keep cursor roughly centred. Start by aiming `start` ~
+  // halfway behind cursorCol.
+  const halfBudget = Math.floor(budget / 2);
+
+  // Walk left from cursor, accumulating cells, until we've spent
+  // halfBudget OR hit the start of the line.
+  let start = cursorCol;
+  let leftCells = 0;
+  while (start > 0 && leftCells < halfBudget) {
+    const cw = charCellsAt(line, start - 1, pastes);
+    if (leftCells + cw > halfBudget) break;
+    start--;
+    leftCells += cw;
+  }
+
+  // Walk right from cursor, filling the remaining budget. We always
+  // include a cell for the cursor itself if line[cursorCol] exists
+  // (since the cursor block covers that char). At end-of-line we
+  // include a phantom cell of cursor space.
+  const rightBudget = budget - leftCells;
+  let end = cursorCol;
+  let rightCells = 0;
+  // Include the char at the cursor (1 or 2 cells depending on width)
+  // if there is one.
+  const cursorChar = cursorCol < line.length ? charCellsAt(line, cursorCol, pastes) : 1;
+  if (rightBudget >= cursorChar) {
+    if (cursorCol < line.length) end = cursorCol + 1;
+    rightCells = cursorChar;
+    while (end < line.length && rightCells < rightBudget) {
+      const cw = charCellsAt(line, end, pastes);
+      if (rightCells + cw > rightBudget) break;
+      rightCells += cw;
+      end++;
+    }
+  }
+
+  // If we have leftover right-budget and there's still room on the
+  // left, expand leftwards more (cursor stays towards the right
+  // edge but more left context is shown — common when typing at
+  // end of a long line).
+  let extraLeftBudget = rightBudget - rightCells;
+  while (start > 0 && extraLeftBudget > 0) {
+    const cw = charCellsAt(line, start - 1, pastes);
+    if (cw > extraLeftBudget) break;
+    start--;
+    leftCells += cw;
+    extraLeftBudget -= cw;
+  }
+
+  const hiddenLeft = start > 0;
+  const hiddenRight = end < line.length;
+  const segments = textToSegments(line.slice(start, end), pastes);
+  // Cursor cell relative to the start of the slice. Markers are
+  // rendered separately by the caller — they don't shift the
+  // segment-relative offset so we don't add them here.
+  const cursorCell = stringCells(line.slice(start, cursorCol), pastes);
+  return { segments, cursorCell, hiddenLeft, hiddenRight };
+}
+
+function charCellsAt(line: string, idx: number, pastes?: ReadonlyMap<number, PasteEntry>): number {
+  const ch = line[idx]!;
+  const id = decodePasteSentinel(ch);
+  if (id !== null) {
+    const entry = pastes?.get(id);
+    return pasteSentinelLabel(id, entry).length;
+  }
+  return charCells(ch);
+}
+
+/**
+ * Walk the string and split it into text/paste segments. Pure —
+ * doesn't allocate per-character objects (text runs accumulate in a
+ * single segment). Used by both the fast and clipped paths.
+ */
+export function textToSegments(line: string, pastes?: ReadonlyMap<number, PasteEntry>): Segment[] {
+  const out: Segment[] = [];
+  let buf = "";
+  const flushBuf = () => {
+    if (buf.length > 0) {
+      out.push({ kind: "text", text: buf });
+      buf = "";
+    }
+  };
+  for (let i = 0; i < line.length; i++) {
+    const ch = line[i]!;
+    const id = decodePasteSentinel(ch);
+    if (id !== null) {
+      flushBuf();
+      const label = pasteSentinelLabel(id, pastes?.get(id));
+      out.push({ kind: "paste", id, label });
+    } else {
+      buf += ch;
+    }
+  }
+  flushBuf();
+  return out;
+}

src/cli/ui/slash.ts

@@ -1,157 +1,20 @@
-import type { CacheFirstLoop } from "../../loop.js";
-import { deleteSession, listSessions } from "../../session.js";
-
-export interface SlashResult {
-  /** Text to display back to the user as a system/info line. */
-  info?: string;
-  /** Exit the app. */
-  exit?: boolean;
-  /** Clear the visible history. */
-  clear?: boolean;
-  /** Unknown command — display usage hint. */
-  unknown?: boolean;
-}
-
-export function parseSlash(text: string): { cmd: string; args: string[] } | null {
-  if (!text.startsWith("/")) return null;
-  const parts = text.slice(1).trim().split(/\s+/);
-  const cmd = parts[0]?.toLowerCase() ?? "";
-  if (!cmd) return null;
-  return { cmd, args: parts.slice(1) };
-}
-
-export function handleSlash(cmd: string, args: string[], loop: CacheFirstLoop): SlashResult {
-  switch (cmd) {
-    case "exit":
-    case "quit":
-      return { exit: true };
-
-    case "clear":
-      return { clear: true };
-
-    case "help":
-    case "?":
-      return {
-        info: [
-          "Commands:",
-          "  /help                    this message",
-          "  /status                  show current settings",
-          "  /preset <fast|smart|max> one-tap presets — see below",
-          "  /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",
-          "  /sessions                list saved sessions (current is marked with ▸)",
-          "  /forget                  delete the current session from disk",
-          "  /clear                   clear displayed history (log + session kept)",
-          "  /exit                    quit",
-          "",
-          "Presets:",
-          "  fast   deepseek-chat   no harvest  no branch    ~1¢/100turns  ← default",
-          "  smart  reasoner        harvest                  ~10x cost, slower",
-          "  max    reasoner        harvest     branch 3     ~30x cost, slowest",
-          "",
-          "Sessions (auto-enabled by default, named 'default'):",
-          "  reasonix chat --session <name>   use a different named session",
-          "  reasonix chat --no-session       disable persistence for this run",
-        ].join("\n"),
-      };
-
-    case "sessions": {
-      const items = listSessions();
-      if (items.length === 0) {
-        return {
-          info: "no saved sessions yet — chat normally and your messages will be saved automatically",
-        };
-      }
-      const lines = ["Saved sessions:"];
-      for (const s of items) {
-        const sizeKb = (s.size / 1024).toFixed(1);
-        const when = s.mtime.toISOString().replace("T", " ").slice(0, 16);
-        const marker = s.name === loop.sessionName ? "▸" : " ";
-        lines.push(
-          `  ${marker} ${s.name.padEnd(22)} ${String(s.messageCount).padStart(5)} msgs  ${sizeKb.padStart(7)} KB  ${when}`,
-        );
-      }
-      lines.push("");
-      lines.push("Resume with: reasonix chat --session <name>");
-      return { info: lines.join("\n") };
-    }
-
-    case "forget": {
-      if (!loop.sessionName) {
-        return { info: "not in a session — nothing to forget" };
-      }
-      const name = loop.sessionName;
-      const ok = deleteSession(name);
-      return {
-        info: ok
-          ? `▸ deleted session "${name}" — current screen still shows the conversation, but next launch starts fresh`
-          : `could not delete session "${name}" (already gone?)`,
-      };
-    }
-
-    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"}`,
-      };
-    }
-
-    case "model": {
-      const id = args[0];
-      if (!id) return { info: "usage: /model <id>   (try deepseek-chat or deepseek-reasoner)" };
-      loop.configure({ model: id });
-      return { info: `model → ${id}` };
-    }
-
-    case "harvest": {
-      const arg = (args[0] ?? "").toLowerCase();
-      const on = arg === "" ? !loop.harvestEnabled : arg === "on" || arg === "true" || arg === "1";
-      loop.configure({ harvest: on });
-      return { info: `harvest → ${loop.harvestEnabled ? "on" : "off"}` };
-    }
-
-    case "preset": {
-      const name = (args[0] ?? "").toLowerCase();
-      if (name === "fast" || name === "default") {
-        loop.configure({ model: "deepseek-chat", harvest: false, branch: 1 });
-        return { info: "preset → fast  (deepseek-chat, no harvest, no branch)" };
-      }
-      if (name === "smart") {
-        loop.configure({ model: "deepseek-reasoner", harvest: true, branch: 1 });
-        return { info: "preset → smart  (reasoner + harvest, ~10x cost vs fast)" };
-      }
-      if (name === "max" || name === "best") {
-        loop.configure({ model: "deepseek-reasoner", harvest: true, branch: 3 });
-        return {
-          info: "preset → max  (reasoner + harvest + branch3, ~30x cost vs fast, slowest)",
-        };
-      }
-      return { info: "usage: /preset <fast|smart|max>" };
-    }
-
-    case "branch": {
-      const raw = (args[0] ?? "").toLowerCase();
-      if (raw === "" || raw === "off" || raw === "0" || raw === "1") {
-        loop.configure({ branch: 1 });
-        return { info: "branch → off" };
-      }
-      const n = Number.parseInt(raw, 10);
-      if (!Number.isFinite(n) || n < 2) {
-        return { info: "usage: /branch <N>   (N>=2, or 'off')" };
-      }
-      if (n > 8) {
-        return { info: "branch budget capped at 8 to prevent runaway cost" };
-      }
-      loop.configure({ branch: n });
-      return { info: `branch → ${n}  (harvest auto-enabled; streaming disabled)` };
-    }
-
-    default:
-      return { unknown: true, info: `unknown command: /${cmd}  (try /help)` };
-  }
-}
+// Slash-command barrel. Public surface is stable across the slash/
+// split — App.tsx, tests, and sibling components continue to import
+// { handleSlash, parseSlash, suggestSlashCommands, SLASH_COMMANDS, ... }
+// from "./slash.js". Everything below is re-exported from the per-topic
+// modules under ./slash/.
+export {
+  SLASH_COMMANDS,
+  detectSlashArgContext,
+  parseSlash,
+  suggestSlashCommands,
+} from "./slash/commands.js";
+export { handleSlash } from "./slash/dispatch.js";
+export type { SlashHandler } from "./slash/dispatch.js";
+export type {
+  McpServerSummary,
+  SlashArgContext,
+  SlashCommandSpec,
+  SlashContext,
+  SlashResult,
+} from "./slash/types.js";

src/cli/ui/slash/commands.ts

@@ -0,0 +1,273 @@
+import type { SlashArgContext, SlashCommandSpec } from "./types.js";
+
+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",
+    argCompleter: ["fast", "smart", "max"],
+  },
+  {
+    cmd: "model",
+    argsHint: "<id>",
+    summary: "switch DeepSeek model id",
+    argCompleter: "models",
+  },
+  { cmd: "models", summary: "list available models fetched from DeepSeek /models" },
+  {
+    cmd: "harvest",
+    argsHint: "[on|off]",
+    summary: "toggle Pillar-2 plan-state extraction",
+    argCompleter: ["on", "off"],
+  },
+  {
+    cmd: "branch",
+    argsHint: "<N|off>",
+    summary: "run N parallel samples per turn (N>=2)",
+    argCompleter: ["off", "2", "3", "4", "5"],
+  },
+  {
+    cmd: "effort",
+    argsHint: "<high|max>",
+    summary: "reasoning_effort cap — max is default (agent-class), high is cheaper/faster",
+    argCompleter: ["max", "high"],
+  },
+  {
+    cmd: "pro",
+    argsHint: "[off]",
+    summary: "arm v4-pro for the NEXT turn only (one-shot · auto-disarms after turn)",
+    argCompleter: ["off"],
+  },
+  { cmd: "mcp", summary: "list MCP servers + tools attached to this session" },
+  {
+    cmd: "resource",
+    argsHint: "[uri]",
+    summary: "browse + read MCP resources (no arg → list URIs; <uri> → fetch contents)",
+    argCompleter: "mcp-resources",
+  },
+  {
+    cmd: "prompt",
+    argsHint: "[name]",
+    summary: "browse + fetch MCP prompts (no arg → list names; <name> → render prompt)",
+    argCompleter: "mcp-prompts",
+  },
+  { 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: "hooks",
+    argsHint: "[reload]",
+    summary: "list active hooks (settings.json under .reasonix/) · reload re-reads from disk",
+  },
+  {
+    cmd: "permissions",
+    argsHint: "[list|add <prefix>|remove <prefix|N>|clear confirm]",
+    summary:
+      "show / edit shell allowlist (builtin read-only · per-project: ~/.reasonix/config.json)",
+    argCompleter: ["list", "add", "remove", "clear"],
+  },
+  {
+    cmd: "dashboard",
+    argsHint: "[stop]",
+    summary: "launch the embedded web dashboard (127.0.0.1, token-gated)",
+    argCompleter: ["stop"],
+  },
+  {
+    cmd: "cwd",
+    argsHint: "<path>",
+    summary:
+      "switch session working directory (re-registers code tools, reloads hooks; MCP servers stay)",
+  },
+  {
+    cmd: "update",
+    summary: "show current vs latest version + the shell command to upgrade",
+  },
+  {
+    cmd: "stats",
+    summary:
+      "cross-session cost dashboard (today / week / month / all-time · cache hit · vs Claude)",
+  },
+  { cmd: "think", summary: "dump the last turn's full R1 reasoning (reasoner only)" },
+  {
+    cmd: "context",
+    summary: "break down where context tokens are going: system / tools / per-turn log",
+  },
+  { cmd: "retry", summary: "truncate & resend your last message (fresh sample)" },
+  {
+    cmd: "compact",
+    argsHint: "[tokens]",
+    summary:
+      "shrink oversized tool results AND tool-call args (edit_file search/replace) in the log; cap in tokens, default 4000",
+  },
+  { cmd: "keys", summary: "show all keyboard shortcuts and prompt prefixes" },
+  { cmd: "plans", summary: "list this session's active + archived plans, newest first" },
+  {
+    cmd: "replay",
+    summary: "load an archived plan as a read-only Time Travel snapshot (default: newest)",
+    argsHint: "[N]",
+  },
+  { 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: "semantic",
+    summary: "show semantic_search status — built? Ollama installed? how to enable",
+  },
+  { cmd: "clear", summary: "clear visible scrollback only (log/context kept)" },
+  { cmd: "new", summary: "start a fresh conversation (clear context + scrollback)" },
+  {
+    cmd: "loop",
+    argsHint: "<5s..6h> <prompt>  ·  stop  ·  (no args = status)",
+    summary: "auto-resubmit <prompt> every <interval> until you type something / Esc / /loop stop",
+  },
+  { cmd: "exit", summary: "quit the TUI" },
+  // Code-mode only
+  {
+    cmd: "init",
+    argsHint: "[force]",
+    summary:
+      "scan the project and synthesize a baseline REASONIX.md (model writes; review with /apply). `force` overwrites an existing file.",
+    contextual: "code",
+    argCompleter: ["force"],
+  },
+  {
+    cmd: "apply",
+    argsHint: "[N|N,M|N-M]",
+    summary:
+      "commit pending edit blocks to disk (no arg → all; `1`, `1,3`, or `1-4` → that subset, rest stay pending)",
+    contextual: "code",
+  },
+  {
+    cmd: "discard",
+    argsHint: "[N|N,M|N-M]",
+    summary: "drop pending edit blocks without writing (no arg → all; indices → that subset)",
+    contextual: "code",
+  },
+  {
+    cmd: "walk",
+    summary:
+      "step through pending edits one block at a time (git-add-p style: y/n per block, a apply rest, A flip AUTO)",
+    contextual: "code",
+  },
+  { cmd: "undo", summary: "roll back the last applied edit batch", contextual: "code" },
+  {
+    cmd: "history",
+    summary: "list every edit batch this session (ids for /show, undone markers)",
+    contextual: "code",
+  },
+  {
+    cmd: "show",
+    argsHint: "[id]",
+    summary: "dump a stored edit diff (omit id for newest non-undone)",
+    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",
+    argCompleter: ["on", "off"],
+  },
+  {
+    cmd: "apply-plan",
+    summary: "force-approve a pending / in-text plan (fallback if picker was missed)",
+    contextual: "code",
+  },
+  {
+    cmd: "mode",
+    argsHint: "[review|auto|yolo]",
+    summary:
+      "edit-gate: review (queue) · auto (apply+undo) · yolo (apply+auto-shell). Shift+Tab cycles.",
+    contextual: "code",
+    argCompleter: ["review", "auto", "yolo"],
+  },
+  { cmd: "jobs", summary: "list background jobs started by run_background", contextual: "code" },
+  {
+    cmd: "kill",
+    argsHint: "<id>",
+    summary: "stop a background job by id (SIGTERM → SIGKILL after grace)",
+    contextual: "code",
+  },
+  {
+    cmd: "logs",
+    argsHint: "<id> [lines]",
+    summary: "tail a background job's output (default last 80 lines)",
+    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);
+  });
+}
+
+/**
+ * Classify the prompt buffer for argument completion. Returns `null`
+ * when the buffer isn't in a slash-with-args state.
+ *
+ * Firing shape: input must start with `/<cmd> ` (space after a known
+ * command). The character right after the space through end-of-buffer
+ * is the "arg tail"; if the tail has NO internal whitespace the
+ * picker is live (tail is the partial). If the tail has whitespace,
+ * the user has moved past the first argument position and we surface
+ * the usage hint only.
+ */
+export function detectSlashArgContext(input: string, codeMode = false): SlashArgContext | null {
+  // `/cmd <rest>` — one space, rest captured up to end-of-buffer.
+  const m = /^\/(\S+) ([\s\S]*)$/.exec(input);
+  if (!m) return null;
+  const cmdName = m[1]!.toLowerCase();
+  const tail = m[2] ?? "";
+  const spec = SLASH_COMMANDS.find(
+    (s) => s.cmd === cmdName && (s.contextual !== "code" || codeMode),
+  );
+  if (!spec) return null;
+  const hasInternalSpace = /\s/.test(tail);
+  const partialOffset = input.length - tail.length;
+  if (hasInternalSpace) {
+    // Past the first arg position (typing the second arg for e.g.
+    // `/edit <file> <instruction>`, or mid-sentence for free-form).
+    return { spec, partial: tail, partialOffset, kind: "hint" };
+  }
+  // No internal whitespace — we're still typing the first arg. Picker
+  // is live if the spec declares a completer; otherwise show a hint
+  // ("what goes here?") since the user's guessing.
+  return {
+    spec,
+    partial: tail,
+    partialOffset,
+    kind: spec.argCompleter ? "picker" : "hint",
+  };
+}
+
+export function parseSlash(text: string): { cmd: string; args: string[] } | null {
+  if (!text.startsWith("/")) return null;
+  const parts = text.slice(1).trim().split(/\s+/);
+  const cmd = parts[0]?.toLowerCase() ?? "";
+  if (!cmd) return null;
+  return { cmd, args: parts.slice(1) };
+}

src/cli/ui/slash/dispatch.ts

@@ -0,0 +1,62 @@
+import type { CacheFirstLoop } from "../../../loop.js";
+import { handlers as adminHandlers } from "./handlers/admin.js";
+import { handlers as basicHandlers } from "./handlers/basic.js";
+import { handlers as dashboardHandlers } from "./handlers/dashboard.js";
+import { handlers as editsHandlers } from "./handlers/edits.js";
+import { handlers as initHandlers } from "./handlers/init.js";
+import { handlers as jobsHandlers } from "./handlers/jobs.js";
+import { handlers as mcpHandlers } from "./handlers/mcp.js";
+import { handlers as memoryHandlers } from "./handlers/memory.js";
+import { handlers as modelHandlers } from "./handlers/model.js";
+import { handlers as observabilityHandlers } from "./handlers/observability.js";
+import { handlers as permissionsHandlers } from "./handlers/permissions.js";
+import { handlers as plansHandlers } from "./handlers/plans.js";
+import { handlers as semanticHandlers } from "./handlers/semantic.js";
+import { handlers as sessionsHandlers } from "./handlers/sessions.js";
+import { handlers as skillHandlers } from "./handlers/skill.js";
+import type { SlashContext, SlashResult } from "./types.js";
+
+/**
+ * A slash handler receives the command's args + the loop + shared
+ * runtime context, and returns a synchronous SlashResult. Async work
+ * (balance fetches, stop_job) fires-and-forgets via `ctx.postInfo`
+ * instead — keeps the TUI input non-blocking.
+ */
+export type SlashHandler = (args: string[], loop: CacheFirstLoop, ctx: SlashContext) => SlashResult;
+
+/**
+ * Flat map of cmd → handler. Composed from per-topic modules so each
+ * feature's logic stays local; aliases (e.g. `exit` / `quit`) are just
+ * extra keys in the per-module handlers bag pointing at the same fn.
+ *
+ * Ordering of the spread matters only for duplicate keys; there are
+ * none. Keep alphabetical for diff sanity when adding modules.
+ */
+const HANDLERS: Record<string, SlashHandler> = {
+  ...adminHandlers,
+  ...basicHandlers,
+  ...dashboardHandlers,
+  ...editsHandlers,
+  ...initHandlers,
+  ...jobsHandlers,
+  ...mcpHandlers,
+  ...memoryHandlers,
+  ...modelHandlers,
+  ...observabilityHandlers,
+  ...permissionsHandlers,
+  ...plansHandlers,
+  ...semanticHandlers,
+  ...sessionsHandlers,
+  ...skillHandlers,
+};
+
+export function handleSlash(
+  cmd: string,
+  args: string[],
+  loop: CacheFirstLoop,
+  ctx: SlashContext = {},
+): SlashResult {
+  const h = HANDLERS[cmd];
+  if (h) return h(args, loop, ctx);
+  return { unknown: true, info: `unknown command: /${cmd}  (try /help)` };
+}

src/cli/ui/slash/handlers/admin.ts

@@ -0,0 +1,220 @@
+import { existsSync, statSync } from "node:fs";
+import * as pathMod from "node:path";
+import {
+  HOOK_EVENTS,
+  type HookEvent,
+  type ResolvedHook,
+  globalSettingsPath,
+  projectSettingsPath,
+} from "../../../../hooks.js";
+import { aggregateUsage, defaultUsageLogPath, readUsageLog } from "../../../../usage.js";
+import { VERSION, compareVersions, isNpxInstall } from "../../../../version.js";
+import { renderDashboard } from "../../../commands/stats.js";
+import type { SlashHandler } from "../dispatch.js";
+
+const hooks: SlashHandler = (args, loop, ctx) => {
+  const sub = (args[0] ?? "").toLowerCase();
+
+  if (sub === "reload") {
+    if (!ctx.reloadHooks) {
+      return {
+        info: "/hooks reload is not available in this context (no reload callback wired).",
+      };
+    }
+    const count = ctx.reloadHooks();
+    return { info: `▸ reloaded hooks · ${count} active` };
+  }
+
+  if (sub !== "" && sub !== "list" && sub !== "ls") {
+    return {
+      info: "usage: /hooks            list active hooks\n       /hooks reload     re-read settings.json files",
+    };
+  }
+
+  const all = loop.hooks;
+  const projPath = ctx.codeRoot ? projectSettingsPath(ctx.codeRoot) : undefined;
+  const globPath = globalSettingsPath();
+  if (all.length === 0) {
+    const lines = [
+      "no hooks configured.",
+      "",
+      "drop a settings.json with a `hooks` key into either of:",
+      ctx.codeRoot
+        ? `  · ${projPath} (project)`
+        : "  · <project>/.reasonix/settings.json (project)",
+      `  · ${globPath} (global)`,
+      "",
+      "events: PreToolUse, PostToolUse, UserPromptSubmit, Stop",
+      "exit 0 = pass · exit 2 = block (Pre*) · other = warn",
+    ];
+    return { info: lines.join("\n") };
+  }
+
+  const grouped = new Map<HookEvent, ResolvedHook[]>();
+  for (const event of HOOK_EVENTS) grouped.set(event, []);
+  for (const h of all) grouped.get(h.event)?.push(h);
+
+  const lines: string[] = [`▸ ${all.length} hook(s) loaded`];
+  for (const event of HOOK_EVENTS) {
+    const list = grouped.get(event) ?? [];
+    if (list.length === 0) continue;
+    lines.push("", `${event}:`);
+    for (const h of list) {
+      const match = h.match && h.match !== "*" ? ` match=${h.match}` : "";
+      const desc = h.description ? `  — ${h.description}` : "";
+      lines.push(`  [${h.scope}]${match} ${h.command}${desc}`);
+    }
+  }
+  lines.push("", `sources: project=${projPath ?? "(none — chat mode)"} · global=${globPath}`);
+  return { info: lines.join("\n") };
+};
+
+/**
+ * `/update` — inside the TUI we deliberately do NOT spawn `npm install`.
+ * stdio:inherit into a running Ink renderer corrupts the display, and
+ * the process being upgraded is the same process that's still reading
+ * its own binaries (messy on Windows). Instead we surface what we
+ * already know from the App's background registry check and print the
+ * exact shell command the user should run after exiting.
+ *
+ * The `latestVersion` ctx field is populated by App.tsx's mount-time
+ * `getLatestVersion()` effect. When it's `null` we report the check
+ * as pending/offline — still a useful output (current version + how
+ * to force a fresh check from another terminal).
+ */
+const update: SlashHandler = (_args, _loop, ctx) => {
+  const latest = ctx.latestVersion ?? null;
+  const lines: string[] = [`current: reasonix ${VERSION}`];
+  if (latest === null) {
+    // Kick off a fresh fetch so a follow-up /update a few seconds
+    // later has a real answer instead of the same pending message.
+    ctx.refreshLatestVersion?.();
+    lines.push(
+      "latest:  (not yet resolved — background check in flight or offline)",
+      "",
+      "triggered a fresh registry fetch — retry `/update` in a few seconds,",
+      "or run `reasonix update` in another terminal to force it synchronously.",
+    );
+    return { info: lines.join("\n") };
+  }
+  lines.push(`latest:  reasonix ${latest}`);
+  const diff = compareVersions(VERSION, latest);
+  if (diff >= 0) {
+    lines.push("", "you're on the latest. nothing to do.");
+    return { info: lines.join("\n") };
+  }
+  if (isNpxInstall()) {
+    lines.push(
+      "",
+      "you're running via npx — the next `npx reasonix ...` launch will auto-fetch.",
+      "to force a refresh sooner: `npm cache clean --force`.",
+    );
+  } else {
+    lines.push(
+      "",
+      "to upgrade, exit this session and run:",
+      "  reasonix update           (interactive, dry-run supported via --dry-run)",
+      "  npm install -g reasonix@latest   (direct)",
+      "",
+      "in-session install is deliberately disabled — the npm spawn would",
+      "corrupt this TUI's rendering and Windows can lock the running binary.",
+    );
+  }
+  return { info: lines.join("\n") };
+};
+
+/**
+ * `/stats` — dashboard view of `~/.reasonix/usage.jsonl`, the same
+ * roll-up `reasonix stats` (no arg) prints at the shell. Synchronous
+ * disk read; cheap enough that we don't bother caching between slash
+ * invocations.
+ *
+ * No transcript-path variant in-TUI: the per-file summary is scripty
+ * and rarely wanted mid-session. If someone needs it they have the
+ * CLI form (`reasonix stats <path>`).
+ */
+const stats: SlashHandler = () => {
+  const path = defaultUsageLogPath();
+  const records = readUsageLog(path);
+  if (records.length === 0) {
+    return {
+      info: [
+        "no usage data yet.",
+        "",
+        `  ${path}`,
+        "",
+        "every turn you run here appends one record — this session's turns",
+        "will show up in the dashboard once you send a message.",
+      ].join("\n"),
+    };
+  }
+  const agg = aggregateUsage(records);
+  return { info: renderDashboard(agg, path) };
+};
+
+/**
+ * `/cwd <path>` — switch the session working directory mid-session.
+ * Validates the target (must exist, must be a directory), normalizes
+ * to an absolute path with `~` expansion, then defers the actual swap
+ * to the App-supplied `setCwd` callback. The callback updates hook
+ * cwd, memory root, project shell allowlist root, `@file` mention
+ * root, and (in code mode) re-registers filesystem / shell / memory /
+ * skill tools — see App.tsx for the wiring.
+ *
+ * MCP servers do NOT follow the cwd switch — their stdio child was
+ * spawned with the original cwd at session start, and there's no
+ * standard "reconnect with new cwd" handshake. The handler surfaces
+ * a one-line warning when MCP servers are present so users aren't
+ * surprised by tools still resolving paths against the old root.
+ */
+const cwd: SlashHandler = (args, _loop, ctx) => {
+  if (!ctx.setCwd) {
+    return {
+      info: "/cwd is not available in this context (no setCwd callback wired).",
+    };
+  }
+  const raw = (args[0] ?? "").trim();
+  if (!raw) {
+    return {
+      info: "usage: /cwd <path>   (absolute or relative, ~ expands to home)",
+    };
+  }
+  const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
+  const expanded = raw.startsWith("~") && home ? pathMod.join(home, raw.slice(1)) : raw;
+  const abs = pathMod.resolve(expanded);
+  if (!existsSync(abs)) {
+    return { info: `▸ /cwd: path does not exist — ${abs}` };
+  }
+  let isDir = false;
+  try {
+    isDir = statSync(abs).isDirectory();
+  } catch {
+    // Permission denied or transient FS error — treat as not-a-dir
+    // and let the user see the exact path so they can investigate.
+  }
+  if (!isDir) {
+    return { info: `▸ /cwd: not a directory — ${abs}` };
+  }
+  let info: string;
+  try {
+    info = ctx.setCwd(abs);
+  } catch (err) {
+    return { info: `▸ /cwd failed: ${(err as Error).message}` };
+  }
+  const lines = [info];
+  if (ctx.mcpServers && ctx.mcpServers.length > 0) {
+    lines.push(
+      `  note: ${ctx.mcpServers.length} MCP server(s) still anchored to the original cwd —`,
+      "        their tools won't follow this switch. Restart the session for full reset.",
+    );
+  }
+  return { info: lines.join("\n") };
+};
+
+export const handlers: Record<string, SlashHandler> = {
+  hook: hooks,
+  hooks,
+  cwd,
+  update,
+  stats,
+};

src/cli/ui/slash/handlers/basic.ts

@@ -0,0 +1,218 @@
+import { formatDuration, formatLoopStatus, parseLoopCommand } from "../../loop.js";
+import type { SlashHandler } from "../dispatch.js";
+
+const exit: SlashHandler = () => ({ exit: true });
+
+const clear: SlashHandler = () => ({
+  clear: true,
+  info: "▸ terminal cleared (viewport + scrollback). Context (message log) is intact — next turn still sees everything. Use /new to start fresh, or /forget to delete the session entirely.",
+});
+
+const resetLog: SlashHandler = (_args, loop) => {
+  // 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.`,
+  };
+};
+
+const keys: SlashHandler = () => ({
+  info: [
+    "Keyboard & prompt shortcuts:",
+    "",
+    "  Enter                  submit the current prompt",
+    "  Shift+Enter  /  Ctrl+J  insert a newline (multi-line prompt)",
+    "  \\<Enter>               bash-style line continuation",
+    "  ← → ↑ ↓                move cursor / recall history at buffer boundary",
+    "  PageUp / PageDown      jump to top / bottom of the WHOLE buffer (handy after a big paste)",
+    "  Ctrl+A / Ctrl+E        jump to start / end of the CURRENT line",
+    "  Ctrl+U                 clear the entire input buffer",
+    "  Ctrl+W                 delete the word before the cursor",
+    "  Backspace              delete left;  Delete   delete under cursor",
+    "  Esc                    abort the in-flight turn",
+    "  y / n                  accept / reject pending edits (code mode)",
+    "  Shift+Tab              cycle edit gate: review ↔ AUTO (code mode, persists to config)",
+    "  u                      undo the latest non-undone edit batch (session-wide, not just banner)",
+    "",
+    "Prompt prefixes:",
+    "  /<name>                slash command; Tab/Enter picks from the suggestion list",
+    "  @<path>                inline a file under [Referenced files] (code mode).",
+    "                           Trailing `@…` opens a file picker; ↑/↓ navigate, Tab/Enter pick.",
+    "  @https://...           fetch the URL, strip HTML, inline under [Referenced URLs].",
+    "                           Cached per session — same URL twice fetches once.",
+    "  !<cmd>                 run <cmd> as shell in the sandbox root; output goes into context",
+    "                           so the model sees it next turn. No allowlist gate.",
+    "  #<note>                append <note> to <project>/REASONIX.md (committable, team-shared).",
+    "  #g <note>              append <note> to ~/.reasonix/REASONIX.md (global, never committed).",
+    "                           Both pin into the immutable prefix every future session.",
+    "                           Use `\\#literal` if you actually want a `#` heading sent to the model.",
+    "",
+    "Pickers (slash + @-mention):",
+    "  ↑ / ↓                  navigate the suggestion list",
+    "  Tab                    insert the highlighted item without submitting",
+    "  Enter                  insert and (slash) run it, (@) keep editing",
+    "",
+    "MCP exploration:",
+    "  /mcp                   servers + tool/resource/prompt counts",
+    "  /resource [uri]        browse & read resources exposed by your MCP servers",
+    "  /prompt [name]         browse & fetch prompts exposed by your MCP servers",
+    "",
+    "Useful slashes: /help · /context · /stats · /compact · /new · /exit",
+  ].join("\n"),
+});
+
+const help: SlashHandler = () => ({
+  info: [
+    "Commands:",
+    "  /help                    this message",
+    "  /keys                    keyboard shortcuts + prompt prefixes (!, @, /)",
+    "  /status                  show current settings",
+    "  /preset <fast|smart|max> one-tap presets — see below",
+    "  /model <id>              deepseek-v4-flash or deepseek-v4-pro",
+    "  /pro [off]               arm v4-pro for NEXT turn only (one-shot, auto-disarms)",
+    "  /harvest [on|off]        Pillar 2: structured plan-state extraction (OPT-IN — costs extra)",
+    "  /branch <N|off>          run N parallel samples (N>=2) — MANUAL ONLY, N× cost",
+    "  /effort <high|max>       reasoning_effort cap (max=full thinking, high=cheaper/faster)",
+    "  /mcp                     list MCP servers + tools attached to this session",
+    "  /resource [uri]          browse + read MCP resources (no arg → list URIs; <uri> → fetch)",
+    "  /prompt [name]           browse + fetch MCP prompts (no arg → list names; <name> → render)",
+    "  /setup                   (exit + reconfigure) → run `reasonix setup`",
+    "  /compact [tokens]        shrink large tool results in history (default 4000 tokens/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 [N|1,3|1-4]       (code mode) commit pending edit blocks (no arg → all; index → subset)",
+    "  /discard [N|1,3|1-4]     (code mode) drop pending edits (no arg → all; index → subset)",
+    "  /walk                    (code mode) step through pending edits one block at a time (y/n per block, a apply rest, A flip AUTO)",
+    "  /undo                    (code mode) roll back the latest non-undone edit batch",
+    "  /history                 (code mode) list every edit batch this session",
+    "  /show [id]               (code mode) dump a stored edit diff (newest when id omitted)",
+    '  /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)",
+    "  /mode [review|auto|yolo] (code mode) review = queue · auto = apply+undo banner · yolo = apply+auto-shell. Shift+Tab cycles all three.",
+    "  /jobs                    (code mode) list background processes (run_background) — running and exited",
+    "  /kill <id>               (code mode) stop a background job by id (SIGTERM → SIGKILL)",
+    "  /logs <id> [lines]       (code mode) tail a background job's output (default 80 lines)",
+    "  /sessions                list saved sessions (current is marked with ▸)",
+    "  /forget                  delete the current session from disk",
+    "  /new                     start fresh: drop all context + clear scrollback",
+    "  /clear                   clear displayed scrollback only (context kept — model still sees it)",
+    "  /loop <interval> <prompt> auto-resubmit <prompt> every <interval> (5s..6h). /loop stop · type anything to cancel.",
+    "  /exit                    quit",
+    "",
+    "Shell shortcut:",
+    "  !<cmd>                   run <cmd> in the sandbox root; output goes into",
+    "                             the conversation so the model sees it next turn.",
+    "                             No allowlist gate — user-typed = explicit consent.",
+    "                             Example: !git status   !ls src/   !npm test",
+    "",
+    "Quick memory:",
+    "  #<note>                  append <note> to <project>/REASONIX.md (committable).",
+    "                             Example: #findByEmail must be case-insensitive",
+    "  #g <note>                append <note> to ~/.reasonix/REASONIX.md (global, never committed).",
+    "                             Example: #g always run pnpm not npm",
+    "                             Both pin into every future session's prefix. Faster than /memory.",
+    "                             Use `\\#text` to send a literal `#text` to the model.",
+    "",
+    "File references (code mode):",
+    "  @path/to/file            inline file content under [Referenced files] on send.",
+    "                             Type `@` to open the picker (↑↓ navigate, Tab/Enter pick).",
+    "",
+    "URL references:",
+    "  @https://example.com     fetch the URL, strip HTML, inline under [Referenced URLs].",
+    "                             Same URL twice in one session fetches once (in-mem cache).",
+    "                             Trailing sentence punctuation (./,/)) is stripped automatically.",
+    "",
+    "Presets (branch + harvest are NEVER auto-enabled — opt-in only):",
+    "  fast   v4-flash · effort=high          cheapest · quick Q&A, one-line edits",
+    "  smart  v4-flash · effort=max           ← default · day-to-day coding",
+    "  max    v4-pro   · effort=max           ~12× fast · hard single-shots",
+    "",
+    "Sessions (auto-enabled by default, named 'default'):",
+    "  reasonix chat --session <name>   use a different named session",
+    "  reasonix chat --no-session       disable persistence for this run",
+    "",
+    "Known limitation:",
+    "  Resizing the terminal mid-session may stack ghost header frames in",
+    "  scrollback (Ink library's live-region clear doesn't account for line",
+    "  re-wrapping at the new width). Scroll-up history is unaffected; the",
+    "  artifact is purely visual and clears the next time you /clear.",
+  ].join("\n"),
+});
+
+const setup: SlashHandler = () => ({
+  info:
+    "To reconfigure (preset, MCP servers, API key), exit this chat and run " +
+    "`reasonix setup`. Changes take effect on next launch.",
+});
+
+const retry: SlashHandler = (_args, loop) => {
+  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,
+  };
+};
+
+const loop: SlashHandler = (args, _loop, ctx) => {
+  if (!ctx.startLoop || !ctx.stopLoop || !ctx.getLoopStatus) {
+    return {
+      info: "/loop is only available in the interactive TUI (not in run/replay).",
+    };
+  }
+  const cmd = parseLoopCommand(args);
+  if (cmd.kind === "error") return { info: cmd.message };
+  if (cmd.kind === "stop") {
+    const wasActive = ctx.getLoopStatus() !== null;
+    ctx.stopLoop();
+    return {
+      info: wasActive ? "▸ loop stopped." : "no active loop to stop.",
+    };
+  }
+  if (cmd.kind === "status") {
+    const status = ctx.getLoopStatus();
+    if (!status) {
+      return {
+        info:
+          "no active loop. Start one with `/loop <interval> <prompt>` (e.g. /loop 30s npm test).\n" +
+          "Cancels on: /loop stop · Esc · /clear · /new · any user-typed prompt.",
+      };
+    }
+    return { info: `▸ ${formatLoopStatus(status.prompt, status.nextFireMs, status.iter)}` };
+  }
+  // kind === "start"
+  ctx.startLoop(cmd.intervalMs, cmd.prompt);
+  return {
+    info: `▸ loop started — re-submitting "${cmd.prompt}" every ${formatDuration(
+      cmd.intervalMs,
+    )}. Type anything (or /loop stop) to cancel.`,
+  };
+};
+
+export const handlers: Record<string, SlashHandler> = {
+  exit,
+  quit: exit,
+  clear,
+  new: resetLog,
+  reset: resetLog,
+  keys,
+  help,
+  "?": help,
+  setup,
+  retry,
+  loop,
+};

src/cli/ui/slash/handlers/dashboard.ts

@@ -0,0 +1,69 @@
+import type { SlashHandler } from "../dispatch.js";
+
+/**
+ * `/dashboard [stop]` — boot the embedded web dashboard attached to
+ * the current session. The actual server start / state capture lives
+ * in App.tsx (`startDashboard` callback), which has direct refs to
+ * the live loop, tool registry, MCP servers, and edit-mode state.
+ * The slash handler is just the user-facing input + output bridge.
+ *
+ * Sub-commands:
+ *   /dashboard          → boot if not running, print URL; if running, print existing URL
+ *   /dashboard stop     → tear down the server
+ */
+const dashboard: SlashHandler = (args, _loop, ctx) => {
+  if (!ctx.startDashboard || !ctx.getDashboardUrl) {
+    return {
+      info: "/dashboard is not available in this context (no startDashboard callback wired).",
+    };
+  }
+
+  const sub = (args[0] ?? "").toLowerCase();
+
+  if (sub === "stop" || sub === "off") {
+    if (!ctx.stopDashboard) {
+      return { info: "/dashboard stop: no stop callback wired." };
+    }
+    const url = ctx.getDashboardUrl();
+    if (!url) return { info: "▸ dashboard is not running." };
+    // Fire-and-forget the async stop. Caller (App.tsx) handles errors
+    // by posting to historical.
+    ctx.stopDashboard();
+    return { info: "▸ dashboard stopping…" };
+  }
+
+  const existing = ctx.getDashboardUrl();
+  if (existing) {
+    return {
+      info: [
+        "▸ dashboard is already running:",
+        `  ${existing}`,
+        "",
+        "Open it in any browser. Type `/dashboard stop` to tear it down.",
+      ].join("\n"),
+    };
+  }
+
+  // Boot. Slash handlers are sync; we kick the start asynchronously
+  // and let App.tsx's `postInfo` deliver the URL when the server is
+  // listening.
+  ctx
+    .startDashboard()
+    .then((url) => {
+      ctx.postInfo?.(
+        [
+          "▸ dashboard ready:",
+          `  ${url}`,
+          "",
+          "127.0.0.1 only · token-gated. Type `/dashboard stop` to shut down.",
+        ].join("\n"),
+      );
+    })
+    .catch((err: Error) => {
+      ctx.postInfo?.(`▸ dashboard failed to start: ${err.message}`);
+    });
+
+  return { info: "▸ starting dashboard server…" };
+};
+
+export const handlers: Record<string, SlashHandler> = { dashboard };

src/cli/ui/slash/handlers/edits.ts

@@ -0,0 +1,182 @@
+import type { EditMode } from "../../../../config.js";
+import { parseEditIndices } from "../../edit-history.js";
+import type { SlashHandler } from "../dispatch.js";
+import { runGitCommit, stripOuterQuotes } from "../helpers.js";
+
+const undo: SlashHandler = (args, _loop, ctx) => {
+  if (!ctx.codeUndo) {
+    return {
+      info: "/undo is only available inside `reasonix code` — chat mode doesn't apply edits.",
+    };
+  }
+  return { info: ctx.codeUndo(args) };
+};
+
+const history: SlashHandler = (_args, _loop, ctx) => {
+  if (!ctx.codeHistory) {
+    return { info: "/history is only available inside `reasonix code`." };
+  }
+  return { info: ctx.codeHistory() };
+};
+
+const show: SlashHandler = (args, _loop, ctx) => {
+  if (!ctx.codeShowEdit) {
+    return { info: "/show is only available inside `reasonix code`." };
+  }
+  return { info: ctx.codeShowEdit(args) };
+};
+
+const apply: SlashHandler = (args, _loop, ctx) => {
+  if (!ctx.codeApply) {
+    return {
+      info: "/apply is only available inside `reasonix code` (nothing to apply here).",
+    };
+  }
+  const parsed = parseIndicesArg(args, ctx.pendingEditCount ?? 0);
+  if ("error" in parsed) return { info: `/apply: ${parsed.error}` };
+  return { info: ctx.codeApply(parsed.indices) };
+};
+
+const discard: SlashHandler = (args, _loop, ctx) => {
+  if (!ctx.codeDiscard) {
+    return {
+      info: "/discard is only available inside `reasonix code`.",
+    };
+  }
+  const parsed = parseIndicesArg(args, ctx.pendingEditCount ?? 0);
+  if ("error" in parsed) return { info: `/discard: ${parsed.error}` };
+  return { info: ctx.codeDiscard(parsed.indices) };
+};
+
+/**
+ * Bridge between the `args: string[]` shape commander gives us and the
+ * comma-separated index syntax users actually type ("/apply 1,3-4").
+ * The TUI's slash parser splits on whitespace, so `1,3-4` arrives as
+ * `["1,3-4"]` and `1, 3, 4` arrives as `["1,", "3,", "4"]`. Re-joining
+ * with commas + delegating to `parseEditIndices` handles both shapes.
+ *
+ * Empty `args` → `{ indices: [] }` (caller treats as "all").
+ */
+function parseIndicesArg(
+  args: readonly string[],
+  max: number,
+): { indices: readonly number[] } | { error: string } {
+  const raw = args.join(",").replace(/,+/g, ",").replace(/^,|,$/g, "");
+  if (!raw) return { indices: [] };
+  const parsed = parseEditIndices(raw, max);
+  if ("error" in parsed) return { error: parsed.error };
+  return { indices: parsed.ok };
+}
+
+const plan: SlashHandler = (args, _loop, ctx) => {
+  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.",
+  };
+};
+
+const applyPlan: SlashHandler = (_args, _loop, ctx) => {
+  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.",
+  };
+};
+
+const mode: SlashHandler = (args, _loop, ctx) => {
+  if (!ctx.setEditMode) {
+    return {
+      info: "/mode is only available inside `reasonix code`.",
+    };
+  }
+  const raw = (args[0] ?? "").toLowerCase();
+  const current = ctx.editMode ?? "review";
+  let target: EditMode;
+  if (raw === "review") target = "review";
+  else if (raw === "auto") target = "auto";
+  else if (raw === "yolo") target = "yolo";
+  else if (raw === "") {
+    // Bare /mode cycles review → auto → yolo → review, mirroring
+    // Shift+Tab. Users who just want to see current mode without
+    // flipping can read /status.
+    target = current === "review" ? "auto" : current === "auto" ? "yolo" : "review";
+  } else {
+    return {
+      info: "usage: /mode <review|auto|yolo>   (Shift+Tab also cycles)",
+    };
+  }
+  ctx.setEditMode(target);
+  const banner =
+    target === "yolo"
+      ? "▸ edit mode: YOLO — edits AND shell commands auto-run with no prompt. /undo still rolls back edits. Use carefully."
+      : target === "auto"
+        ? "▸ edit mode: AUTO — edits apply immediately; press u within 5s to undo, or /undo later. Shell commands still ask."
+        : "▸ edit mode: review — edits queue for /apply (or y) / /discard (or n)";
+  return { info: banner };
+};
+
+const commit: SlashHandler = (args, _loop, ctx) => {
+  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);
+};
+
+const walk: SlashHandler = (_args, _loop, ctx) => {
+  if (!ctx.startWalkthrough) {
+    return {
+      info: "/walk is only available inside `reasonix code`.",
+    };
+  }
+  return { info: ctx.startWalkthrough() };
+};
+
+export const handlers: Record<string, SlashHandler> = {
+  undo,
+  history,
+  show,
+  apply,
+  discard,
+  plan,
+  "apply-plan": applyPlan,
+  applyplan: applyPlan,
+  mode,
+  commit,
+  walk,
+};

src/cli/ui/slash/handlers/init.ts

@@ -0,0 +1,126 @@
+/**
+ * `/init` — auto-generate a baseline REASONIX.md by asking the model
+ * to scan the project and synthesize a concise summary.
+ *
+ * Mechanism: the slash handler injects a structured user-turn prompt
+ * (via `resubmit`) that hard-constrains the model to write a short,
+ * fact-only document and stop. It uses the same filesystem tools the
+ * model already has — no new tool, no new pipeline. The model's output
+ * lands as an `edit_file` (empty SEARCH = create new) or `write_file`
+ * SEARCH/REPLACE block, which goes through the normal /apply review
+ * gate so the user can audit before the file hits disk.
+ *
+ * Why this shape rather than a CLI command: REASONIX.md goes into
+ * the system prompt every session, so its content has to fit. A
+ * model-driven generator that runs inside the same loop the user
+ * will use later gives the most consistent output, and reusing the
+ * existing edit-review flow means we don't have to invent a
+ * separate "review the generated doc" UI.
+ */
+
+import { existsSync } from "node:fs";
+import * as pathMod from "node:path";
+import type { SlashHandler } from "../dispatch.js";
+
+/**
+ * The init brief. Sent verbatim as a user turn (via resubmit). Hard
+ * constraints up top because flash will skim and the structure of
+ * the document matters for system-prompt budget. The "STOP after
+ * writing" line is load-bearing — without it the model will follow
+ * up with "want me to also …" and burn turns on noise.
+ */
+const INIT_PROMPT = [
+  "# Task: Initialize REASONIX.md",
+  "",
+  "I want you to generate a REASONIX.md at the project root that captures",
+  "the working knowledge a future Reasonix session needs to be productive",
+  "here. This file is auto-pinned into your system prompt every launch,",
+  "so its size and accuracy matter.",
+  "",
+  "## Hard constraints (do NOT relax these)",
+  "",
+  "- **Length cap: ≤ 80 lines / 3KB total.** Be concise. If you can't fit a",
+  "  section, drop it.",
+  "- **Only document things you can verify by reading files.** Do NOT",
+  "  speculate about architectural intent, future roadmap, or design",
+  "  rationale. If it isn't obvious from the code, leave it out.",
+  "- **No placeholder text.** No 'TODO: describe X', no 'Add more here'.",
+  "  Either state a fact or omit the section.",
+  "",
+  "## Procedure",
+  "",
+  "1. Read the top of any existing README* file.",
+  "2. Read the manifest (package.json / Cargo.toml / pyproject.toml /",
+  "   go.mod / etc.) — pick whichever exists.",
+  "3. `directory_tree` 1-2 levels deep on the project root, skipping",
+  "   common build/dependency dirs (node_modules, dist, target, .git,",
+  "   venv, __pycache__).",
+  "4. Identify: primary language + framework, top-level layout, test",
+  "   runner, lint/format setup, build/run/test scripts, any non-obvious",
+  "   convention with visible evidence (commit message format, import",
+  "   order, naming pattern).",
+  "5. Write REASONIX.md with the sections below, skipping any you can't",
+  "   fill from evidence.",
+  "",
+  "## Sections to use (skip ones with no evidence)",
+  "",
+  "- **Stack** — language + framework + 3-5 key deps. One line each.",
+  "- **Layout** — top-level dirs and what lives in each. One line each.",
+  "- **Commands** — verbatim from `scripts` block (or equivalent):",
+  "  build / test / lint / typecheck / dev / format. Whatever exists.",
+  "- **Conventions** — only things visible in the code. Examples:",
+  "  '*.test.ts colocated with source', 'named exports only',",
+  "  'commits use Conventional Commits prefix'. If you can't find any",
+  "  CONVENTION evidence, omit the whole section.",
+  "- **Watch out for** — gotchas a new contributor would benefit from",
+  "  knowing BEFORE editing. Examples: 'edit_file SEARCH must match",
+  "  byte-for-byte', 'this dir is generated, don't edit by hand'.",
+  "  Omit if you find nothing concrete.",
+  "",
+  "## Output",
+  "",
+  "Write the result to `REASONIX.md` in the project root using the",
+  "filesystem tools (edit_file with empty SEARCH if creating new,",
+  "write_file if overwriting). After writing, STOP — do not summarize",
+  "what you did, do not propose follow-up tasks. The user will review",
+  "the pending edit via /apply.",
+  "",
+  "Start now.",
+].join("\n");
+
+const init: SlashHandler = (args, _loop, ctx) => {
+  if (!ctx.codeRoot) {
+    return {
+      info: [
+        "/init only works in code mode (it needs filesystem tools).",
+        "Run `reasonix code [path]` to start a session rooted at the",
+        "project you want to initialize, then run /init.",
+      ].join("\n"),
+    };
+  }
+  const force = (args[0] ?? "").toLowerCase() === "force";
+  const target = pathMod.join(ctx.codeRoot, "REASONIX.md");
+  if (existsSync(target) && !force) {
+    return {
+      info: [
+        `▸ REASONIX.md already exists at ${target}`,
+        "",
+        "  /init force   regenerate from scratch (overwrites)",
+        "",
+        "  Or edit it by hand — it's just markdown. The current file is",
+        "  pinned into the system prompt every launch as-is.",
+      ].join("\n"),
+    };
+  }
+  return {
+    info: [
+      "▸ /init — model will scan the project and synthesize REASONIX.md.",
+      "  The result lands as a pending edit; review with /apply or /walk.",
+    ].join("\n"),
+    resubmit: INIT_PROMPT,
+  };
+};
+
+export const handlers: Record<string, SlashHandler> = {
+  init,
+};

src/cli/ui/slash/handlers/jobs.ts

@@ -0,0 +1,84 @@
+import type { SlashHandler } from "../dispatch.js";
+
+const jobs: SlashHandler = (_args, _loop, ctx) => {
+  if (!ctx.jobs) {
+    return { info: "/jobs is only available inside `reasonix code`." };
+  }
+  const rows = ctx.jobs.list();
+  if (rows.length === 0) {
+    return { info: "no background jobs yet — use run_background to start one" };
+  }
+  const lines = ["Background jobs:"];
+  for (const r of rows) {
+    const age = ((Date.now() - r.startedAt) / 1000).toFixed(1);
+    const state = r.running
+      ? `running   · pid ${r.pid ?? "?"}`
+      : r.exitCode !== null
+        ? `exit ${r.exitCode}`
+        : r.spawnError
+          ? "failed"
+          : "stopped";
+    lines.push(
+      `  ${String(r.id).padStart(3)}  ${state.padEnd(20)}  ${age.padStart(6)}s ago   $ ${r.command}`,
+    );
+  }
+  lines.push("");
+  lines.push("/kill <id> to stop one · /logs <id> [lines] to tail output");
+  return { info: lines.join("\n") };
+};
+
+const kill: SlashHandler = (args, _loop, ctx) => {
+  if (!ctx.jobs) return { info: "/kill is only available inside `reasonix code`." };
+  const id = Number.parseInt(args[0] ?? "", 10);
+  if (!Number.isFinite(id)) return { info: "usage: /kill <id>   (see /jobs for ids)" };
+  const rec = ctx.jobs.list().find((r) => r.id === id);
+  if (!rec) return { info: `job ${id}: not found` };
+  if (!rec.running) return { info: `job ${id} already exited (${rec.exitCode ?? "?"})` };
+  // Fire-and-forget: the registry waits for grace + SIGKILL internally;
+  // returning immediately keeps the slash synchronous so the user's
+  // prompt doesn't lock up for 2s on every /kill. The postInfo
+  // callback lands a follow-up row in historical when the kill
+  // actually completes, so the user sees "job N stopped" without
+  // polling /jobs.
+  const jobsRef = ctx.jobs;
+  void (async () => {
+    const final = await jobsRef.stop(id);
+    if (!final) return;
+    const status = final.running
+      ? "still alive after SIGKILL (!) — report this as a bug"
+      : final.exitCode !== null
+        ? `exit ${final.exitCode}`
+        : "stopped";
+    ctx.postInfo?.(`▸ job ${id} ${status}`);
+  })();
+  return {
+    info: `▸ stopping job ${id} (tree kill: SIGTERM → SIGKILL after 2s grace; Windows: taskkill /T /F)`,
+  };
+};
+
+const logs: SlashHandler = (args, _loop, ctx) => {
+  if (!ctx.jobs) return { info: "/logs is only available inside `reasonix code`." };
+  const id = Number.parseInt(args[0] ?? "", 10);
+  if (!Number.isFinite(id)) {
+    return { info: "usage: /logs <id> [lines]   (default last 80 lines)" };
+  }
+  const requested = Number.parseInt(args[1] ?? "", 10);
+  const tail = Number.isFinite(requested) && requested > 0 ? requested : 80;
+  const out = ctx.jobs.read(id, { tailLines: tail });
+  if (!out) return { info: `job ${id}: not found` };
+  const status = out.running
+    ? `running · pid ${out.pid ?? "?"}`
+    : out.exitCode !== null
+      ? `exited ${out.exitCode}`
+      : out.spawnError
+        ? `failed (${out.spawnError})`
+        : "stopped";
+  const header = `[job ${id} · ${status}]\n$ ${out.command}`;
+  return { info: out.output ? `${header}\n${out.output}` : header };
+};
+
+export const handlers: Record<string, SlashHandler> = {
+  jobs,
+  kill,
+  logs,
+};

src/cli/ui/slash/handlers/mcp.ts

@@ -0,0 +1,64 @@
+import type { SlashHandler } from "../dispatch.js";
+import { appendSection } from "../helpers.js";
+
+const mcp: SlashHandler = (_args, loop, ctx) => {
+  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[] = [];
+    let anyResources = false;
+    let anyPrompts = false;
+    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);
+      if (report.resources.supported && report.resources.items.length > 0) anyResources = true;
+      if (report.prompts.supported && report.prompts.items.length > 0) anyPrompts = true;
+      lines.push("");
+    }
+    if (anyResources || anyPrompts) {
+      const hints: string[] = [];
+      if (anyResources) hints.push("`/resource` to browse+read");
+      if (anyPrompts) hints.push("`/prompt` to browse+fetch");
+      lines.push(hints.join(" · "));
+    } else {
+      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") };
+};
+
+export const handlers: Record<string, SlashHandler> = { mcp };

src/cli/ui/slash/handlers/memory.ts

@@ -0,0 +1,169 @@
+import {
+  PROJECT_MEMORY_FILE,
+  memoryEnabled,
+  readProjectMemory,
+} from "../../../../project-memory.js";
+import { type MemoryScope, MemoryStore } from "../../../../user-memory.js";
+import type { SlashHandler } from "../dispatch.js";
+import { resolveMemoryTarget } from "../helpers.js";
+
+/**
+ * `/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)
+ */
+const memory: SlashHandler = (args, _loop, ctx) => {
+  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") };
+};
+
+export const handlers: Record<string, SlashHandler> = { memory };

src/cli/ui/slash/handlers/model.ts

@@ -0,0 +1,187 @@
+import { saveReasoningEffort } from "../../../../config.js";
+import type { SlashHandler } from "../dispatch.js";
+
+const model: SlashHandler = (args, loop, ctx) => {
+  const id = args[0];
+  const known = ctx.models ?? null;
+  if (!id) {
+    const hint =
+      known && known.length > 0
+        ? known.join(" | ")
+        : "try deepseek-v4-flash or deepseek-v4-pro — run /models to fetch the live list";
+    return { info: `usage: /model <id>   (${hint})` };
+  }
+  loop.configure({ model: id });
+  // Soft validation: if we have the live list and the id isn't in
+  // it, flag a warning but still switch — DeepSeek may have just
+  // released something we haven't indexed yet, and refusing would
+  // be worse than a bad API error on the next call.
+  if (known && known.length > 0 && !known.includes(id)) {
+    return {
+      info: `model → ${id}   (⚠ not in the fetched catalog: ${known.join(", ")}. If this is wrong the next call will 400 — run /models to refresh.)`,
+    };
+  }
+  return { info: `model → ${id}` };
+};
+
+const models: SlashHandler = (_args, loop, ctx) => {
+  const list = ctx.models ?? null;
+  if (list === null) {
+    ctx.refreshModels?.();
+    return {
+      info: "fetching /models from DeepSeek… run /models again in a moment. If it stays empty, your API key may lack permission or the network is blocked.",
+    };
+  }
+  if (list.length === 0) {
+    return {
+      info: "DeepSeek /models returned an empty list. Try /models again, or check your account status at api-docs.deepseek.com.",
+    };
+  }
+  const current = loop.model;
+  const lines = list.map((id) => (id === current ? `▸ ${id}  (current)` : `  ${id}`));
+  return {
+    info: [
+      `Available models (DeepSeek /models · ${list.length} total):`,
+      "",
+      ...lines,
+      "",
+      "Switch with: /model <id>",
+    ].join("\n"),
+  };
+};
+
+const harvest: SlashHandler = (args, loop) => {
+  const arg = (args[0] ?? "").toLowerCase();
+  const on = arg === "" ? !loop.harvestEnabled : arg === "on" || arg === "true" || arg === "1";
+  loop.configure({ harvest: on });
+  if (loop.harvestEnabled) {
+    return {
+      info: "harvest → on  (Pillar-2 plan-state extraction · +1 cheap flash call per turn · opt-in only; no preset turns it on)",
+    };
+  }
+  return { info: "harvest → off" };
+};
+
+const preset: SlashHandler = (args, loop) => {
+  const name = (args[0] ?? "").toLowerCase();
+  // Persist the effort along with the preset change so a relaunch
+  // doesn't revert to the previously-saved /effort value.
+  const applyAndPersist = (effort: "high" | "max") => {
+    try {
+      saveReasoningEffort(effort);
+    } catch {
+      /* disk full / perms — runtime change still took effect */
+    }
+  };
+  if (name === "fast" || name === "default") {
+    loop.configure({
+      model: "deepseek-v4-flash",
+      reasoningEffort: "high",
+      harvest: false,
+      branch: 1,
+    });
+    applyAndPersist("high");
+    return { info: "preset → fast  (v4-flash · effort=high · cheapest)" };
+  }
+  if (name === "smart") {
+    loop.configure({
+      model: "deepseek-v4-flash",
+      reasoningEffort: "max",
+      harvest: false,
+      branch: 1,
+    });
+    applyAndPersist("max");
+    return { info: "preset → smart  (v4-flash · effort=max · default · ~1.5× fast)" };
+  }
+  if (name === "max" || name === "best") {
+    loop.configure({
+      model: "deepseek-v4-pro",
+      reasoningEffort: "max",
+      harvest: false,
+      branch: 1,
+    });
+    applyAndPersist("max");
+    return {
+      info: "preset → max  (v4-pro · effort=max · ~12× fast · save for hard tasks, or use /pro for a single-turn bump)",
+    };
+  }
+  return { info: "usage: /preset <fast|smart|max>" };
+};
+
+const branch: SlashHandler = (args, loop) => {
+  const raw = (args[0] ?? "").toLowerCase();
+  if (raw === "" || raw === "off" || raw === "0" || raw === "1") {
+    loop.configure({ branch: 1 });
+    return { info: "branch → off" };
+  }
+  const n = Number.parseInt(raw, 10);
+  if (!Number.isFinite(n) || n < 2) {
+    return { info: "usage: /branch <N>   (N>=2, or 'off')" };
+  }
+  if (n > 8) {
+    return { info: "branch budget capped at 8 to prevent runaway cost" };
+  }
+  loop.configure({ branch: n });
+  return {
+    info: `branch → ${n}  (runs ${n} parallel samples per turn · ${n}× per-turn cost · streaming disabled · manual only, no preset enables branching)`,
+  };
+};
+
+const effort: SlashHandler = (args, loop) => {
+  const raw = (args[0] ?? "").toLowerCase();
+  if (raw === "") {
+    return {
+      info: `reasoning_effort → ${loop.reasoningEffort}  (use /effort high for cheaper/faster, /effort max for the agent-class default · persisted across relaunches)`,
+    };
+  }
+  if (raw !== "high" && raw !== "max") {
+    return { info: "usage: /effort <high|max>" };
+  }
+  loop.configure({ reasoningEffort: raw });
+  // Persist so the next launch starts with this value instead of
+  // reverting to the constructor default.
+  try {
+    saveReasoningEffort(raw);
+  } catch {
+    /* disk full / perms — runtime change still took effect */
+  }
+  return { info: `reasoning_effort → ${raw} (persisted)` };
+};
+
+const pro: SlashHandler = (args, loop, ctx) => {
+  const arg = (args[0] ?? "").toLowerCase();
+  if (arg === "off" || arg === "cancel" || arg === "disarm") {
+    if (!loop.proArmed) {
+      return { info: "nothing armed — /pro with no args will arm pro for your next turn" };
+    }
+    if (ctx.disarmPro) ctx.disarmPro();
+    else loop.disarmPro();
+    return { info: "▸ /pro disarmed — next turn falls back to the current preset" };
+  }
+  if (arg && arg !== "on" && arg !== "arm") {
+    return {
+      info: "usage: /pro       arm pro for the next turn (one-shot, auto-disarms after)\n       /pro off  cancel armed state before the next turn",
+    };
+  }
+  if (ctx.armPro) ctx.armPro();
+  else loop.armProForNextTurn();
+  return {
+    info: `▸ /pro armed — your NEXT message runs on ${ESCALATION_MODEL_ID} regardless of preset. Auto-disarms after one turn. Use /preset max for a persistent switch.`,
+  };
+};
+
+// Kept in sync with loop.ts ESCALATION_MODEL — hard-coding rather than
+// importing it because loop.ts already exports enough surface, and this
+// string is user-facing (description strings stay verbatim even if the
+// internal constant renames).
+const ESCALATION_MODEL_ID = "deepseek-v4-pro";
+
+export const handlers: Record<string, SlashHandler> = {
+  model,
+  models,
+  harvest,
+  preset,
+  branch,
+  effort,
+  pro,
+};