reasonix 0.5.22 → 0.5.24

package/dist/cli/index.js

@@ -7,7 +7,7 @@ import {
   memoryEnabled,
   readProjectMemory,
   sanitizeMemoryName
-} from "./chunk-ANMDY236.js";
+} from "./chunk-C266QOQU.js";
 
 // src/cli/index.ts
 import { Command } from "commander";
@@ -67,6 +67,33 @@ function addProjectShellAllowed(rootDir, prefix, path = defaultConfigPath()) {
   cfg.projects[rootDir].shellAllowed = [...existing, trimmed];
   writeConfig(cfg, path);
 }
+function loadEditMode(path = defaultConfigPath()) {
+  const v = readConfig(path).editMode;
+  return v === "auto" ? "auto" : "review";
+}
+function saveEditMode(mode, path = defaultConfigPath()) {
+  const cfg = readConfig(path);
+  cfg.editMode = mode;
+  writeConfig(cfg, path);
+}
+function editModeHintShown(path = defaultConfigPath()) {
+  return readConfig(path).editModeHintShown === true;
+}
+function loadReasoningEffort(path = defaultConfigPath()) {
+  const v = readConfig(path).reasoningEffort;
+  return v === "high" ? "high" : "max";
+}
+function saveReasoningEffort(effort, path = defaultConfigPath()) {
+  const cfg = readConfig(path);
+  cfg.reasoningEffort = effort;
+  writeConfig(cfg, path);
+}
+function markEditModeHintShown(path = defaultConfigPath()) {
+  const cfg = readConfig(path);
+  if (cfg.editModeHintShown === true) return;
+  cfg.editModeHintShown = true;
+  writeConfig(cfg, path);
+}
 function isPlausibleKey(key) {
   const trimmed = key.trim();
   return /^sk-[A-Za-z0-9_-]{16,}$/.test(trimmed);
@@ -126,8 +153,8 @@ function computeWait(attempt, initial, cap, retryAfter) {
 }
 function sleep(ms, signal) {
   if (ms <= 0) return Promise.resolve();
-  return new Promise((resolve7, reject) => {
-    const timer = setTimeout(resolve7, ms);
+  return new Promise((resolve8, reject) => {
+    const timer = setTimeout(resolve8, ms);
     if (signal) {
       const onAbort = () => {
         clearTimeout(timer);
@@ -612,7 +639,7 @@ function matchesTool(hook, toolName) {
   }
 }
 function defaultSpawner(input) {
-  return new Promise((resolve7) => {
+  return new Promise((resolve8) => {
     const child = spawn(input.command, {
       cwd: input.cwd,
       shell: true,
@@ -639,7 +666,7 @@ function defaultSpawner(input) {
     });
     child.once("error", (err) => {
       clearTimeout(timer);
-      resolve7({
+      resolve8({
         exitCode: null,
         stdout: stdout2,
         stderr,
@@ -649,7 +676,7 @@ function defaultSpawner(input) {
     });
     child.once("close", (code) => {
       clearTimeout(timer);
-      resolve7({
+      resolve8({
         exitCode: code,
         stdout: stdout2.trim(),
         stderr: stderr.trim(),
@@ -979,6 +1006,12 @@ var ToolRegistry = class {
    * bounced until the user approves a submitted plan.
    */
   _planMode = false;
+  /**
+   * Optional hook run after arg parsing but before tool.fn. Lets the TUI
+   * reroute specific tool calls (e.g. edit_file in review mode) without
+   * modifying the tool definitions themselves.
+   */
+  _interceptor = null;
   constructor(opts = {}) {
     this._autoFlatten = opts.autoFlatten !== false;
   }
@@ -990,6 +1023,14 @@ var ToolRegistry = class {
   get planMode() {
     return this._planMode;
   }
+  /**
+   * Install or clear the dispatch interceptor. At most one interceptor
+   * is active at a time — calling twice replaces the previous. Pass
+   * `null` to remove.
+   */
+  setToolInterceptor(fn) {
+    this._interceptor = fn;
+  }
   register(def) {
     if (!def.name) throw new Error("tool requires a name");
     const internal = { ...def };
@@ -1046,6 +1087,16 @@ var ToolRegistry = class {
         error: `${name}: unavailable in plan mode \u2014 this is a read-only exploration phase. Use read_file / list_directory / search_files / directory_tree / web_search / allowlisted shell commands to investigate. Call submit_plan with your proposed plan when you're ready for the user's review.`
       });
     }
+    if (this._interceptor) {
+      try {
+        const short = await this._interceptor(name, args);
+        if (typeof short === "string") return short;
+      } catch (err) {
+        return JSON.stringify({
+          error: `${name}: interceptor failed \u2014 ${err.message}`
+        });
+      }
+    }
     try {
       const result = await tool.fn(args, { signal: opts.signal });
       const str = typeof result === "string" ? result : JSON.stringify(result);
@@ -1779,6 +1830,7 @@ function round(n, digits) {
 }
 
 // src/loop.ts
+var ARGS_COMPACT_THRESHOLD_TOKENS = 800;
 var CacheFirstLoop = class {
   client;
   prefix;
@@ -1882,12 +1934,62 @@ var CacheFirstLoop = class {
    * authored intent we can't mechanically shrink without losing
    * meaning.
    */
-  compact(maxTokens = 4e3) {
+  /**
+   * Conservative args-only shrink fired after every tool response —
+   * strictly about ONE thing: stop oversized `edit_file` / `write_file`
+   * arguments from riding every future turn's prompt.
+   *
+   * Why this is worth doing AUTOMATICALLY (not just on /compact):
+   * Each tool-call arguments string sticks in the log verbatim. On a
+   * coding session with ~10 edits, that's 20-40K tokens of stale
+   * SEARCH/REPLACE text riding along on every turn. Even at a 98.9%
+   * cache hit rate the input cost still adds up linearly (cache-hit
+   * price × tokens × turns). Compacting IMMEDIATELY after the tool
+   * responds means the next turn's prompt is already smaller — the
+   * shrink is a one-time write that saves every future prompt.
+   *
+   * Threshold rationale: 800 tokens ≈ 3 KB. A typical 20-line edit's
+   * args land well under that; massive rewrites (whole-file content,
+   * 100+ line refactors) land above and get the compaction. Small
+   * edits stay byte-verbatim so nothing common-case changes.
+   *
+   * Safety: we ONLY shrink args whose tool has ALREADY responded.
+   * Structurally that's every call in `log.toMessages()` at this
+   * point — the current turn's assistant/tool pairing is by
+   * construction closed by the time we get here (append happens
+   * AFTER dispatch). The in-flight assistant message being built
+   * lives in scratch, not the log, so this pass can't touch it.
+   *
+   * Model impact: the model may occasionally want to reference the
+   * exact SEARCH text of a prior edit — it then reads the file
+   * directly (which shows current state) or looks at the preceding
+   * assistant text (which has its plan). Losing the stale args is a
+   * net win: one extra read_file vs. dragging N KB of stale text
+   * through every subsequent turn.
+   */
+  compactToolCallArgsAfterResponse() {
     const before = this.log.toMessages();
-    const { messages, healedCount, tokensSaved, charsSaved } = shrinkOversizedToolResultsByTokens(
+    const { messages, healedCount } = shrinkOversizedToolCallArgsByTokens(
       before,
-      maxTokens
+      ARGS_COMPACT_THRESHOLD_TOKENS
     );
+    if (healedCount === 0) return;
+    this.log.compactInPlace(messages);
+    if (this.sessionName) {
+      try {
+        rewriteSession(this.sessionName, messages);
+      } catch {
+      }
+    }
+  }
+  compact(maxTokens = 4e3) {
+    const before = this.log.toMessages();
+    const resultsPass = shrinkOversizedToolResultsByTokens(before, maxTokens);
+    const argsPass = shrinkOversizedToolCallArgsByTokens(resultsPass.messages, maxTokens);
+    const messages = argsPass.messages;
+    const healedCount = resultsPass.healedCount + argsPass.healedCount;
+    const tokensSaved = resultsPass.tokensSaved + argsPass.tokensSaved;
+    const charsSaved = resultsPass.charsSaved + argsPass.charsSaved;
     if (healedCount > 0) {
       this.log.compactInPlace(messages);
       if (this.sessionName) {
@@ -2130,8 +2232,8 @@ var CacheFirstLoop = class {
             }
           );
           for (let k = 0; k < budget; k++) {
-            const sample = queue.shift() ?? await new Promise((resolve7) => {
-              waiter = resolve7;
+            const sample = queue.shift() ?? await new Promise((resolve8) => {
+              waiter = resolve8;
             });
             yield {
               turn: this._turn,
@@ -2397,6 +2499,7 @@ ${reason}`;
           name,
           content: result
         });
+        this.compactToolCallArgsAfterResponse();
         yield {
           turn: this._turn,
           role: "tool",
@@ -2582,6 +2685,56 @@ function shrinkOversizedToolResultsByTokens(messages, maxTokens) {
   });
   return { messages: out, healedCount, tokensSaved, charsSaved };
 }
+function shrinkOversizedToolCallArgsByTokens(messages, maxTokens) {
+  let healedCount = 0;
+  let tokensSaved = 0;
+  let charsSaved = 0;
+  const out = messages.map((msg) => {
+    if (msg.role !== "assistant" || !Array.isArray(msg.tool_calls)) return msg;
+    let changed = false;
+    const newCalls = msg.tool_calls.map((call) => {
+      const args = call.function?.arguments;
+      if (typeof args !== "string" || args.length <= maxTokens) return call;
+      const beforeTokens = countTokens(args);
+      if (beforeTokens <= maxTokens) return call;
+      const shrunk = shrinkJsonLongStrings(args);
+      const afterTokens = countTokens(shrunk);
+      if (afterTokens >= beforeTokens) return call;
+      changed = true;
+      healedCount += 1;
+      tokensSaved += beforeTokens - afterTokens;
+      charsSaved += args.length - shrunk.length;
+      return { ...call, function: { ...call.function, arguments: shrunk } };
+    });
+    if (!changed) return msg;
+    return { ...msg, tool_calls: newCalls };
+  });
+  return { messages: out, healedCount, tokensSaved, charsSaved };
+}
+function shrinkJsonLongStrings(jsonStr) {
+  let parsed;
+  try {
+    parsed = JSON.parse(jsonStr);
+  } catch {
+    const head = jsonStr.slice(0, 200);
+    return `${head}\u2026[shrunk: ${jsonStr.length} chars, unparsed]`;
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return jsonStr;
+  }
+  const LONG_THRESHOLD = 300;
+  const input = parsed;
+  const output = {};
+  for (const [k, v] of Object.entries(input)) {
+    if (typeof v === "string" && v.length > LONG_THRESHOLD) {
+      const newlines = v.match(/\n/g)?.length ?? 0;
+      output[k] = `[\u2026shrunk: ${v.length} chars, ${newlines} lines \u2014 tool already responded, see result]`;
+    } else {
+      output[k] = v;
+    }
+  }
+  return JSON.stringify(output);
+}
 function fixToolCallPairing(messages) {
   const out = [];
   let droppedAssistantCalls = 0;
@@ -2645,10 +2798,41 @@ function formatLoopError(err) {
   if (msg.includes("maximum context length")) {
     const reqMatch = msg.match(/requested\s+(\d+)\s+tokens/);
     const requested = reqMatch ? `${Number(reqMatch[1]).toLocaleString()} tokens` : "too many tokens";
-    return `Context overflow (DeepSeek 400): session history is ${requested}, past the 131,072-token limit. Usually this means a single tool call returned a huge payload. v0.3.0-alpha.6+ caps new tool results at 32k chars, AND auto-heals oversized history on session load \u2014 restart Reasonix and this session should come back trimmed. If it still overflows, run /forget (delete the session) or /clear (drop the displayed history) to start fresh.`;
+    return `Context overflow (DeepSeek 400): session history is ${requested}, past the model's prompt limit (V4: 1M tokens; legacy chat/reasoner: 131k). Usually a single tool result grew too big. Reasonix caps new tool results at 8k tokens and auto-heals oversized history on session load \u2014 a restart often clears it. If it still overflows, run /forget (delete the session) or /clear (drop the displayed history) to start fresh.`;
+  }
+  const m = /^DeepSeek (\d{3}):\s*([\s\S]*)$/.exec(msg);
+  if (!m) return msg;
+  const status = m[1] ?? "";
+  const body = m[2] ?? "";
+  const inner = extractDeepSeekErrorMessage(body);
+  if (status === "401") {
+    return `Authentication failed (DeepSeek 401): ${inner}. Your API key is rejected. Fix with \`reasonix setup\` or \`export DEEPSEEK_API_KEY=sk-...\`. Get one at https://platform.deepseek.com/api_keys.`;
+  }
+  if (status === "402") {
+    return `Out of balance (DeepSeek 402): ${inner}. Top up at https://platform.deepseek.com/top_up \u2014 the panel header shows your balance once it's non-zero.`;
+  }
+  if (status === "422") {
+    return `Invalid parameter (DeepSeek 422): ${inner}`;
+  }
+  if (status === "400") {
+    return `Bad request (DeepSeek 400): ${inner}`;
   }
   return msg;
 }
+function extractDeepSeekErrorMessage(body) {
+  const trimmed = body.trim();
+  if (!trimmed) return "(no message)";
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (parsed && typeof parsed === "object") {
+      const obj = parsed;
+      if (obj.error && typeof obj.error.message === "string") return obj.error.message;
+      if (typeof obj.message === "string") return obj.message;
+    }
+  } catch {
+  }
+  return trimmed;
+}
 
 // src/at-mentions.ts
 import { existsSync as existsSync4, readFileSync as readFileSync5, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
@@ -2845,6 +3029,9 @@ import { promises as fs } from "fs";
 import * as pathMod from "path";
 var DEFAULT_MAX_READ_BYTES = 2 * 1024 * 1024;
 var DEFAULT_MAX_LIST_BYTES = 256 * 1024;
+var DEFAULT_AUTO_PREVIEW_LINES = 200;
+var AUTO_PREVIEW_HEAD_LINES = 80;
+var AUTO_PREVIEW_TAIL_LINES = 40;
 var SKIP_DIR_NAMES = /* @__PURE__ */ new Set([
   "node_modules",
   ".git",
@@ -2937,14 +3124,22 @@ function registerFilesystemTools(registry, opts) {
   };
   registry.register({
     name: "read_file",
-    description: "Read a file under the sandbox root. Returns the full contents (truncated with a notice if larger than the per-call cap). Paths may be relative to the root or absolute-under-root.",
+    description: `Read a file under the sandbox root. To save context, PREFER to scope the read instead of pulling the whole file:
+  - head: N  \u2192 first N lines (imports, public API, small configs)
+  - tail: N  \u2192 last N lines (recently-added code, log tails)
+  - range: "A-B"  \u2192 inclusive line range A..B, 1-indexed (e.g. "120-180" around an edit site)
+When none of these is given AND the file is longer than ${DEFAULT_AUTO_PREVIEW_LINES} lines, the tool auto-returns a head+tail preview with an "N lines omitted" marker rather than dumping everything. If you need the middle, re-call with a range. Prefer search_content to locate a symbol first, then read_file with a range around the hit \u2014 one scoped read beats three full-file reads.`,
     readOnly: true,
     parameters: {
       type: "object",
       properties: {
         path: { type: "string", description: "Path to read (relative to rootDir or absolute)." },
         head: { type: "integer", description: "If set, return only the first N lines." },
-        tail: { type: "integer", description: "If set, return only the last N lines." }
+        tail: { type: "integer", description: "If set, return only the last N lines." },
+        range: {
+          type: "string",
+          description: 'Inclusive line range like "50-100" or "50-50". 1-indexed. Takes precedence over head/tail when all three are set. Out-of-range requests clamp to file bounds.'
+        }
       },
       required: ["path"]
     },
@@ -2956,21 +3151,52 @@ function registerFilesystemTools(registry, opts) {
       }
       const raw = await fs.readFile(abs);
       if (raw.length > maxReadBytes) {
-        const head = raw.slice(0, maxReadBytes).toString("utf8");
-        return `${head}
+        const headBytes = raw.slice(0, maxReadBytes).toString("utf8");
+        return `${headBytes}
 
-[\u2026truncated ${raw.length - maxReadBytes} bytes \u2014 file is ${raw.length} B, cap ${maxReadBytes} B. Retry with head/tail for targeted view.]`;
+[\u2026truncated ${raw.length - maxReadBytes} bytes \u2014 file is ${raw.length} B, cap ${maxReadBytes} B. Retry with head/tail/range for targeted view.]`;
       }
       const text = raw.toString("utf8");
+      let lines = text.split(/\r?\n/);
+      if (lines.length > 0 && lines[lines.length - 1] === "") lines = lines.slice(0, -1);
+      const totalLines = lines.length;
+      if (typeof args.range === "string" && /^\d+\s*-\s*\d+$/.test(args.range)) {
+        const [rawStart, rawEnd] = args.range.split("-").map((s) => Number.parseInt(s, 10));
+        const start = Math.max(1, rawStart ?? 1);
+        const end = Math.min(totalLines, Math.max(start, rawEnd ?? totalLines));
+        const slice = lines.slice(start - 1, end);
+        const label = `[range ${start}-${end} of ${totalLines} lines]`;
+        return `${label}
+${slice.join("\n")}`;
+      }
       if (typeof args.head === "number" && args.head > 0) {
-        return text.split(/\r?\n/).slice(0, args.head).join("\n");
+        const count = Math.min(args.head, totalLines);
+        const slice = lines.slice(0, count);
+        const marker = count < totalLines ? `
+
+[\u2026head ${count} of ${totalLines} lines \u2014 call again with range / tail for more]` : "";
+        return slice.join("\n") + marker;
       }
       if (typeof args.tail === "number" && args.tail > 0) {
-        let lines = text.split(/\r?\n/);
-        if (lines.length > 0 && lines[lines.length - 1] === "") lines = lines.slice(0, -1);
-        return lines.slice(Math.max(0, lines.length - args.tail)).join("\n");
-      }
-      return text;
+        const count = Math.min(args.tail, totalLines);
+        const slice = lines.slice(totalLines - count);
+        const marker = count < totalLines ? `[\u2026tail ${count} of ${totalLines} lines \u2014 call again with range / head for more]
+
+` : "";
+        return marker + slice.join("\n");
+      }
+      if (totalLines <= DEFAULT_AUTO_PREVIEW_LINES) return lines.join("\n");
+      const head = lines.slice(0, AUTO_PREVIEW_HEAD_LINES).join("\n");
+      const tail = lines.slice(totalLines - AUTO_PREVIEW_TAIL_LINES).join("\n");
+      const omitted = totalLines - AUTO_PREVIEW_HEAD_LINES - AUTO_PREVIEW_TAIL_LINES;
+      return [
+        `[auto-preview: head ${AUTO_PREVIEW_HEAD_LINES} + tail ${AUTO_PREVIEW_TAIL_LINES} of ${totalLines} lines]`,
+        head,
+        `
+[\u2026 ${omitted} lines omitted \u2014 call read_file again with range:"A-B" (1-indexed) or head / tail to get the middle]
+`,
+        tail
+      ].join("\n");
     }
   });
   registry.register({
@@ -2995,21 +3221,34 @@ function registerFilesystemTools(registry, opts) {
   });
   registry.register({
     name: "directory_tree",
-    description: "Recursively list entries in a directory. Shows indented tree structure with directories marked '/'. Caps output so a huge tree doesn't drown the context.",
+    description: `Recursively list entries in a directory. Shows indented tree structure with directories marked '/'. Budget-aware by default:
+  - maxDepth defaults to 2 (root + one level). A depth-4 tree on a real repo blew ~5K tokens in one call. If you truly need deeper, pass maxDepth:N explicitly.
+  - Skips ${[...SKIP_DIR_NAMES].sort().join(", ")} unless include_deps:true. Traversing into node_modules / .git / dist is almost always token-waste.
+  - Large subtrees (>50 children) auto-collapse to "[N files, M dirs hidden \u2014 list_directory <path> to inspect]" so one huge folder can't dominate the output.
+Prefer \`list_directory\` for a single-level view, \`search_files\` to find specific paths, and \`search_content\` to find code.`,
     readOnly: true,
     parameters: {
       type: "object",
       properties: {
         path: { type: "string", description: "Root of the tree (default: sandbox root)." },
-        maxDepth: { type: "integer", description: "Max recursion depth (default 4)." }
+        maxDepth: {
+          type: "integer",
+          description: "Max recursion depth (default 2). Depth 0 shows only the top-level entries; depth 2 is usually enough to see module structure."
+        },
+        include_deps: {
+          type: "boolean",
+          description: "When true, also traverse node_modules / .git / dist / build / etc. Off by default \u2014 most exploration questions are about the user's own code."
+        }
       }
     },
     fn: async (args) => {
       const startAbs = safePath(args.path ?? ".");
-      const maxDepth = typeof args.maxDepth === "number" ? args.maxDepth : 4;
+      const maxDepth = typeof args.maxDepth === "number" ? args.maxDepth : 2;
+      const includeDeps = args.include_deps === true;
       const lines = [];
       let totalBytes = 0;
       let truncated = false;
+      const PER_DIR_CHILD_CAP = 50;
       const walk2 = async (dir, depth) => {
         if (truncated) return;
         if (depth > maxDepth) return;
@@ -3020,10 +3259,27 @@ function registerFilesystemTools(registry, opts) {
           return;
         }
         entries.sort((a, b) => a.name.localeCompare(b.name));
+        let emitted = 0;
         for (const e of entries) {
           if (truncated) return;
+          const skip = e.isDirectory() && !includeDeps && SKIP_DIR_NAMES.has(e.name);
+          if (emitted >= PER_DIR_CHILD_CAP) {
+            const remaining = entries.length - emitted;
+            let restFiles = 0;
+            let restDirs = 0;
+            for (const r of entries.slice(emitted)) {
+              if (r.isDirectory()) restDirs++;
+              else restFiles++;
+            }
+            const indent2 = "  ".repeat(depth);
+            lines.push(
+              `${indent2}[\u2026 ${remaining} entries hidden (${restDirs} dirs, ${restFiles} files) \u2014 list_directory on this path to see all]`
+            );
+            return;
+          }
           const indent = "  ".repeat(depth);
-          const line = e.isDirectory() ? `${indent}${e.name}/` : `${indent}${e.name}`;
+          const suffix = skip ? " (skipped \u2014 pass include_deps:true to traverse)" : "";
+          const line = e.isDirectory() ? `${indent}${e.name}/${suffix}` : `${indent}${e.name}`;
           totalBytes += line.length + 1;
           if (totalBytes > maxListBytes) {
             lines.push(`  [\u2026 tree truncated at ${maxListBytes} bytes \u2026]`);
@@ -3031,7 +3287,8 @@ function registerFilesystemTools(registry, opts) {
             return;
           }
           lines.push(line);
-          if (e.isDirectory()) {
+          emitted++;
+          if (e.isDirectory() && !skip) {
             await walk2(pathMod.join(dir, e.name), depth + 1);
           }
         }
@@ -3673,9 +3930,311 @@ function forkRegistryExcluding(parent, exclude) {
 }
 
 // src/tools/shell.ts
-import { spawn as spawn2 } from "child_process";
+import { spawn as spawn3 } from "child_process";
 import { existsSync as existsSync5, statSync as statSync3 } from "fs";
+import * as pathMod3 from "path";
+
+// src/tools/jobs.ts
+import { spawn as spawn2 } from "child_process";
 import * as pathMod2 from "path";
+function killProcessTree(pid, signal) {
+  if (process.platform === "win32") {
+    const args = ["/pid", String(pid), "/T"];
+    if (signal === "SIGKILL") args.push("/F");
+    try {
+      const killer = spawn2("taskkill", args, {
+        stdio: "ignore",
+        windowsHide: true
+      });
+      killer.on("error", () => {
+      });
+    } catch {
+    }
+    return;
+  }
+  try {
+    process.kill(-pid, signal);
+    return;
+  } catch {
+  }
+  try {
+    process.kill(pid, signal);
+  } catch {
+  }
+}
+var DEFAULT_OUTPUT_CAP_BYTES = 64 * 1024;
+var READY_SIGNALS = [
+  // HTTP server banners
+  /\blistening on\b/i,
+  /\blocal:\s+https?:\/\//i,
+  /\bhttps?:\/\/(?:localhost|127\.0\.0\.1|0\.0\.0\.0)(?::\d+)?\b/i,
+  /\b(?:ready|server started|started server|app listening)\b/i,
+  // Bundlers / compilers
+  /\bcompiled successfully\b/i,
+  /\bbuild complete(?:d)?\b/i,
+  /\bwatching for (?:file )?changes\b/i,
+  /\bready in \d+/i,
+  // Generic
+  /\bstartup (?:complete|finished)\b/i
+];
+var JobRegistry = class {
+  jobs = /* @__PURE__ */ new Map();
+  nextId = 1;
+  /**
+   * Spawn a background child. Resolves after `waitSec` OR on ready
+   * signal OR on early exit, whichever comes first. The child continues
+   * to run (and buffer output) regardless of which path fires.
+   */
+  async start(command, opts) {
+    const trimmed = command.trim();
+    if (!trimmed) throw new Error("run_background: empty command");
+    const op = detectShellOperator(trimmed);
+    if (op !== null) {
+      throw new Error(
+        `run_background: shell operator "${op}" is not supported \u2014 spawn one process per background job. Compose via your orchestration, not the shell.`
+      );
+    }
+    const argv = tokenizeCommand(trimmed);
+    if (argv.length === 0) throw new Error("run_background: empty command");
+    const waitMs = Math.max(0, Math.min(30, opts.waitSec ?? 3)) * 1e3;
+    const maxBytes = opts.maxBufferBytes ?? DEFAULT_OUTPUT_CAP_BYTES;
+    const { bin, args, spawnOverrides } = prepareSpawn(argv);
+    const spawnOpts = {
+      cwd: pathMod2.resolve(opts.cwd),
+      shell: false,
+      windowsHide: true,
+      env: process.env,
+      // POSIX: detach so the child becomes its own process-group leader.
+      // Required for `process.kill(-pid, …)` later — without it a group
+      // kill fails and we end up only signaling the wrapper, leaving
+      // grandchildren (node → vite → esbuild …) orphaned.
+      // Windows: detached would spawn a new console window; leave the
+      // default and use taskkill /T for tree termination.
+      detached: process.platform !== "win32",
+      ...spawnOverrides
+    };
+    let child;
+    try {
+      child = spawn2(bin, args, spawnOpts);
+    } catch (err) {
+      const id2 = this.nextId++;
+      const job2 = {
+        id: id2,
+        command: trimmed,
+        pid: null,
+        startedAt: Date.now(),
+        exitCode: null,
+        output: `[spawn failed] ${err.message}`,
+        totalBytesWritten: 0,
+        running: false,
+        spawnError: err.message,
+        child: null,
+        readyPromise: Promise.resolve(),
+        signalReady: () => {
+        }
+      };
+      this.jobs.set(id2, job2);
+      return {
+        jobId: id2,
+        pid: null,
+        stillRunning: false,
+        readyMatched: false,
+        preview: job2.output,
+        exitCode: null
+      };
+    }
+    const id = this.nextId++;
+    let readyResolve = () => {
+    };
+    const readyPromise = new Promise((res) => {
+      readyResolve = res;
+    });
+    const job = {
+      id,
+      command: trimmed,
+      pid: child.pid ?? null,
+      startedAt: Date.now(),
+      exitCode: null,
+      output: "",
+      totalBytesWritten: 0,
+      running: true,
+      child,
+      readyPromise,
+      signalReady: readyResolve
+    };
+    this.jobs.set(id, job);
+    let readyMatched = false;
+    const onData = (chunk) => {
+      const s = chunk.toString();
+      job.totalBytesWritten += s.length;
+      job.output += s;
+      if (job.output.length > maxBytes) {
+        const overflow = job.output.length - maxBytes;
+        const cut = job.output.indexOf("\n", overflow);
+        const start = cut >= 0 ? cut + 1 : overflow;
+        job.output = `[\u2026 older output dropped \u2026]
+${job.output.slice(start)}`;
+      }
+      if (!readyMatched) {
+        for (const re of READY_SIGNALS) {
+          if (re.test(s) || re.test(job.output)) {
+            readyMatched = true;
+            job.signalReady();
+            break;
+          }
+        }
+      }
+    };
+    child.stdout?.on("data", onData);
+    child.stderr?.on("data", onData);
+    child.on("error", (err) => {
+      job.running = false;
+      job.spawnError = err.message;
+      job.signalReady();
+    });
+    child.on("close", (code) => {
+      job.running = false;
+      job.exitCode = code;
+      job.signalReady();
+    });
+    const onAbort = () => this.stop(id, { graceMs: 100 });
+    opts.signal?.addEventListener("abort", onAbort, { once: true });
+    let timer = null;
+    await Promise.race([
+      readyPromise,
+      new Promise((res) => {
+        timer = setTimeout(res, waitMs);
+      })
+    ]);
+    if (timer) clearTimeout(timer);
+    return {
+      jobId: id,
+      pid: job.pid,
+      stillRunning: job.running,
+      readyMatched,
+      preview: job.output,
+      exitCode: job.exitCode
+    };
+  }
+  /**
+   * Read a job's accumulated output. `since` lets a caller poll
+   * incrementally: pass the byte count returned from the last call to
+   * get only newly-written content. Returns both full output and a
+   * running snapshot so the caller can use whichever.
+   */
+  read(id, opts = {}) {
+    const job = this.jobs.get(id);
+    if (!job) return null;
+    const full = job.output;
+    let slice = full;
+    if (typeof opts.since === "number" && opts.since >= 0 && opts.since < full.length) {
+      slice = full.slice(opts.since);
+    }
+    if (typeof opts.tailLines === "number" && opts.tailLines > 0) {
+      const lines = slice.split("\n");
+      const keep = lines.slice(Math.max(0, lines.length - opts.tailLines));
+      slice = keep.join("\n");
+    }
+    return {
+      output: slice,
+      byteLength: full.length,
+      running: job.running,
+      exitCode: job.exitCode,
+      command: job.command,
+      pid: job.pid,
+      spawnError: job.spawnError
+    };
+  }
+  /**
+   * Send SIGTERM, wait `graceMs`, then SIGKILL if still alive. Returns
+   * the final job record (or null when the job id is unknown). Safe to
+   * call on an already-exited job — returns the record unchanged.
+   */
+  async stop(id, opts = {}) {
+    const job = this.jobs.get(id);
+    if (!job) return null;
+    if (!job.running || !job.child) return snapshot(job);
+    const graceMs = Math.max(0, opts.graceMs ?? 2e3);
+    if (job.pid !== null) {
+      killProcessTree(job.pid, "SIGTERM");
+    } else {
+      try {
+        job.child.kill("SIGTERM");
+      } catch {
+      }
+    }
+    await Promise.race([job.readyPromise, new Promise((res) => setTimeout(res, graceMs))]);
+    if (job.running) {
+      if (job.pid !== null) {
+        killProcessTree(job.pid, "SIGKILL");
+      } else {
+        try {
+          job.child.kill("SIGKILL");
+        } catch {
+        }
+      }
+      await new Promise((res) => setTimeout(res, 800));
+    }
+    return snapshot(job);
+  }
+  list() {
+    return [...this.jobs.values()].map(snapshot);
+  }
+  /**
+   * Best-effort kill of every still-running job. Called on TUI shutdown
+   * so dev servers don't outlive the Reasonix process. Resolves after
+   * every child has closed or a hard deadline passes (3s total).
+   */
+  async shutdown(deadlineMs = 5e3) {
+    const start = Date.now();
+    const runningJobs = [...this.jobs.values()].filter((j) => j.running && j.child);
+    if (runningJobs.length === 0) return;
+    for (const job of runningJobs) {
+      if (job.pid !== null) killProcessTree(job.pid, "SIGTERM");
+      else
+        try {
+          job.child?.kill("SIGTERM");
+        } catch {
+        }
+    }
+    const allClose = Promise.all(runningJobs.map((j) => j.readyPromise));
+    const elapsed = () => Date.now() - start;
+    const graceMs = Math.min(1500, Math.max(0, deadlineMs / 2));
+    await Promise.race([allClose, new Promise((res) => setTimeout(res, graceMs))]);
+    for (const job of runningJobs) {
+      if (!job.running) continue;
+      if (job.pid !== null) killProcessTree(job.pid, "SIGKILL");
+      else
+        try {
+          job.child?.kill("SIGKILL");
+        } catch {
+        }
+    }
+    const remaining = Math.max(800, deadlineMs - elapsed());
+    await Promise.race([allClose, new Promise((res) => setTimeout(res, remaining))]);
+  }
+  /** Count of still-running jobs — drives the TUI status-bar indicator. */
+  runningCount() {
+    let n = 0;
+    for (const job of this.jobs.values()) if (job.running) n++;
+    return n;
+  }
+};
+function snapshot(job) {
+  return {
+    id: job.id,
+    command: job.command,
+    pid: job.pid,
+    startedAt: job.startedAt,
+    exitCode: job.exitCode,
+    output: job.output,
+    totalBytesWritten: job.totalBytesWritten,
+    running: job.running,
+    spawnError: job.spawnError
+  };
+}
+
+// src/tools/shell.ts
 var DEFAULT_TIMEOUT_SEC = 60;
 var DEFAULT_MAX_OUTPUT_CHARS = 32e3;
 var BUILTIN_ALLOWLIST = [
@@ -3844,10 +4403,10 @@ async function runCommand(cmd, opts) {
   };
   const { bin, args, spawnOverrides } = prepareSpawn(argv);
   const effectiveSpawnOpts = { ...spawnOpts, ...spawnOverrides };
-  return await new Promise((resolve7, reject) => {
+  return await new Promise((resolve8, reject) => {
     let child;
     try {
-      child = spawn2(bin, args, effectiveSpawnOpts);
+      child = spawn3(bin, args, effectiveSpawnOpts);
     } catch (err) {
       reject(err);
       return;
@@ -3877,7 +4436,7 @@ async function runCommand(cmd, opts) {
       const output = buf.length > maxChars ? `${buf.slice(0, maxChars)}
 
 [\u2026 truncated ${buf.length - maxChars} chars \u2026]` : buf;
-      resolve7({ exitCode: code, output, timedOut });
+      resolve8({ exitCode: code, output, timedOut });
     });
   });
 }
@@ -3885,16 +4444,16 @@ function resolveExecutable(cmd, opts = {}) {
   const platform = opts.platform ?? process.platform;
   if (platform !== "win32") return cmd;
   if (!cmd) return cmd;
-  if (cmd.includes("/") || cmd.includes("\\") || pathMod2.isAbsolute(cmd)) return cmd;
-  if (pathMod2.extname(cmd)) return cmd;
+  if (cmd.includes("/") || cmd.includes("\\") || pathMod3.isAbsolute(cmd)) return cmd;
+  if (pathMod3.extname(cmd)) return cmd;
   const env = opts.env ?? process.env;
   const pathExt = (env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").map((e) => e.trim()).filter(Boolean);
-  const delimiter2 = opts.pathDelimiter ?? (platform === "win32" ? ";" : pathMod2.delimiter);
+  const delimiter2 = opts.pathDelimiter ?? (platform === "win32" ? ";" : pathMod3.delimiter);
   const pathDirs = (env.PATH ?? "").split(delimiter2).filter(Boolean);
   const isFile = opts.isFile ?? defaultIsFile;
   for (const dir of pathDirs) {
     for (const ext of pathExt) {
-      const full = pathMod2.win32.join(dir, cmd + ext);
+      const full = pathMod3.win32.join(dir, cmd + ext);
       if (isFile(full)) return full;
     }
   }
@@ -3964,8 +4523,8 @@ function withUtf8Codepage(cmdline) {
 function isBareWindowsName(s) {
   if (!s) return false;
   if (s.includes("/") || s.includes("\\")) return false;
-  if (pathMod2.isAbsolute(s)) return false;
-  if (pathMod2.extname(s)) return false;
+  if (pathMod3.isAbsolute(s)) return false;
+  if (pathMod3.extname(s)) return false;
   return true;
 }
 function quoteForCmdExe(arg) {
@@ -3984,12 +4543,13 @@ var NeedsConfirmationError = class extends Error {
   }
 };
 function registerShellTools(registry, opts) {
-  const rootDir = pathMod2.resolve(opts.rootDir);
+  const rootDir = pathMod3.resolve(opts.rootDir);
   const timeoutSec = opts.timeoutSec ?? DEFAULT_TIMEOUT_SEC;
   const maxOutputChars = opts.maxOutputChars ?? DEFAULT_MAX_OUTPUT_CHARS;
+  const jobs = opts.jobs ?? new JobRegistry();
   const getExtraAllowed = typeof opts.extraAllowed === "function" ? opts.extraAllowed : (() => {
-    const snapshot = opts.extraAllowed ?? [];
-    return () => snapshot;
+    const snapshot2 = opts.extraAllowed ?? [];
+    return () => snapshot2;
   })();
   const allowAll = opts.allowAll ?? false;
   registry.register({
@@ -4035,8 +4595,126 @@ function registerShellTools(registry, opts) {
       return formatCommandResult(cmd, result);
     }
   });
+  registry.register({
+    name: "run_background",
+    description: "Spawn a long-running process (dev server, watcher, any command that doesn't naturally exit) and detach. Waits up to `waitSec` seconds for startup (or until the output matches a readiness signal like 'Local:', 'listening on', 'compiled successfully'), then returns the job id + startup preview. The process keeps running; call `job_output` to tail its logs, `stop_job` to kill it, `list_jobs` to see all running jobs. USE THIS \u2014 not `run_command` \u2014 for: npm/yarn/pnpm run dev, uvicorn / flask run, go run, cargo watch, tsc --watch, webpack serve, anything with 'dev' / 'serve' / 'watch' in the name.",
+    parameters: {
+      type: "object",
+      properties: {
+        command: {
+          type: "string",
+          description: "Full command line. Same quoting rules as run_command (no pipes / redirects / chaining)."
+        },
+        waitSec: {
+          type: "integer",
+          description: "Max seconds to wait for startup before returning. 0..30, default 3. A ready-signal match short-circuits this."
+        }
+      },
+      required: ["command"]
+    },
+    fn: async (args, ctx) => {
+      const cmd = args.command.trim();
+      if (!cmd) throw new Error("run_background: empty command");
+      if (!allowAll && !isAllowed(cmd, getExtraAllowed())) {
+        throw new NeedsConfirmationError(cmd);
+      }
+      const result = await jobs.start(cmd, {
+        cwd: rootDir,
+        waitSec: args.waitSec,
+        signal: ctx?.signal
+      });
+      return formatJobStart(result);
+    }
+  });
+  registry.register({
+    name: "job_output",
+    description: "Read the latest output of a background job started with `run_background`. By default returns the tail of the buffer (last 80 lines). Pass `since` (the `byteLength` from a previous call) to stream only new content incrementally. Tells you whether the job is still running, so you can stop polling when it's done.",
+    readOnly: true,
+    parameters: {
+      type: "object",
+      properties: {
+        jobId: { type: "integer", description: "Job id returned by run_background." },
+        since: {
+          type: "integer",
+          description: "Return only output written past this byte offset (for incremental polling)."
+        },
+        tailLines: {
+          type: "integer",
+          description: "Cap the returned slice to the last N lines. Default 80, 0 = unlimited."
+        }
+      },
+      required: ["jobId"]
+    },
+    fn: async (args) => {
+      const out = jobs.read(args.jobId, {
+        since: args.since,
+        tailLines: args.tailLines ?? 80
+      });
+      if (!out) return `job ${args.jobId}: not found (use list_jobs)`;
+      return formatJobRead(args.jobId, out);
+    }
+  });
+  registry.register({
+    name: "stop_job",
+    description: "Stop a background job started with `run_background`. SIGTERM first; SIGKILL after a short grace period if it doesn't exit cleanly. Returns the final output + exit code. Safe to call on an already-exited job.",
+    parameters: {
+      type: "object",
+      properties: {
+        jobId: { type: "integer" }
+      },
+      required: ["jobId"]
+    },
+    fn: async (args) => {
+      const rec = await jobs.stop(args.jobId);
+      if (!rec) return `job ${args.jobId}: not found`;
+      return formatJobStop(rec);
+    }
+  });
+  registry.register({
+    name: "list_jobs",
+    description: "List every background job started this session \u2014 running and exited \u2014 with id, command, pid, status. Use when you've lost track of which job_id corresponds to which process, or to see what's still alive.",
+    readOnly: true,
+    parameters: { type: "object", properties: {} },
+    fn: async () => {
+      const all = jobs.list();
+      if (all.length === 0) return "(no background jobs started this session)";
+      return all.map(formatJobRow).join("\n");
+    }
+  });
   return registry;
 }
+function formatJobStart(r) {
+  const header2 = r.stillRunning ? `[job ${r.jobId} started \xB7 pid ${r.pid ?? "?"} \xB7 ${r.readyMatched ? "READY signal matched" : "running (no ready signal yet)"}]` : r.exitCode !== null ? `[job ${r.jobId} exited during startup \xB7 exit ${r.exitCode}]` : `[job ${r.jobId} failed to start]`;
+  return r.preview ? `${header2}
+${r.preview}` : header2;
+}
+function formatJobRead(jobId, r) {
+  const status = r.running ? `running \xB7 pid ${r.pid ?? "?"}` : r.exitCode !== null ? `exited ${r.exitCode}` : r.spawnError ? `failed (${r.spawnError})` : "stopped";
+  const header2 = `[job ${jobId} \xB7 ${status} \xB7 byteLength=${r.byteLength}]
+$ ${r.command}`;
+  return r.output ? `${header2}
+${r.output}` : header2;
+}
+function formatJobStop(r) {
+  const running = r.running ? "still running (SIGKILL may be pending)" : `exit ${r.exitCode ?? "?"}`;
+  const tail = tailLines(r.output, 40);
+  const header2 = `[job ${r.id} stopped \xB7 ${running}]
+$ ${r.command}`;
+  return tail ? `${header2}
+${tail}` : header2;
+}
+function formatJobRow(r) {
+  const age = ((Date.now() - r.startedAt) / 1e3).toFixed(1);
+  const state = r.running ? `running   \xB7  pid ${r.pid ?? "?"}` : r.exitCode !== null ? `exit ${r.exitCode}` : r.spawnError ? "failed" : "stopped";
+  return `  ${String(r.id).padStart(3)}  ${state.padEnd(24)}  ${age}s ago   $ ${r.command}`;
+}
+function tailLines(s, n) {
+  if (!s) return "";
+  const lines = s.split("\n");
+  if (lines.length <= n) return s;
+  const dropped = lines.length - n;
+  return [`[\u2026 ${dropped} earlier lines \u2026]`, ...lines.slice(-n)].join("\n");
+}
 function formatCommandResult(cmd, r) {
   const header2 = r.timedOut ? `$ ${cmd}
 [killed after timeout]` : `$ ${cmd}
@@ -4230,11 +4908,11 @@ ${i + 1}. ${r.title}`);
 
 // src/env.ts
 import { readFileSync as readFileSync6 } from "fs";
-import { resolve as resolve4 } from "path";
+import { resolve as resolve5 } from "path";
 function loadDotenv(path = ".env") {
   let raw;
   try {
-    raw = readFileSync6(resolve4(process.cwd(), path), "utf8");
+    raw = readFileSync6(resolve5(process.cwd(), path), "utf8");
   } catch {
     return;
   }
@@ -4947,7 +5625,7 @@ var McpClient = class {
     const id = this.nextId++;
     const frame = { jsonrpc: "2.0", id, method, params };
     let abortHandler = null;
-    const promise = new Promise((resolve7, reject) => {
+    const promise = new Promise((resolve8, reject) => {
       const timeout = setTimeout(() => {
         this.pending.delete(id);
         if (abortHandler && signal) signal.removeEventListener("abort", abortHandler);
@@ -4956,7 +5634,7 @@ var McpClient = class {
         );
       }, this.requestTimeoutMs);
       this.pending.set(id, {
-        resolve: resolve7,
+        resolve: resolve8,
         reject,
         timeout
       });
@@ -5038,7 +5716,7 @@ var McpClient = class {
 };
 
 // src/mcp/stdio.ts
-import { spawn as spawn3 } from "child_process";
+import { spawn as spawn4 } from "child_process";
 var StdioTransport = class {
   child;
   queue = [];
@@ -5053,14 +5731,14 @@ var StdioTransport = class {
         opts.command,
         ...(opts.args ?? []).map((a) => quoteArg(a, process.platform === "win32"))
       ].join(" ");
-      this.child = spawn3(line, [], {
+      this.child = spawn4(line, [], {
         env,
         cwd: opts.cwd,
         stdio: ["pipe", "pipe", "inherit"],
         shell: true
       });
     } else {
-      this.child = spawn3(opts.command, opts.args ?? [], {
+      this.child = spawn4(opts.command, opts.args ?? [], {
         env,
         cwd: opts.cwd,
         stdio: ["pipe", "pipe", "inherit"]
@@ -5079,12 +5757,12 @@ var StdioTransport = class {
   }
   async send(message) {
     if (this.closed) throw new Error("MCP transport is closed");
-    return new Promise((resolve7, reject) => {
+    return new Promise((resolve8, reject) => {
       const line = `${JSON.stringify(message)}
 `;
       this.child.stdin.write(line, "utf8", (err) => {
         if (err) reject(err);
-        else resolve7();
+        else resolve8();
       });
     });
   }
@@ -5095,8 +5773,8 @@ var StdioTransport = class {
         continue;
       }
       if (this.closed) return;
-      const next = await new Promise((resolve7) => {
-        this.waiters.push(resolve7);
+      const next = await new Promise((resolve8) => {
+        this.waiters.push(resolve8);
       });
       if (next === null) return;
       yield next;
@@ -5162,8 +5840,8 @@ var SseTransport = class {
   constructor(opts) {
     this.url = opts.url;
     this.headers = opts.headers ?? {};
-    this.endpointReady = new Promise((resolve7, reject) => {
-      this.resolveEndpoint = resolve7;
+    this.endpointReady = new Promise((resolve8, reject) => {
+      this.resolveEndpoint = resolve8;
       this.rejectEndpoint = reject;
     });
     this.endpointReady.catch(() => void 0);
@@ -5190,8 +5868,8 @@ var SseTransport = class {
         continue;
       }
       if (this.closed) return;
-      const next = await new Promise((resolve7) => {
-        this.waiters.push(resolve7);
+      const next = await new Promise((resolve8) => {
+        this.waiters.push(resolve8);
       });
       if (next === null) return;
       yield next;
@@ -5391,7 +6069,7 @@ async function trySection(load) {
 
 // src/code/edit-blocks.ts
 import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync8, unlinkSync as unlinkSync2, writeFileSync as writeFileSync3 } from "fs";
-import { dirname as dirname5, resolve as resolve5 } from "path";
+import { dirname as dirname5, resolve as resolve6 } from "path";
 var BLOCK_RE = /^(\S[^\n]*)\n<{7} SEARCH\n([\s\S]*?)\n?={7}\n([\s\S]*?)\n?>{7} REPLACE/gm;
 function parseEditBlocks(text) {
   const out = [];
@@ -5409,8 +6087,8 @@ function parseEditBlocks(text) {
   return out;
 }
 function applyEditBlock(block, rootDir) {
-  const absRoot = resolve5(rootDir);
-  const absTarget = resolve5(absRoot, block.path);
+  const absRoot = resolve6(rootDir);
+  const absTarget = resolve6(absRoot, block.path);
   if (absTarget !== absRoot && !absTarget.startsWith(`${absRoot}${sep()}`)) {
     return {
       path: block.path,
@@ -5459,14 +6137,26 @@ function applyEditBlock(block, rootDir) {
 function applyEditBlocks(blocks, rootDir) {
   return blocks.map((b) => applyEditBlock(b, rootDir));
 }
+function toWholeFileEditBlock(path, content, rootDir) {
+  const abs = resolve6(rootDir, path);
+  let search = "";
+  if (existsSync6(abs)) {
+    try {
+      search = readFileSync8(abs, "utf8");
+    } catch {
+      search = "";
+    }
+  }
+  return { path, search, replace: content, offset: 0 };
+}
 function snapshotBeforeEdits(blocks, rootDir) {
-  const absRoot = resolve5(rootDir);
+  const absRoot = resolve6(rootDir);
   const seen = /* @__PURE__ */ new Set();
   const snapshots = [];
   for (const b of blocks) {
     if (seen.has(b.path)) continue;
     seen.add(b.path);
-    const abs = resolve5(absRoot, b.path);
+    const abs = resolve6(absRoot, b.path);
     if (!existsSync6(abs)) {
       snapshots.push({ path: b.path, prevContent: null });
       continue;
@@ -5480,9 +6170,9 @@ function snapshotBeforeEdits(blocks, rootDir) {
   return snapshots;
 }
 function restoreSnapshots(snapshots, rootDir) {
-  const absRoot = resolve5(rootDir);
+  const absRoot = resolve6(rootDir);
   return snapshots.map((snap) => {
-    const abs = resolve5(absRoot, snap.path);
+    const abs = resolve6(absRoot, snap.path);
     if (abs !== absRoot && !abs.startsWith(`${absRoot}${sep()}`)) {
       return {
         path: snap.path,
@@ -5769,11 +6459,11 @@ function formatLogSize(path = defaultUsageLogPath()) {
 // src/cli/commands/chat.tsx
 import { existsSync as existsSync11, statSync as statSync6 } from "fs";
 import { render } from "ink";
-import React17, { useState as useState7 } from "react";
+import React18, { useState as useState8 } from "react";
 
 // src/cli/ui/App.tsx
-import { Box as Box13, Static, Text as Text13, useApp, useInput as useInput4 } from "ink";
-import React14, { useCallback, useEffect as useEffect2, useMemo, useRef as useRef2, useState as useState5 } from "react";
+import { Box as Box14, Static, Text as Text14, useApp, useInput as useInput5 } from "ink";
+import React15, { useCallback, useEffect as useEffect2, useMemo as useMemo2, useRef as useRef2, useState as useState6 } from "react";
 
 // src/code/diff-preview.ts
 function formatEditBlockDiff(block, opts = {}) {
@@ -5996,13 +6686,108 @@ function FileRow({ path, isSelected }) {
   return /* @__PURE__ */ React.createElement(Box, null, /* @__PURE__ */ React.createElement(Text, { dimColor: true }, marker, " ", base, dir ? `  ${dir}` : ""));
 }
 
+// src/cli/ui/EditConfirm.tsx
+import { Box as Box2, Text as Text2, useInput, useStdout } from "ink";
+import React2, { useMemo, useState } from "react";
+var MODAL_OVERHEAD_ROWS = 18;
+var MIN_DIFF_ROWS = 8;
+function EditConfirm({ block, onChoose }) {
+  const { stdout: stdout2 } = useStdout();
+  const rows = stdout2?.rows ?? 40;
+  const budget = Math.max(MIN_DIFF_ROWS, rows - MODAL_OVERHEAD_ROWS);
+  const allLines = useMemo(
+    () => formatEditBlockDiff(block, { contextLines: 2, maxLines: 1e5, indent: "  " }),
+    [block]
+  );
+  const [scroll, setScroll] = useState(0);
+  const maxScroll = Math.max(0, allLines.length - budget);
+  const effectiveScroll = Math.min(scroll, maxScroll);
+  useInput((input, key) => {
+    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;
+    }
+    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;
+    }
+  });
+  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;
+  return /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, marginY: 1 }, /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "cyan" }, "\u25B8 model wants to edit a file")), /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Text2, { color: "cyan", dimColor: true }, "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500")), /* @__PURE__ */ React2.createElement(Box2, { marginTop: 1 }, /* @__PURE__ */ React2.createElement(Text2, null, /* @__PURE__ */ React2.createElement(Text2, { color: isNew ? "green" : "yellow", bold: true }, `[${tag}] `), /* @__PURE__ */ React2.createElement(Text2, { color: "cyan" }, block.path), /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, `  (-${removed} +${added} lines)`), showScrollHud ? /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, `  \xB7  viewing ${effectiveScroll + 1}-${effectiveScroll + visibleLines.length}/${totalLines}`) : null)), hiddenAbove > 0 ? /* @__PURE__ */ React2.createElement(
+    Text2,
+    {
+      dimColor: true
+    },
+    `  \u2191 ${hiddenAbove} line${hiddenAbove === 1 ? "" : "s"} above  (\u2191/k or PgUp)`
+  ) : null, /* @__PURE__ */ React2.createElement(Box2, { marginTop: hiddenAbove > 0 ? 0 : 1, flexDirection: "column" }, visibleLines.map((line, i) => {
+    const trimmed = line.trimStart();
+    const color = trimmed.startsWith("+") ? "green" : trimmed.startsWith("-") ? "red" : void 0;
+    const dim = !color;
+    return /* @__PURE__ */ React2.createElement(
+      Text2,
+      {
+        key: `diff-${effectiveScroll}-${i}`,
+        color,
+        dimColor: dim
+      },
+      line
+    );
+  })), hiddenBelow > 0 ? /* @__PURE__ */ React2.createElement(
+    Text2,
+    {
+      dimColor: true
+    },
+    `  \u2193 ${hiddenBelow} line${hiddenBelow === 1 ? "" : "s"} below  (\u2193/j or Space/PgDn)`
+  ) : null, /* @__PURE__ */ React2.createElement(Box2, { marginTop: 1 }, /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, "[", /* @__PURE__ */ React2.createElement(Text2, { color: "cyan", bold: true }, "y"), "/Enter] apply  \xB7  [", /* @__PURE__ */ React2.createElement(Text2, { color: "cyan", bold: true }, "n"), "] reject  \xB7  [", /* @__PURE__ */ React2.createElement(Text2, { color: "cyan", bold: true }, "a"), "] apply rest  \xB7  [", /* @__PURE__ */ React2.createElement(Text2, { color: "cyan", bold: true }, "A"), "] flip AUTO  \xB7  [", /* @__PURE__ */ React2.createElement(Text2, { color: "cyan", bold: true }, "\u2191\u2193/Space"), "] scroll  \xB7  [Esc] abort")));
+}
+
 // src/cli/ui/EventLog.tsx
-import { Box as Box4, Text as Text4, useStdout } from "ink";
-import React5 from "react";
+import { Box as Box5, Text as Text5, useStdout as useStdout2 } from "ink";
+import React6 from "react";
 
 // src/cli/ui/PlanStateBlock.tsx
-import { Box as Box2, Text as Text2 } from "ink";
-import React2 from "react";
+import { Box as Box3, Text as Text3 } from "ink";
+import React3 from "react";
 function PlanStateBlock({ planState }) {
   const fields = [];
   if (planState.subgoals.length) fields.push(["subgoals", planState.subgoals, "cyan", false]);
@@ -6013,14 +6798,14 @@ function PlanStateBlock({ planState }) {
   if (planState.rejectedPaths.length)
     fields.push(["rejected", planState.rejectedPaths, "red", true]);
   if (fields.length === 0) return null;
-  return /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column", marginBottom: 1 }, fields.map(([label, items, color, dim]) => /* @__PURE__ */ React2.createElement(Text2, { key: label }, /* @__PURE__ */ React2.createElement(Text2, { color, bold: true, dimColor: dim }, "\u2039 ", label), /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, ` (${items.length})`), /* @__PURE__ */ React2.createElement(Text2, null, `: ${items.join(" \xB7 ")}`))));
+  return /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column", marginBottom: 1 }, fields.map(([label, items, color, dim]) => /* @__PURE__ */ React3.createElement(Text3, { key: label }, /* @__PURE__ */ React3.createElement(Text3, { color, bold: true, dimColor: dim }, "\u2039 ", label), /* @__PURE__ */ React3.createElement(Text3, { dimColor: true }, ` (${items.length})`), /* @__PURE__ */ React3.createElement(Text3, null, `: ${items.join(" \xB7 ")}`))));
 }
 
 // src/cli/ui/markdown.tsx
 import { readFileSync as readFileSync12, statSync as statSync5 } from "fs";
 import { isAbsolute as isAbsolute4, join as join10 } from "path";
-import { Box as Box3, Text as Text3 } from "ink";
-import React3 from "react";
+import { Box as Box4, Text as Text4 } from "ink";
+import React4 from "react";
 var SUPERSCRIPT = {
   "0": "\u2070",
   "1": "\xB9",
@@ -6145,57 +6930,57 @@ function InlineMd({
   for (const m of text.matchAll(INLINE_RE)) {
     const start = m.index ?? 0;
     if (start > last) {
-      parts.push(/* @__PURE__ */ React3.createElement(Text3, { key: `t${idx++}` }, text.slice(last, start)));
+      parts.push(/* @__PURE__ */ React4.createElement(Text4, { key: `t${idx++}` }, text.slice(last, start)));
     }
     if (m[2] !== void 0 && m[3] !== void 0) {
       const linkText = m[2];
       const url = m[3];
       if (isExternalUrl(url)) {
         parts.push(
-          /* @__PURE__ */ React3.createElement(Text3, { key: `l${idx++}`, color: "blue", underline: true }, linkText)
+          /* @__PURE__ */ React4.createElement(Text4, { key: `l${idx++}`, color: "blue", underline: true }, linkText)
         );
       } else {
         const status = citations?.get(url);
         if (status && !status.ok) {
           parts.push(
-            /* @__PURE__ */ React3.createElement(Text3, { key: `l${idx++}`, color: "red", strikethrough: true }, `${linkText} \u2717`)
+            /* @__PURE__ */ React4.createElement(Text4, { key: `l${idx++}`, color: "red", strikethrough: true }, `${linkText} \u2717`)
           );
         } else {
           parts.push(
-            /* @__PURE__ */ React3.createElement(Text3, { key: `l${idx++}`, color: "cyan", underline: true }, linkText)
+            /* @__PURE__ */ React4.createElement(Text4, { key: `l${idx++}`, color: "cyan", underline: true }, linkText)
           );
         }
       }
     } else if (m[4] !== void 0) {
       parts.push(
-        /* @__PURE__ */ React3.createElement(Text3, { key: `b${idx++}`, bold: true }, m[4])
+        /* @__PURE__ */ React4.createElement(Text4, { key: `b${idx++}`, bold: true }, m[4])
       );
     } else if (m[5] !== void 0) {
       const stripped = m[5].replace(/^(\w+)\s+/, "");
       parts.push(
-        /* @__PURE__ */ React3.createElement(Text3, { key: `c${idx++}`, color: "yellow" }, stripped)
+        /* @__PURE__ */ React4.createElement(Text4, { key: `c${idx++}`, color: "yellow" }, stripped)
       );
     } else if (m[6] !== void 0) {
       parts.push(
-        /* @__PURE__ */ React3.createElement(Text3, { key: `c${idx++}`, color: "yellow" }, m[6])
+        /* @__PURE__ */ React4.createElement(Text4, { key: `c${idx++}`, color: "yellow" }, m[6])
       );
     } else if (m[7] !== void 0) {
       parts.push(
-        /* @__PURE__ */ React3.createElement(Text3, { key: `i${idx++}`, italic: true }, m[7])
+        /* @__PURE__ */ React4.createElement(Text4, { key: `i${idx++}`, italic: true }, m[7])
       );
     }
     last = start + m[0].length;
   }
   if (last < text.length) {
-    parts.push(/* @__PURE__ */ React3.createElement(Text3, { key: `t${idx++}` }, text.slice(last)));
+    parts.push(/* @__PURE__ */ React4.createElement(Text4, { key: `t${idx++}` }, text.slice(last)));
   }
   if (padTo !== void 0) {
     const seen = visibleWidth(text);
     if (seen < padTo) {
-      parts.push(/* @__PURE__ */ React3.createElement(Text3, { key: `pad${idx++}` }, " ".repeat(padTo - seen)));
+      parts.push(/* @__PURE__ */ React4.createElement(Text4, { key: `pad${idx++}` }, " ".repeat(padTo - seen)));
     }
   }
-  return /* @__PURE__ */ React3.createElement(Text3, null, parts);
+  return /* @__PURE__ */ React4.createElement(Text4, null, parts);
 }
 function stripInlineMarkup(s) {
   return s.replace(/\[([^\]\n]+)\]\(([^)\n]+)\)/g, "$1").replace(/\*\*([^*\n]+?)\*\*/g, "$1").replace(/```([^\n]+?)```/g, (_m, c) => c.replace(/^(\w+)\s+/, "")).replace(/`([^`\n]+?)`/g, "$1").replace(/(?<![*\w])\*([^*\n]+?)\*(?!\w)/g, "$1");
@@ -6391,19 +7176,19 @@ function parseBlocks(raw) {
 function BlockView({ block, citations }) {
   switch (block.kind) {
     case "heading":
-      return /* @__PURE__ */ React3.createElement(Text3, { bold: true, color: "cyan" }, /* @__PURE__ */ React3.createElement(InlineMd, { text: block.text, citations }));
+      return /* @__PURE__ */ React4.createElement(Text4, { bold: true, color: "cyan" }, /* @__PURE__ */ React4.createElement(InlineMd, { text: block.text, citations }));
     case "paragraph":
-      return /* @__PURE__ */ React3.createElement(InlineMd, { text: block.text, citations });
+      return /* @__PURE__ */ React4.createElement(InlineMd, { text: block.text, citations });
     case "bullet":
-      return /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column" }, block.items.map((item, i) => /* @__PURE__ */ React3.createElement(Box3, { key: `${i}-${item.slice(0, 24)}` }, /* @__PURE__ */ React3.createElement(Text3, { color: "cyan" }, block.ordered ? ` ${block.start + i}. ` : "  \u2022 "), /* @__PURE__ */ React3.createElement(InlineMd, { text: item, citations }))));
+      return /* @__PURE__ */ React4.createElement(Box4, { flexDirection: "column" }, block.items.map((item, i) => /* @__PURE__ */ React4.createElement(Box4, { key: `${i}-${item.slice(0, 24)}` }, /* @__PURE__ */ React4.createElement(Text4, { color: "cyan" }, block.ordered ? ` ${block.start + i}. ` : "  \u2022 "), /* @__PURE__ */ React4.createElement(InlineMd, { text: item, citations }))));
     case "code":
-      return /* @__PURE__ */ React3.createElement(Box3, { borderStyle: "single", borderColor: "gray", paddingX: 1 }, /* @__PURE__ */ React3.createElement(Text3, { color: "yellow" }, block.text));
+      return /* @__PURE__ */ React4.createElement(Box4, { borderStyle: "single", borderColor: "gray", paddingX: 1 }, /* @__PURE__ */ React4.createElement(Text4, { color: "yellow" }, block.text));
     case "edit-block":
-      return /* @__PURE__ */ React3.createElement(EditBlockRow, { block });
+      return /* @__PURE__ */ React4.createElement(EditBlockRow, { block });
     case "table":
-      return /* @__PURE__ */ React3.createElement(TableBlockRow, { block, citations });
+      return /* @__PURE__ */ React4.createElement(TableBlockRow, { block, citations });
     case "hr":
-      return /* @__PURE__ */ React3.createElement(Text3, { dimColor: true }, "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+      return /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
   }
 }
 function splitTableRow(line) {
@@ -6421,14 +7206,14 @@ function TableBlockRow({ block, citations }) {
     widths.push(Math.min(40, Math.max(3, ...cellLengths)));
   }
   const separator = widths.map((w) => "\u2500".repeat(w)).join("\u2500\u253C\u2500");
-  return /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column" }, /* @__PURE__ */ React3.createElement(Box3, null, block.header.map((cell, ci) => (
+  return /* @__PURE__ */ React4.createElement(Box4, { flexDirection: "column" }, /* @__PURE__ */ React4.createElement(Box4, null, block.header.map((cell, ci) => (
     // biome-ignore lint/suspicious/noArrayIndexKey: table columns never reorder — derived from a static header array
-    /* @__PURE__ */ React3.createElement(Text3, { key: `h-${ci}`, bold: true, color: "cyan" }, /* @__PURE__ */ React3.createElement(InlineMd, { text: cell, padTo: widths[ci] ?? 3, citations }), ci < colCount - 1 ? " \u2502 " : "")
-  ))), /* @__PURE__ */ React3.createElement(Text3, { dimColor: true }, separator), block.rows.map((row2, ri) => (
+    /* @__PURE__ */ React4.createElement(Text4, { key: `h-${ci}`, bold: true, color: "cyan" }, /* @__PURE__ */ React4.createElement(InlineMd, { text: cell, padTo: widths[ci] ?? 3, citations }), ci < colCount - 1 ? " \u2502 " : "")
+  ))), /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, separator), block.rows.map((row2, ri) => (
     // biome-ignore lint/suspicious/noArrayIndexKey: table rows render in source order and don't reorder
-    /* @__PURE__ */ React3.createElement(Box3, { key: `r-${ri}` }, Array.from({ length: colCount }).map((_, ci) => (
+    /* @__PURE__ */ React4.createElement(Box4, { key: `r-${ri}` }, Array.from({ length: colCount }).map((_, ci) => (
       // biome-ignore lint/suspicious/noArrayIndexKey: same — column axis is fixed by the table shape
-      /* @__PURE__ */ React3.createElement(Text3, { key: `c-${ri}-${ci}` }, /* @__PURE__ */ React3.createElement(InlineMd, { text: row2[ci] ?? "", padTo: widths[ci] ?? 3, citations }), ci < colCount - 1 ? " \u2502 " : "")
+      /* @__PURE__ */ React4.createElement(Text4, { key: `c-${ri}-${ci}` }, /* @__PURE__ */ React4.createElement(InlineMd, { text: row2[ci] ?? "", padTo: widths[ci] ?? 3, citations }), ci < colCount - 1 ? " \u2502 " : "")
     )))
   )));
 }
@@ -6448,44 +7233,44 @@ function EditBlockRow({ block }) {
   const isNewFile = block.search.length === 0;
   const searchLines = block.search.split("\n");
   const replaceLines = block.replace.split("\n");
-  return /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1 }, /* @__PURE__ */ React3.createElement(Box3, null, /* @__PURE__ */ React3.createElement(Text3, { bold: true, color: "cyan" }, block.filename), isNewFile ? /* @__PURE__ */ React3.createElement(Text3, { color: "green", bold: true }, " (new file)") : null), isNewFile ? null : /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column", marginTop: 1 }, searchLines.map((line, i) => /* @__PURE__ */ React3.createElement(Text3, { key: `s-${i}-${line.length}`, color: "red" }, `- ${line}`))), /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column", marginTop: isNewFile ? 1 : 0 }, replaceLines.map((line, i) => /* @__PURE__ */ React3.createElement(Text3, { key: `r-${i}-${line.length}`, color: "green" }, `+ ${line}`))));
+  return /* @__PURE__ */ React4.createElement(Box4, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1 }, /* @__PURE__ */ React4.createElement(Box4, null, /* @__PURE__ */ React4.createElement(Text4, { bold: true, color: "cyan" }, block.filename), isNewFile ? /* @__PURE__ */ React4.createElement(Text4, { color: "green", bold: true }, " (new file)") : null), isNewFile ? null : /* @__PURE__ */ React4.createElement(Box4, { flexDirection: "column", marginTop: 1 }, searchLines.map((line, i) => /* @__PURE__ */ React4.createElement(Text4, { key: `s-${i}-${line.length}`, color: "red" }, `- ${line}`))), /* @__PURE__ */ React4.createElement(Box4, { flexDirection: "column", marginTop: isNewFile ? 1 : 0 }, replaceLines.map((line, i) => /* @__PURE__ */ React4.createElement(Text4, { key: `r-${i}-${line.length}`, color: "green" }, `+ ${line}`))));
 }
 function Markdown({ text, projectRoot }) {
   const cleaned = stripMath(text);
   const root = projectRoot ?? process.cwd();
-  const citations = React3.useMemo(() => collectCitations(cleaned, root), [cleaned, root]);
-  const blocks = React3.useMemo(() => parseBlocks(cleaned), [cleaned]);
+  const citations = React4.useMemo(() => collectCitations(cleaned, root), [cleaned, root]);
+  const blocks = React4.useMemo(() => parseBlocks(cleaned), [cleaned]);
   const broken = [];
   for (const [url, status] of citations) {
     if (!status.ok) broken.push({ url, reason: status.reason });
   }
-  return /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column", gap: 1 }, blocks.map((b, i) => /* @__PURE__ */ React3.createElement(BlockView, { key: `${i}-${b.kind}`, block: b, citations })), broken.length > 0 ? /* @__PURE__ */ React3.createElement(BrokenCitationsBlock, { items: broken }) : null);
+  return /* @__PURE__ */ React4.createElement(Box4, { flexDirection: "column", gap: 1 }, blocks.map((b, i) => /* @__PURE__ */ React4.createElement(BlockView, { key: `${i}-${b.kind}`, block: b, citations })), broken.length > 0 ? /* @__PURE__ */ React4.createElement(BrokenCitationsBlock, { items: broken }) : null);
 }
 function BrokenCitationsBlock({ items }) {
-  return /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column", borderStyle: "round", borderColor: "red", paddingX: 1 }, /* @__PURE__ */ React3.createElement(Text3, { color: "red", bold: true }, `\u26A0 ${items.length} broken citation${items.length > 1 ? "s" : ""} \u2014 the model referenced paths or lines that don't exist`), items.map((b, i) => (
+  return /* @__PURE__ */ React4.createElement(Box4, { flexDirection: "column", borderStyle: "round", borderColor: "red", paddingX: 1 }, /* @__PURE__ */ React4.createElement(Text4, { color: "red", bold: true }, `\u26A0 ${items.length} broken citation${items.length > 1 ? "s" : ""} \u2014 the model referenced paths or lines that don't exist`), items.map((b, i) => (
     // biome-ignore lint/suspicious/noArrayIndexKey: list is derived from a Map iteration order, stable per render
-    /* @__PURE__ */ React3.createElement(Text3, { key: `bc-${i}`, color: "red" }, `  \u2717 ${b.url} \u2192 ${b.reason}`)
+    /* @__PURE__ */ React4.createElement(Text4, { key: `bc-${i}`, color: "red" }, `  \u2717 ${b.url} \u2192 ${b.reason}`)
   )));
 }
 
 // src/cli/ui/ticker.tsx
-import React4, { createContext, useContext, useEffect, useState } from "react";
+import React5, { createContext, useContext, useEffect, useState as useState2 } from "react";
 var TICK_MS = 120;
 var TickContext = createContext(0);
 function TickerProvider({ children, disabled }) {
-  const [tick, setTick] = useState(0);
+  const [tick, setTick] = useState2(0);
   useEffect(() => {
     if (disabled) return;
     const id = setInterval(() => setTick((t) => t + 1), TICK_MS);
     return () => clearInterval(id);
   }, [disabled]);
-  return /* @__PURE__ */ React4.createElement(TickContext.Provider, { value: tick }, children);
+  return /* @__PURE__ */ React5.createElement(TickContext.Provider, { value: tick }, children);
 }
 function useTick() {
   return useContext(TickContext);
 }
 function useElapsedSeconds() {
-  const [start] = useState(() => Date.now());
+  const [start] = useState2(() => Date.now());
   useTick();
   return Math.floor((Date.now() - start) / 1e3);
 }
@@ -6505,18 +7290,18 @@ function RoleGlyph({
   glyph,
   color
 }) {
-  return /* @__PURE__ */ React5.createElement(Text4, { color, bold: true }, glyph);
+  return /* @__PURE__ */ React6.createElement(Text5, { color, bold: true }, glyph);
 }
-var EventRow = React5.memo(function EventRow2({
+var EventRow = React6.memo(function EventRow2({
   event,
   projectRoot
 }) {
   if (event.role === "user") {
-    return /* @__PURE__ */ React5.createElement(Box4, { marginTop: event.leadSeparator ? 1 : 0 }, /* @__PURE__ */ React5.createElement(RoleGlyph, { glyph: ROLE_GLYPH.user, color: "cyan" }), /* @__PURE__ */ React5.createElement(Text4, null, "  ", event.text));
+    return /* @__PURE__ */ React6.createElement(Box5, { marginTop: event.leadSeparator ? 1 : 0 }, /* @__PURE__ */ React6.createElement(RoleGlyph, { glyph: ROLE_GLYPH.user, color: "cyan" }), /* @__PURE__ */ React6.createElement(Text5, null, "  ", event.text));
   }
   if (event.role === "assistant") {
-    if (event.streaming) return /* @__PURE__ */ React5.createElement(StreamingAssistant, { event });
-    return /* @__PURE__ */ React5.createElement(Box4, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React5.createElement(Box4, null, /* @__PURE__ */ React5.createElement(RoleGlyph, { glyph: ROLE_GLYPH.assistant, color: "green" }), event.stats ? /* @__PURE__ */ React5.createElement(Text4, { dimColor: true }, `  ${event.stats.model}`) : null), /* @__PURE__ */ React5.createElement(Box4, { flexDirection: "column", paddingLeft: 2, marginTop: 1 }, event.branch ? /* @__PURE__ */ React5.createElement(BranchBlock, { branch: event.branch }) : null, event.reasoning ? /* @__PURE__ */ React5.createElement(ReasoningBlock, { reasoning: event.reasoning }) : null, !isPlanStateEmpty(event.planState) ? /* @__PURE__ */ React5.createElement(PlanStateBlock, { planState: event.planState }) : null, event.text ? /* @__PURE__ */ React5.createElement(Markdown, { text: event.text, projectRoot }) : /* @__PURE__ */ React5.createElement(Text4, { dimColor: true }, "(no content)"), event.stats ? /* @__PURE__ */ React5.createElement(StatsLine, { stats: event.stats }) : null, event.repair ? /* @__PURE__ */ React5.createElement(Text4, { color: "magenta" }, event.repair) : null));
+    if (event.streaming) return /* @__PURE__ */ React6.createElement(StreamingAssistant, { event });
+    return /* @__PURE__ */ React6.createElement(Box5, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React6.createElement(Box5, null, /* @__PURE__ */ React6.createElement(RoleGlyph, { glyph: ROLE_GLYPH.assistant, color: "green" }), event.stats ? /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, `  ${event.stats.model}`) : null), /* @__PURE__ */ React6.createElement(Box5, { flexDirection: "column", paddingLeft: 2, marginTop: 1 }, event.branch ? /* @__PURE__ */ React6.createElement(BranchBlock, { branch: event.branch }) : null, event.reasoning ? /* @__PURE__ */ React6.createElement(ReasoningBlock, { reasoning: event.reasoning }) : null, !isPlanStateEmpty(event.planState) ? /* @__PURE__ */ React6.createElement(PlanStateBlock, { planState: event.planState }) : null, event.text ? /* @__PURE__ */ React6.createElement(Markdown, { text: event.text, projectRoot }) : /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, "(no content)"), event.stats ? /* @__PURE__ */ React6.createElement(StatsLine, { stats: event.stats }) : null, event.repair ? /* @__PURE__ */ React6.createElement(Text5, { color: "magenta" }, event.repair) : null));
   }
   if (event.role === "tool") {
     const isError = event.text.startsWith("ERROR:");
@@ -6524,31 +7309,31 @@ var EventRow = React5.memo(function EventRow2({
     const glyph = isError ? ROLE_GLYPH.toolErr : ROLE_GLYPH.toolOk;
     const marker = isError ? "\u2717" : "\u2192";
     const isEditFile = (event.toolName === "edit_file" || event.toolName?.endsWith("_edit_file")) && !isError;
-    return /* @__PURE__ */ React5.createElement(Box4, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React5.createElement(Box4, null, /* @__PURE__ */ React5.createElement(RoleGlyph, { glyph, color }), /* @__PURE__ */ React5.createElement(Text4, { color, bold: true }, `  ${event.toolName ?? "?"}`), /* @__PURE__ */ React5.createElement(Text4, { color, dimColor: true }, `  ${marker}`)), /* @__PURE__ */ React5.createElement(Box4, { flexDirection: "column", paddingLeft: 2, marginTop: 1 }, isEditFile ? /* @__PURE__ */ React5.createElement(EditFileDiff, { text: event.text }) : /* @__PURE__ */ React5.createElement(Text4, { color: isError ? "red" : void 0, dimColor: !isError }, truncate2(event.text, 400))));
+    return /* @__PURE__ */ React6.createElement(Box5, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React6.createElement(Box5, null, /* @__PURE__ */ React6.createElement(RoleGlyph, { glyph, color }), /* @__PURE__ */ React6.createElement(Text5, { color, bold: true }, `  ${event.toolName ?? "?"}`), /* @__PURE__ */ React6.createElement(Text5, { color, dimColor: true }, `  ${marker}`)), /* @__PURE__ */ React6.createElement(Box5, { flexDirection: "column", paddingLeft: 2, marginTop: 1 }, isEditFile ? /* @__PURE__ */ React6.createElement(EditFileDiff, { text: event.text }) : /* @__PURE__ */ React6.createElement(Text5, { color: isError ? "red" : void 0, dimColor: !isError }, truncate2(event.text, 400))));
   }
   if (event.role === "error") {
-    return /* @__PURE__ */ React5.createElement(Box4, { marginTop: 1 }, /* @__PURE__ */ React5.createElement(RoleGlyph, { glyph: ROLE_GLYPH.error, color: "red" }), /* @__PURE__ */ React5.createElement(Text4, { color: "red" }, "  ", event.text));
+    return /* @__PURE__ */ React6.createElement(Box5, { marginTop: 1 }, /* @__PURE__ */ React6.createElement(RoleGlyph, { glyph: ROLE_GLYPH.error, color: "red" }), /* @__PURE__ */ React6.createElement(Text5, { color: "red" }, "  ", event.text));
   }
   if (event.role === "info") {
-    return /* @__PURE__ */ React5.createElement(Box4, null, /* @__PURE__ */ React5.createElement(Text4, { dimColor: true }, event.text));
+    return /* @__PURE__ */ React6.createElement(Box5, null, /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, event.text));
   }
   if (event.role === "warning") {
-    return /* @__PURE__ */ React5.createElement(Box4, null, /* @__PURE__ */ React5.createElement(RoleGlyph, { glyph: ROLE_GLYPH.warning, color: "yellow" }), /* @__PURE__ */ React5.createElement(Text4, { color: "yellow" }, "  ", event.text));
+    return /* @__PURE__ */ React6.createElement(Box5, null, /* @__PURE__ */ React6.createElement(RoleGlyph, { glyph: ROLE_GLYPH.warning, color: "yellow" }), /* @__PURE__ */ React6.createElement(Text5, { color: "yellow" }, "  ", event.text));
   }
-  return /* @__PURE__ */ React5.createElement(Box4, null, /* @__PURE__ */ React5.createElement(Text4, null, event.text));
+  return /* @__PURE__ */ React6.createElement(Box5, null, /* @__PURE__ */ React6.createElement(Text5, null, event.text));
 });
 function EditFileDiff({ text }) {
   const lines = text.split(/\r?\n/);
   const [statusHeader, hunkHeader, ...body] = lines;
-  return /* @__PURE__ */ React5.createElement(Box4, { flexDirection: "column" }, /* @__PURE__ */ React5.createElement(Text4, { dimColor: true }, ` ${statusHeader ?? ""}`), hunkHeader !== void 0 ? /* @__PURE__ */ React5.createElement(Text4, { color: "cyan", bold: true }, hunkHeader) : null, body.map((line, i) => {
+  return /* @__PURE__ */ React6.createElement(Box5, { flexDirection: "column" }, /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, ` ${statusHeader ?? ""}`), hunkHeader !== void 0 ? /* @__PURE__ */ React6.createElement(Text5, { color: "cyan", bold: true }, hunkHeader) : null, body.map((line, i) => {
     const key = `${i}-${line.slice(0, 32)}`;
     if (line.startsWith("- ")) {
-      return /* @__PURE__ */ React5.createElement(Text4, { key, color: "red" }, line);
+      return /* @__PURE__ */ React6.createElement(Text5, { key, color: "red" }, line);
     }
     if (line.startsWith("+ ")) {
-      return /* @__PURE__ */ React5.createElement(Text4, { key, color: "green" }, line);
+      return /* @__PURE__ */ React6.createElement(Text5, { key, color: "green" }, line);
     }
-    return /* @__PURE__ */ React5.createElement(Text4, { key, dimColor: true }, line);
+    return /* @__PURE__ */ React6.createElement(Text5, { key, dimColor: true }, line);
   }));
 }
 function BranchBlock({ branch }) {
@@ -6557,33 +7342,33 @@ function BranchBlock({ branch }) {
     const t = (branch.temperatures[i] ?? 0).toFixed(1);
     return `${marker} #${i} T=${t} u=${u}`;
   }).join("  ");
-  return /* @__PURE__ */ React5.createElement(Box4, null, /* @__PURE__ */ React5.createElement(Text4, { color: "blue" }, "\u2387 branched ", /* @__PURE__ */ React5.createElement(Text4, { bold: true }, branch.budget), ` samples \u2192 picked #${branch.chosenIndex}   `, /* @__PURE__ */ React5.createElement(Text4, { dimColor: true }, per)));
+  return /* @__PURE__ */ React6.createElement(Box5, null, /* @__PURE__ */ React6.createElement(Text5, { color: "blue" }, "\u2387 branched ", /* @__PURE__ */ React6.createElement(Text5, { bold: true }, branch.budget), ` samples \u2192 picked #${branch.chosenIndex}   `, /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, per)));
 }
 function ReasoningBlock({ reasoning }) {
   const max = 260;
   const flat = reasoning.replace(/\s+/g, " ").trim();
   const preview = flat.length <= max ? flat : `\u2026 (+${flat.length - max} earlier chars) ${flat.slice(-max)}`;
-  return /* @__PURE__ */ React5.createElement(Box4, { marginBottom: 1 }, /* @__PURE__ */ React5.createElement(Text4, { dimColor: true }, "\u258F "), /* @__PURE__ */ React5.createElement(Text4, { dimColor: true, italic: true }, "thinking ", preview));
+  return /* @__PURE__ */ React6.createElement(Box5, { marginBottom: 1 }, /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, "\u258F "), /* @__PURE__ */ React6.createElement(Text5, { dimColor: true, italic: true }, "thinking ", preview));
 }
 function Elapsed() {
   const s = useElapsedSeconds();
   const mm = String(Math.floor(s / 60)).padStart(2, "0");
   const ss = String(s % 60).padStart(2, "0");
-  return /* @__PURE__ */ React5.createElement(Text4, { dimColor: true }, `${mm}:${ss}`);
+  return /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, `${mm}:${ss}`);
 }
 function PulsingAssistantGlyph() {
   const tick = useTick();
   const on = Math.floor(tick / 4) % 2 === 0;
-  return /* @__PURE__ */ React5.createElement(Text4, { color: "green", bold: true }, on ? ROLE_GLYPH.assistant : ROLE_GLYPH.assistantPulse);
+  return /* @__PURE__ */ React6.createElement(Text5, { color: "green", bold: true }, on ? ROLE_GLYPH.assistant : ROLE_GLYPH.assistantPulse);
 }
 function StreamingAssistant({ event }) {
   if (event.branchProgress) {
     const p = event.branchProgress;
     if (p.completed === 0) {
-      return /* @__PURE__ */ React5.createElement(Box4, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React5.createElement(Box4, null, /* @__PURE__ */ React5.createElement(PulsingAssistantGlyph, null), /* @__PURE__ */ React5.createElement(Text4, { color: "blue" }, "  \u2387 launching ", p.total, " parallel samples (R1 thinking in parallel)\u2026  "), /* @__PURE__ */ React5.createElement(Elapsed, null)), /* @__PURE__ */ React5.createElement(Text4, { color: "yellow" }, "  ", "spread across T=0.0/0.5/1.0 \xB7 reasoner typically takes 30-90s \u2014 this is normal"));
+      return /* @__PURE__ */ React6.createElement(Box5, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React6.createElement(Box5, null, /* @__PURE__ */ React6.createElement(PulsingAssistantGlyph, null), /* @__PURE__ */ React6.createElement(Text5, { color: "blue" }, "  \u2387 launching ", p.total, " parallel samples (R1 thinking in parallel)\u2026  "), /* @__PURE__ */ React6.createElement(Elapsed, null)), /* @__PURE__ */ React6.createElement(Text5, { color: "yellow" }, "  ", "spread across T=0.0/0.5/1.0 \xB7 reasoner typically takes 30-90s \u2014 this is normal"));
     }
     const pct2 = Math.round(p.completed / p.total * 100);
-    return /* @__PURE__ */ React5.createElement(Box4, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React5.createElement(Box4, null, /* @__PURE__ */ React5.createElement(PulsingAssistantGlyph, null), /* @__PURE__ */ React5.createElement(Text4, { color: "blue" }, "  \u2387 branching ", p.completed, "/", p.total, " (", pct2, "%)  "), /* @__PURE__ */ React5.createElement(Elapsed, null)), /* @__PURE__ */ React5.createElement(Text4, { dimColor: true }, "  latest #", p.latestIndex, " T=", p.latestTemperature.toFixed(1), " u=", p.latestUncertainties, p.completed < p.total ? "  \xB7 waiting for other samples\u2026" : "  \xB7 selecting winner\u2026"));
+    return /* @__PURE__ */ React6.createElement(Box5, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React6.createElement(Box5, null, /* @__PURE__ */ React6.createElement(PulsingAssistantGlyph, null), /* @__PURE__ */ React6.createElement(Text5, { color: "blue" }, "  \u2387 branching ", p.completed, "/", p.total, " (", pct2, "%)  "), /* @__PURE__ */ React6.createElement(Elapsed, null)), /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, "  latest #", p.latestIndex, " T=", p.latestTemperature.toFixed(1), " u=", p.latestUncertainties, p.completed < p.total ? "  \xB7 waiting for other samples\u2026" : "  \xB7 selecting winner\u2026"));
   }
   const tail = lastLine(event.text, 140);
   const reasoningTail = event.reasoning ? lastLine(event.reasoning, 120) : "";
@@ -6613,16 +7398,16 @@ function StreamingAssistant({ event }) {
     label = parts.join(" \xB7 ");
     labelColor = "green";
   }
-  return /* @__PURE__ */ React5.createElement(Box4, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React5.createElement(Box4, null, /* @__PURE__ */ React5.createElement(PulsingAssistantGlyph, null), /* @__PURE__ */ React5.createElement(Text4, null, "  "), /* @__PURE__ */ React5.createElement(Pulse, null), /* @__PURE__ */ React5.createElement(Text4, { color: labelColor }, ` ${label} `), /* @__PURE__ */ React5.createElement(Elapsed, null)), reasoningTail ? /* @__PURE__ */ React5.createElement(Text4, { dimColor: true, italic: true }, "\u21B3 thinking: ", reasoningTail) : null, tail ? /* @__PURE__ */ React5.createElement(Text4, { dimColor: true }, "\u25B8 ", tail) : preFirstByte ? (
+  return /* @__PURE__ */ React6.createElement(Box5, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React6.createElement(Box5, null, /* @__PURE__ */ React6.createElement(PulsingAssistantGlyph, null), /* @__PURE__ */ React6.createElement(Text5, null, "  "), /* @__PURE__ */ React6.createElement(Pulse, null), /* @__PURE__ */ React6.createElement(Text5, { color: labelColor }, ` ${label} `), /* @__PURE__ */ React6.createElement(Elapsed, null)), reasoningTail ? /* @__PURE__ */ React6.createElement(Text5, { dimColor: true, italic: true }, "\u21B3 thinking: ", reasoningTail) : null, tail ? /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, "\u25B8 ", tail) : preFirstByte ? (
     // Non-dim yellow: first-time users misread the dim version as
     // "app frozen". The reassurance has to be VISIBLE to do its job.
-    /* @__PURE__ */ React5.createElement(Text4, { color: "yellow", italic: true }, "  waiting for first byte \u2014 this is normal, typically 5-60s depending on model + load")
-  ) : reasoningOnly ? /* @__PURE__ */ React5.createElement(Text4, { color: "yellow", italic: true }, "  R1 is thinking before it speaks \u2014 body text arrives when reasoning finishes (typically 20-90s, this is normal)") : toolCallOnly ? /* @__PURE__ */ React5.createElement(Text4, { color: "magenta", italic: true }, "  tool-call arguments streaming \u2014 the model is about to dispatch a tool") : event.reasoning ? /* @__PURE__ */ React5.createElement(Text4, { color: "yellow", italic: true }, "  R1 still reasoning \u2014 body text or tool call arrives when thinking finishes") : null);
+    /* @__PURE__ */ React6.createElement(Text5, { color: "yellow", italic: true }, "  waiting for first byte \u2014 this is normal, typically 5-60s depending on model + load")
+  ) : reasoningOnly ? /* @__PURE__ */ React6.createElement(Text5, { color: "yellow", italic: true }, "  R1 is thinking before it speaks \u2014 body text arrives when reasoning finishes (typically 20-90s, this is normal)") : toolCallOnly ? /* @__PURE__ */ React6.createElement(Text5, { color: "magenta", italic: true }, "  tool-call arguments streaming \u2014 the model is about to dispatch a tool") : event.reasoning ? /* @__PURE__ */ React6.createElement(Text5, { color: "yellow", italic: true }, "  R1 still reasoning \u2014 body text or tool call arrives when thinking finishes") : null);
 }
 function Pulse() {
   const tick = useTick();
   const frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
-  return /* @__PURE__ */ React5.createElement(Text4, { color: "cyan" }, frames[Math.floor(tick / 4) % frames.length]);
+  return /* @__PURE__ */ React6.createElement(Text5, { color: "cyan" }, frames[Math.floor(tick / 4) % frames.length]);
 }
 function formatToolCallIndex(tb) {
   if (!tb || tb.index === void 0) return "";
@@ -6641,7 +7426,7 @@ function lastLine(s, maxChars) {
 }
 function StatsLine({ stats }) {
   const hit = (stats.cacheHitRatio * 100).toFixed(1);
-  return /* @__PURE__ */ React5.createElement(Box4, null, /* @__PURE__ */ React5.createElement(Text4, { dimColor: true }, "\u258F "), /* @__PURE__ */ React5.createElement(Text4, { dimColor: true }, "cache ", hit, "% \xB7 tokens ", stats.usage.promptTokens, " \u2192 ", stats.usage.completionTokens, " \xB7 $", stats.cost.toFixed(6)));
+  return /* @__PURE__ */ React6.createElement(Box5, null, /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, "\u258F "), /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, "cache ", hit, "% \xB7 tokens ", stats.usage.promptTokens, " \u2192 ", stats.usage.completionTokens, " \xB7 $", stats.cost.toFixed(6)));
 }
 function truncate2(s, max) {
   if (s.length <= max) return s;
@@ -6664,12 +7449,12 @@ ${s.slice(-max)}`;
 }
 
 // src/cli/ui/PlanConfirm.tsx
-import { Box as Box6, Text as Text6 } from "ink";
-import React7 from "react";
+import { Box as Box7, Text as Text7 } from "ink";
+import React8 from "react";
 
 // src/cli/ui/Select.tsx
-import { Box as Box5, Text as Text5, useInput } from "ink";
-import React6, { useState as useState2 } from "react";
+import { Box as Box6, Text as Text6, useInput as useInput2 } from "ink";
+import React7, { useState as useState3 } from "react";
 function SingleSelect({
   items,
   initialValue,
@@ -6681,8 +7466,8 @@ function SingleSelect({
     0,
     items.findIndex((i) => i.value === initialValue && !i.disabled)
   );
-  const [index, setIndex] = useState2(initialIndex === -1 ? 0 : initialIndex);
-  useInput((_input, key) => {
+  const [index, setIndex] = useState3(initialIndex === -1 ? 0 : initialIndex);
+  useInput2((_input, key) => {
     if (key.upArrow) {
       setIndex((i) => findNextEnabled(items, i, -1));
     } else if (key.downArrow) {
@@ -6694,7 +7479,7 @@ function SingleSelect({
       onCancel();
     }
   });
-  return /* @__PURE__ */ React6.createElement(Box5, { flexDirection: "column" }, items.map((item, i) => /* @__PURE__ */ React6.createElement(
+  return /* @__PURE__ */ React7.createElement(Box6, { flexDirection: "column" }, items.map((item, i) => /* @__PURE__ */ React7.createElement(
     SelectRow,
     {
       key: item.value,
@@ -6702,7 +7487,7 @@ function SingleSelect({
       active: i === index,
       marker: i === index ? "\u25B8" : " "
     }
-  )), footer ? /* @__PURE__ */ React6.createElement(Box5, { marginTop: 1 }, /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, footer)) : null);
+  )), footer ? /* @__PURE__ */ React7.createElement(Box6, { marginTop: 1 }, /* @__PURE__ */ React7.createElement(Text6, { dimColor: true }, footer)) : null);
 }
 function MultiSelect({
   items,
@@ -6711,12 +7496,12 @@ function MultiSelect({
   onCancel,
   footer
 }) {
-  const [index, setIndex] = useState2(() => {
+  const [index, setIndex] = useState3(() => {
     const first = items.findIndex((i) => !i.disabled);
     return first === -1 ? 0 : first;
   });
-  const [selected, setSelected] = useState2(new Set(initialSelected));
-  useInput((input, key) => {
+  const [selected, setSelected] = useState3(new Set(initialSelected));
+  useInput2((input, key) => {
     if (key.upArrow) {
       setIndex((i) => findNextEnabled(items, i, -1));
     } else if (key.downArrow) {
@@ -6737,10 +7522,10 @@ function MultiSelect({
       onCancel();
     }
   });
-  return /* @__PURE__ */ React6.createElement(Box5, { flexDirection: "column" }, items.map((item, i) => {
+  return /* @__PURE__ */ React7.createElement(Box6, { flexDirection: "column" }, items.map((item, i) => {
     const checked = selected.has(item.value);
     const marker = checked ? "[x]" : "[ ]";
-    return /* @__PURE__ */ React6.createElement(
+    return /* @__PURE__ */ React7.createElement(
       SelectRow,
       {
         key: item.value,
@@ -6749,7 +7534,7 @@ function MultiSelect({
         marker: `${i === index ? "\u25B8" : " "} ${marker}`
       }
     );
-  }), footer ? /* @__PURE__ */ React6.createElement(Box5, { marginTop: 1 }, /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, footer)) : null);
+  }), footer ? /* @__PURE__ */ React7.createElement(Box6, { marginTop: 1 }, /* @__PURE__ */ React7.createElement(Text6, { dimColor: true }, footer)) : null);
 }
 function SelectRow({
   item,
@@ -6757,7 +7542,7 @@ function SelectRow({
   marker
 }) {
   const color = item.disabled ? "gray" : active ? "cyan" : void 0;
-  return /* @__PURE__ */ React6.createElement(Box5, { flexDirection: "column" }, /* @__PURE__ */ React6.createElement(Box5, null, /* @__PURE__ */ React6.createElement(Text5, { color }, marker, " ", item.label)), item.hint ? /* @__PURE__ */ React6.createElement(Box5, { paddingLeft: marker.length + 1 }, /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, item.hint)) : null);
+  return /* @__PURE__ */ React7.createElement(Box6, { flexDirection: "column" }, /* @__PURE__ */ React7.createElement(Box6, null, /* @__PURE__ */ React7.createElement(Text6, { color }, marker, " ", item.label)), item.hint ? /* @__PURE__ */ React7.createElement(Box6, { paddingLeft: marker.length + 1 }, /* @__PURE__ */ React7.createElement(Text6, { dimColor: true }, item.hint)) : null);
 }
 function findNextEnabled(items, from, step) {
   if (items.length === 0) return 0;
@@ -6800,7 +7585,7 @@ function PlanConfirmInner({
   const sourceLineBudget = Math.max(MIN_BODY_ROWS, Math.floor(renderedBudget / MARKDOWN_EXPANSION));
   const visible = clampBodyByLines(charCapped, sourceLineBudget);
   const hasOpenQuestions = /^#{1,6}\s*(open[-\s]?questions?|risks?|unknowns?|assumptions?|unclear)/im.test(plan) || /^#{1,6}\s*(待确认|开放问题|风险|未知|假设|不确定)/im.test(plan);
-  return /* @__PURE__ */ React7.createElement(Box6, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, marginY: 1 }, /* @__PURE__ */ React7.createElement(Box6, null, /* @__PURE__ */ React7.createElement(Text6, { bold: true, color: "cyan" }, "\u25B8 plan submitted \u2014 awaiting your review")), /* @__PURE__ */ React7.createElement(Box6, null, /* @__PURE__ */ React7.createElement(Text6, { color: "cyan", dimColor: true }, "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500")), /* @__PURE__ */ React7.createElement(Box6, { marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React7.createElement(Markdown, { text: visible, projectRoot })), hasOpenQuestions ? /* @__PURE__ */ React7.createElement(Box6, { marginTop: 1 }, /* @__PURE__ */ React7.createElement(Text6, { color: "yellow" }, "\u25B2 the plan has open questions or flagged risks \u2014 pick", " ", /* @__PURE__ */ React7.createElement(Text6, { bold: true }, "Refine / answer questions"), " to write concrete answers before the model moves on.")) : null, /* @__PURE__ */ React7.createElement(Box6, { marginTop: 1 }, /* @__PURE__ */ React7.createElement(
+  return /* @__PURE__ */ React8.createElement(Box7, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, marginY: 1 }, /* @__PURE__ */ React8.createElement(Box7, null, /* @__PURE__ */ React8.createElement(Text7, { bold: true, color: "cyan" }, "\u25B8 plan submitted \u2014 awaiting your review")), /* @__PURE__ */ React8.createElement(Box7, null, /* @__PURE__ */ React8.createElement(Text7, { color: "cyan", dimColor: true }, "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500")), /* @__PURE__ */ React8.createElement(Box7, { marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React8.createElement(Markdown, { text: visible, projectRoot })), hasOpenQuestions ? /* @__PURE__ */ React8.createElement(Box7, { marginTop: 1 }, /* @__PURE__ */ React8.createElement(Text7, { color: "yellow" }, "\u25B2 the plan has open questions or flagged risks \u2014 pick", " ", /* @__PURE__ */ React8.createElement(Text7, { bold: true }, "Refine / answer questions"), " to write concrete answers before the model moves on.")) : null, /* @__PURE__ */ React8.createElement(Box7, { marginTop: 1 }, /* @__PURE__ */ React8.createElement(
     SingleSelect,
     {
       initialValue: hasOpenQuestions ? "refine" : "approve",
@@ -6827,14 +7612,14 @@ function PlanConfirmInner({
     }
   )));
 }
-var PlanConfirm = React7.memo(PlanConfirmInner);
+var PlanConfirm = React8.memo(PlanConfirmInner);
 
 // src/cli/ui/PlanRefineInput.tsx
-import { Box as Box7, Text as Text7, useInput as useInput2 } from "ink";
-import React8, { useState as useState3 } from "react";
+import { Box as Box8, Text as Text8, useInput as useInput3 } from "ink";
+import React9, { useState as useState4 } from "react";
 function PlanRefineInput({ mode, onSubmit, onCancel }) {
-  const [value, setValue] = useState3("");
-  useInput2((input, key) => {
+  const [value, setValue] = useState4("");
+  useInput3((input, key) => {
     if (key.escape) {
       onCancel();
       return;
@@ -6854,12 +7639,12 @@ function PlanRefineInput({ mode, onSubmit, onCancel }) {
   const title = mode === "approve" ? "\u25B8 approving \u2014 any last instructions or answers to open questions?" : "\u25B8 refining \u2014 what should the model change?";
   const hint = mode === "approve" ? "Answer questions the plan raised, add constraints, or just press Enter to approve as-is." : "Describe what's wrong or missing, or answer questions the plan raised.";
   const blankHint = mode === "approve" ? " (Enter with blank = approve without extra instructions.)" : " (Enter with blank = ask the model to list concrete questions.)";
-  return /* @__PURE__ */ React8.createElement(Box7, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, marginY: 1 }, /* @__PURE__ */ React8.createElement(Box7, null, /* @__PURE__ */ React8.createElement(Text7, { bold: true, color: "yellow" }, title)), /* @__PURE__ */ React8.createElement(Box7, { marginTop: 1 }, /* @__PURE__ */ React8.createElement(Text7, { dimColor: true }, hint, " Enter to send \xB7 Esc to return to the picker.", value === "" ? blankHint : "")), /* @__PURE__ */ React8.createElement(Box7, { marginTop: 1 }, /* @__PURE__ */ React8.createElement(Text7, null, /* @__PURE__ */ React8.createElement(Text7, { color: "yellow" }, "\u203A "), /* @__PURE__ */ React8.createElement(Text7, null, value || " "), /* @__PURE__ */ React8.createElement(Text7, { color: "yellow" }, "\u258D"))));
+  return /* @__PURE__ */ React9.createElement(Box8, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, marginY: 1 }, /* @__PURE__ */ React9.createElement(Box8, null, /* @__PURE__ */ React9.createElement(Text8, { bold: true, color: "yellow" }, title)), /* @__PURE__ */ React9.createElement(Box8, { marginTop: 1 }, /* @__PURE__ */ React9.createElement(Text8, { dimColor: true }, hint, " Enter to send \xB7 Esc to return to the picker.", value === "" ? blankHint : "")), /* @__PURE__ */ React9.createElement(Box8, { marginTop: 1 }, /* @__PURE__ */ React9.createElement(Text8, null, /* @__PURE__ */ React9.createElement(Text8, { color: "yellow" }, "\u203A "), /* @__PURE__ */ React9.createElement(Text8, null, value || " "), /* @__PURE__ */ React9.createElement(Text8, { color: "yellow" }, "\u258D"))));
 }
 
 // src/cli/ui/PromptInput.tsx
-import { Box as Box8, Text as Text8, useInput as useInput3 } from "ink";
-import React9, { useRef, useState as useState4 } from "react";
+import { Box as Box9, Text as Text9, useInput as useInput4 } from "ink";
+import React10, { useRef, useState as useState5 } from "react";
 
 // src/cli/ui/multiline-keys.ts
 var BACKSLASH_SUFFIX = /\\$/;
@@ -6974,7 +7759,7 @@ function PromptInput({
   disabled,
   placeholder
 }) {
-  const [cursor, setCursor] = useState4(value.length);
+  const [cursor, setCursor] = useState5(value.length);
   const lastLocalValueRef = useRef(value);
   if (value !== lastLocalValueRef.current) {
     lastLocalValueRef.current = value;
@@ -6984,7 +7769,7 @@ function PromptInput({
   }
   const tick = useTick();
   const showCursor = disabled ? false : Math.floor(tick / 4) % 2 === 0;
-  useInput3(
+  useInput4(
     (input, key) => {
       const ke = {
         input,
@@ -7019,13 +7804,13 @@ function PromptInput({
   const lines = value.length > 0 ? value.split("\n") : [""];
   const borderColor = disabled ? "gray" : "cyan";
   const { line: cursorLine, col: cursorCol } = lineAndColumn(value, cursor);
-  return /* @__PURE__ */ React9.createElement(Box8, { borderStyle: "round", borderColor, paddingX: 1, flexDirection: "column" }, lines.map((line, i) => {
+  return /* @__PURE__ */ React10.createElement(Box9, { borderStyle: "round", borderColor, paddingX: 1, flexDirection: "column" }, lines.map((line, i) => {
     const isFirst = i === 0;
     const showPlaceholder = isFirst && value.length === 0;
     const isCursorLine = i === cursorLine;
     return (
       // biome-ignore lint/suspicious/noArrayIndexKey: stable by construction — lines are derived from `value.split("\n")` and never reordered
-      /* @__PURE__ */ React9.createElement(Box8, { key: i }, isFirst ? /* @__PURE__ */ React9.createElement(Text8, { bold: true, color: borderColor }, "you \u203A", " ") : /* @__PURE__ */ React9.createElement(Text8, { dimColor: true }, "     "), showPlaceholder ? /* @__PURE__ */ React9.createElement(React9.Fragment, null, isCursorLine && !disabled ? /* @__PURE__ */ React9.createElement(Text8, { color: borderColor }, showCursor ? "\u258C" : " ") : null, /* @__PURE__ */ React9.createElement(Text8, { dimColor: true }, effectivePlaceholder)) : isCursorLine && !disabled ? /* @__PURE__ */ React9.createElement(
+      /* @__PURE__ */ React10.createElement(Box9, { key: i }, isFirst ? /* @__PURE__ */ React10.createElement(Text9, { bold: true, color: borderColor }, "you \u203A", " ") : /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, "     "), showPlaceholder ? /* @__PURE__ */ React10.createElement(React10.Fragment, null, isCursorLine && !disabled ? /* @__PURE__ */ React10.createElement(Text9, { color: borderColor }, showCursor ? "\u258C" : " ") : null, /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, effectivePlaceholder)) : isCursorLine && !disabled ? /* @__PURE__ */ React10.createElement(
         LineWithCursor,
         {
           line,
@@ -7033,7 +7818,7 @@ function PromptInput({
           showCursor,
           borderColor
         }
-      ) : /* @__PURE__ */ React9.createElement(Text8, null, line))
+      ) : /* @__PURE__ */ React10.createElement(Text9, null, line))
     );
   }));
 }
@@ -7047,16 +7832,17 @@ function LineWithCursor({
   const atCursor = line.slice(col, col + 1);
   const after = line.slice(col + 1);
   if (atCursor.length === 0) {
-    return /* @__PURE__ */ React9.createElement(React9.Fragment, null, /* @__PURE__ */ React9.createElement(Text8, null, before), /* @__PURE__ */ React9.createElement(Text8, { color: borderColor }, showCursor ? "\u258C" : " "));
+    return /* @__PURE__ */ React10.createElement(React10.Fragment, null, /* @__PURE__ */ React10.createElement(Text9, null, before), /* @__PURE__ */ React10.createElement(Text9, { color: borderColor }, showCursor ? "\u258C" : " "));
   }
-  return /* @__PURE__ */ React9.createElement(React9.Fragment, null, /* @__PURE__ */ React9.createElement(Text8, null, before), /* @__PURE__ */ React9.createElement(Text8, { inverse: showCursor }, atCursor), /* @__PURE__ */ React9.createElement(Text8, null, after));
+  return /* @__PURE__ */ React10.createElement(React10.Fragment, null, /* @__PURE__ */ React10.createElement(Text9, null, before), /* @__PURE__ */ React10.createElement(Text9, { inverse: showCursor }, atCursor), /* @__PURE__ */ React10.createElement(Text9, null, after));
 }
 
 // src/cli/ui/ShellConfirm.tsx
-import { Box as Box9, Text as Text9 } from "ink";
-import React10 from "react";
-function ShellConfirm({ command, allowPrefix, onChoose }) {
-  return /* @__PURE__ */ React10.createElement(Box9, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, marginY: 1 }, /* @__PURE__ */ React10.createElement(Box9, null, /* @__PURE__ */ React10.createElement(Text9, { bold: true, color: "yellow" }, "\u25B8 model wants to run a shell command")), /* @__PURE__ */ React10.createElement(Box9, null, /* @__PURE__ */ React10.createElement(Text9, { color: "yellow", dimColor: true }, "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500")), /* @__PURE__ */ React10.createElement(Box9, { marginTop: 1 }, /* @__PURE__ */ React10.createElement(Text9, null, /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, "$ "), /* @__PURE__ */ React10.createElement(Text9, { color: "cyan" }, command))), /* @__PURE__ */ React10.createElement(Box9, { marginTop: 1 }, /* @__PURE__ */ React10.createElement(
+import { Box as Box10, Text as Text10 } from "ink";
+import React11 from "react";
+function ShellConfirm({ command, allowPrefix, kind, onChoose }) {
+  const isBackground = kind === "run_background";
+  return /* @__PURE__ */ React11.createElement(Box10, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, marginY: 1 }, /* @__PURE__ */ React11.createElement(Box10, null, /* @__PURE__ */ React11.createElement(Text10, { bold: true, color: "yellow" }, isBackground ? "\u25B8 model wants to start a BACKGROUND process" : "\u25B8 model wants to run a shell command")), isBackground ? /* @__PURE__ */ React11.createElement(Box10, null, /* @__PURE__ */ React11.createElement(Text10, { dimColor: true }, "  (long-running: dev server / watcher; keeps running after approval, /kill to stop)")) : null, /* @__PURE__ */ React11.createElement(Box10, null, /* @__PURE__ */ React11.createElement(Text10, { color: "yellow", dimColor: true }, "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500")), /* @__PURE__ */ React11.createElement(Box10, { marginTop: 1 }, /* @__PURE__ */ React11.createElement(Text10, null, /* @__PURE__ */ React11.createElement(Text10, { dimColor: true }, "$ "), /* @__PURE__ */ React11.createElement(Text10, { color: "cyan" }, command))), /* @__PURE__ */ React11.createElement(Box10, { marginTop: 1 }, /* @__PURE__ */ React11.createElement(
     SingleSelect,
     {
       initialValue: "run_once",
@@ -7113,8 +7899,8 @@ function derivePrefix(command) {
 }
 
 // src/cli/ui/SlashArgPicker.tsx
-import { Box as Box10, Text as Text10 } from "ink";
-import React11 from "react";
+import { Box as Box11, Text as Text11 } from "ink";
+import React12 from "react";
 function SlashArgPicker({
   matches,
   selectedIndex,
@@ -7123,11 +7909,11 @@ function SlashArgPicker({
   partial
 }) {
   if (kind === "hint") {
-    return /* @__PURE__ */ React11.createElement(Box10, { paddingX: 1 }, /* @__PURE__ */ React11.createElement(Text10, { dimColor: true }, "  ", /* @__PURE__ */ React11.createElement(Text10, { bold: true }, "/", spec.cmd), spec.argsHint ? ` ${spec.argsHint}` : "", " \u2014 ", spec.summary));
+    return /* @__PURE__ */ React12.createElement(Box11, { paddingX: 1 }, /* @__PURE__ */ React12.createElement(Text11, { dimColor: true }, "  ", /* @__PURE__ */ React12.createElement(Text11, { bold: true }, "/", spec.cmd), spec.argsHint ? ` ${spec.argsHint}` : "", " \u2014 ", spec.summary));
   }
   if (matches === null) return null;
   if (matches.length === 0) {
-    return /* @__PURE__ */ React11.createElement(Box10, { flexDirection: "column", paddingX: 1 }, /* @__PURE__ */ React11.createElement(Text10, { dimColor: true }, "  ", /* @__PURE__ */ React11.createElement(Text10, { bold: true }, "/", spec.cmd), spec.argsHint ? ` ${spec.argsHint}` : "", " \u2014 ", spec.summary), /* @__PURE__ */ React11.createElement(Text10, { color: "yellow" }, ' no match for "', partial, '" \u2014 keep typing, or Backspace to edit'));
+    return /* @__PURE__ */ React12.createElement(Box11, { flexDirection: "column", paddingX: 1 }, /* @__PURE__ */ React12.createElement(Text11, { dimColor: true }, "  ", /* @__PURE__ */ React12.createElement(Text11, { bold: true }, "/", spec.cmd), spec.argsHint ? ` ${spec.argsHint}` : "", " \u2014 ", spec.summary), /* @__PURE__ */ React12.createElement(Text11, { color: "yellow" }, ' no match for "', partial, '" \u2014 keep typing, or Backspace to edit'));
   }
   const MAX = 8;
   const total = matches.length;
@@ -7135,26 +7921,26 @@ function SlashArgPicker({
   const shown = matches.slice(windowStart, windowStart + MAX);
   const hiddenAbove = windowStart;
   const hiddenBelow = total - windowStart - shown.length;
-  return /* @__PURE__ */ React11.createElement(Box10, { flexDirection: "column", paddingX: 1 }, /* @__PURE__ */ React11.createElement(Text10, { dimColor: true }, "  ", /* @__PURE__ */ React11.createElement(Text10, { bold: true }, "/", spec.cmd), spec.argsHint ? ` ${spec.argsHint}` : "", " \u2014 ", spec.summary), hiddenAbove > 0 ? /* @__PURE__ */ React11.createElement(Text10, { dimColor: true }, " \u2191 ", hiddenAbove, " more above") : null, shown.map((value, i) => /* @__PURE__ */ React11.createElement(ArgRow, { key: value, value, isSelected: windowStart + i === selectedIndex })), hiddenBelow > 0 ? /* @__PURE__ */ React11.createElement(Text10, { dimColor: true }, " \u2193 ", hiddenBelow, " more below") : null, /* @__PURE__ */ React11.createElement(Text10, { dimColor: true }, " [\u2191\u2193] navigate \xB7 [Tab]/[Enter] pick"));
+  return /* @__PURE__ */ React12.createElement(Box11, { flexDirection: "column", paddingX: 1 }, /* @__PURE__ */ React12.createElement(Text11, { dimColor: true }, "  ", /* @__PURE__ */ React12.createElement(Text11, { bold: true }, "/", spec.cmd), spec.argsHint ? ` ${spec.argsHint}` : "", " \u2014 ", spec.summary), hiddenAbove > 0 ? /* @__PURE__ */ React12.createElement(Text11, { dimColor: true }, " \u2191 ", hiddenAbove, " more above") : null, shown.map((value, i) => /* @__PURE__ */ React12.createElement(ArgRow, { key: value, value, isSelected: windowStart + i === selectedIndex })), hiddenBelow > 0 ? /* @__PURE__ */ React12.createElement(Text11, { dimColor: true }, " \u2193 ", hiddenBelow, " more below") : null, /* @__PURE__ */ React12.createElement(Text11, { dimColor: true }, " [\u2191\u2193] navigate \xB7 [Tab]/[Enter] pick"));
 }
 function ArgRow({ value, isSelected }) {
   const marker = isSelected ? "\u25B8" : " ";
   if (isSelected) {
-    return /* @__PURE__ */ React11.createElement(Box10, null, /* @__PURE__ */ React11.createElement(Text10, { bold: true, color: "cyan" }, marker, " ", value));
+    return /* @__PURE__ */ React12.createElement(Box11, null, /* @__PURE__ */ React12.createElement(Text11, { bold: true, color: "cyan" }, marker, " ", value));
   }
-  return /* @__PURE__ */ React11.createElement(Box10, null, /* @__PURE__ */ React11.createElement(Text10, { dimColor: true }, marker, " ", value));
+  return /* @__PURE__ */ React12.createElement(Box11, null, /* @__PURE__ */ React12.createElement(Text11, { dimColor: true }, marker, " ", value));
 }
 
 // src/cli/ui/SlashSuggestions.tsx
-import { Box as Box11, Text as Text11 } from "ink";
-import React12 from "react";
+import { Box as Box12, Text as Text12 } from "ink";
+import React13 from "react";
 function SlashSuggestions({
   matches,
   selectedIndex
 }) {
   if (matches === null) return null;
   if (matches.length === 0) {
-    return /* @__PURE__ */ React12.createElement(Box11, { paddingX: 1 }, /* @__PURE__ */ React12.createElement(Text11, { color: "yellow" }, "no slash command matches that prefix"), /* @__PURE__ */ React12.createElement(Text11, { dimColor: true }, " \u2014 Backspace to edit, or /help for the full list"));
+    return /* @__PURE__ */ React13.createElement(Box12, { paddingX: 1 }, /* @__PURE__ */ React13.createElement(Text12, { color: "yellow" }, "no slash command matches that prefix"), /* @__PURE__ */ React13.createElement(Text12, { dimColor: true }, " \u2014 Backspace to edit, or /help for the full list"));
   }
   const MAX = 8;
   const total = matches.length;
@@ -7162,21 +7948,21 @@ function SlashSuggestions({
   const shown = matches.slice(windowStart, windowStart + MAX);
   const hiddenAbove = windowStart;
   const hiddenBelow = total - windowStart - shown.length;
-  return /* @__PURE__ */ React12.createElement(Box11, { flexDirection: "column", paddingX: 1 }, hiddenAbove > 0 ? /* @__PURE__ */ React12.createElement(Text11, { dimColor: true }, " \u2191 ", hiddenAbove, " more above") : null, shown.map((spec, i) => /* @__PURE__ */ React12.createElement(SuggestionRow, { key: spec.cmd, spec, isSelected: windowStart + i === selectedIndex })), hiddenBelow > 0 ? /* @__PURE__ */ React12.createElement(Text11, { dimColor: true }, " \u2193 ", hiddenBelow, " more below") : null, /* @__PURE__ */ React12.createElement(Text11, { dimColor: true }, " [\u2191\u2193] navigate \xB7 [Tab]/[Enter] pick"));
+  return /* @__PURE__ */ React13.createElement(Box12, { flexDirection: "column", paddingX: 1 }, hiddenAbove > 0 ? /* @__PURE__ */ React13.createElement(Text12, { dimColor: true }, " \u2191 ", hiddenAbove, " more above") : null, shown.map((spec, i) => /* @__PURE__ */ React13.createElement(SuggestionRow, { key: spec.cmd, spec, isSelected: windowStart + i === selectedIndex })), hiddenBelow > 0 ? /* @__PURE__ */ React13.createElement(Text12, { dimColor: true }, " \u2193 ", hiddenBelow, " more below") : null, /* @__PURE__ */ React13.createElement(Text12, { dimColor: true }, " [\u2191\u2193] navigate \xB7 [Tab]/[Enter] pick"));
 }
 function SuggestionRow({ spec, isSelected }) {
   const marker = isSelected ? "\u25B8" : " ";
   const name = `/${spec.cmd}`;
   const argsSuffix = spec.argsHint ? ` ${spec.argsHint}` : "";
   if (isSelected) {
-    return /* @__PURE__ */ React12.createElement(Box11, null, /* @__PURE__ */ React12.createElement(Text11, { bold: true, color: "cyan" }, marker, " ", name.padEnd(12), argsSuffix.padEnd(16)), /* @__PURE__ */ React12.createElement(Text11, { color: "cyan" }, " ", spec.summary));
+    return /* @__PURE__ */ React13.createElement(Box12, null, /* @__PURE__ */ React13.createElement(Text12, { bold: true, color: "cyan" }, marker, " ", name.padEnd(12), argsSuffix.padEnd(16)), /* @__PURE__ */ React13.createElement(Text12, { color: "cyan" }, " ", spec.summary));
   }
-  return /* @__PURE__ */ React12.createElement(Box11, null, /* @__PURE__ */ React12.createElement(Text11, { dimColor: true }, marker, " ", name.padEnd(12), argsSuffix.padEnd(16), " ", spec.summary));
+  return /* @__PURE__ */ React13.createElement(Box12, null, /* @__PURE__ */ React13.createElement(Text12, { dimColor: true }, marker, " ", name.padEnd(12), argsSuffix.padEnd(16), " ", spec.summary));
 }
 
 // src/cli/ui/StatsPanel.tsx
-import { Box as Box12, Text as Text12, useStdout as useStdout2 } from "ink";
-import React13 from "react";
+import { Box as Box13, Text as Text13, useStdout as useStdout3 } from "ink";
+import React14 from "react";
 var WORDMARK_STYLES = [
   { ch: "\u25C8", color: "#5eead4", isLogo: true },
   // teal — brand mark
@@ -7202,7 +7988,7 @@ function Wordmark({ busy }) {
   const tick = useTick();
   const period = busy ? 5 : 12;
   const bright = Math.floor(tick / period) % 2 === 0;
-  return /* @__PURE__ */ React13.createElement(Text12, null, WORDMARK_STYLES.map((c) => /* @__PURE__ */ React13.createElement(Text12, { key: `${c.ch}-${c.color}`, color: c.color, bold: c.isLogo ? bright : true }, c.ch)));
+  return /* @__PURE__ */ React14.createElement(Text13, null, WORDMARK_STYLES.map((c) => /* @__PURE__ */ React14.createElement(Text13, { key: `${c.ch}-${c.color}`, color: c.color, bold: c.isLogo ? bright : true }, c.ch)));
 }
 var NARROW_BREAKPOINT = 120;
 var COLD_START_TURNS = 3;
@@ -7214,6 +8000,7 @@ function StatsPanel({
   branchBudget,
   reasoningEffort,
   planMode,
+  editMode,
   balance,
   updateAvailable,
   busy
@@ -7221,11 +8008,11 @@ function StatsPanel({
   const branchOn = (branchBudget ?? 1) > 1;
   const ctxMax = DEEPSEEK_CONTEXT_TOKENS[model] ?? DEFAULT_CONTEXT_TOKENS;
   const ctxRatio = summary.lastPromptTokens / ctxMax;
-  const { stdout: stdout2 } = useStdout2();
+  const { stdout: stdout2 } = useStdout3();
   const columns = stdout2?.columns ?? 80;
   const narrow = columns < NARROW_BREAKPOINT;
   const coldStart = summary.turns <= COLD_START_TURNS;
-  return /* @__PURE__ */ React13.createElement(Box12, { borderStyle: "round", borderColor: "cyan", flexDirection: "column", paddingX: 1 }, /* @__PURE__ */ React13.createElement(
+  return /* @__PURE__ */ React14.createElement(Box13, { borderStyle: "round", borderColor: "cyan", flexDirection: "column", paddingX: 1 }, /* @__PURE__ */ React14.createElement(
     Header,
     {
       model,
@@ -7235,12 +8022,13 @@ function StatsPanel({
       branchBudget: branchBudget ?? 1,
       reasoningEffort,
       planMode,
+      editMode,
       turns: summary.turns,
       updateAvailable,
       narrow,
       busy: busy ?? false
     }
-  ), narrow ? /* @__PURE__ */ React13.createElement(
+  ), narrow ? /* @__PURE__ */ React14.createElement(
     StackedMetrics,
     {
       summary,
@@ -7249,7 +8037,7 @@ function StatsPanel({
       balance,
       coldStart
     }
-  ) : /* @__PURE__ */ React13.createElement(
+  ) : /* @__PURE__ */ React14.createElement(
     InlineMetrics,
     {
       summary,
@@ -7268,12 +8056,13 @@ function Header({
   branchBudget,
   reasoningEffort,
   planMode,
+  editMode,
   turns,
   updateAvailable,
   narrow,
   busy
 }) {
-  return /* @__PURE__ */ React13.createElement(Box12, { justifyContent: "space-between" }, /* @__PURE__ */ React13.createElement(Box12, null, /* @__PURE__ */ React13.createElement(Wordmark, { busy }), /* @__PURE__ */ React13.createElement(Text12, { dimColor: true }, ` v${VERSION}`), /* @__PURE__ */ React13.createElement(Text12, { dimColor: true }, " \xB7 "), /* @__PURE__ */ React13.createElement(Text12, { color: "yellow" }, model), narrow ? null : /* @__PURE__ */ React13.createElement(React13.Fragment, null, /* @__PURE__ */ React13.createElement(Text12, { dimColor: true }, " \xB7 "), /* @__PURE__ */ React13.createElement(Text12, { dimColor: true }, prefixHash)), harvestOn ? /* @__PURE__ */ React13.createElement(Text12, { color: "magenta" }, " \xB7 harvest") : null, branchOn ? /* @__PURE__ */ React13.createElement(Text12, { color: "blue" }, " \xB7 branch", branchBudget) : null, reasoningEffort === "max" ? /* @__PURE__ */ React13.createElement(Text12, { color: "green" }, " \xB7 max") : null, reasoningEffort === "high" ? /* @__PURE__ */ React13.createElement(Text12, { color: "yellow" }, " \xB7 high") : null, planMode ? /* @__PURE__ */ React13.createElement(Text12, { color: "red", bold: true }, " \xB7 PLAN") : null), /* @__PURE__ */ React13.createElement(Text12, null, updateAvailable ? /* @__PURE__ */ React13.createElement(Text12, { color: "yellow", bold: true }, `update: ${updateAvailable} \xB7 `) : null, /* @__PURE__ */ React13.createElement(Text12, { dimColor: true }, narrow ? `turn ${turns}` : `turn ${turns} \xB7 /help`)));
+  return /* @__PURE__ */ React14.createElement(Box13, { justifyContent: "space-between" }, /* @__PURE__ */ React14.createElement(Box13, null, /* @__PURE__ */ React14.createElement(Wordmark, { busy }), /* @__PURE__ */ React14.createElement(Text13, { dimColor: true }, ` v${VERSION}`), /* @__PURE__ */ React14.createElement(Text13, { dimColor: true }, " \xB7 "), /* @__PURE__ */ React14.createElement(Text13, { color: "yellow" }, model), narrow ? null : /* @__PURE__ */ React14.createElement(React14.Fragment, null, /* @__PURE__ */ React14.createElement(Text13, { dimColor: true }, " \xB7 "), /* @__PURE__ */ React14.createElement(Text13, { dimColor: true }, prefixHash)), harvestOn ? /* @__PURE__ */ React14.createElement(Text13, { color: "magenta" }, " \xB7 harvest") : null, branchOn ? /* @__PURE__ */ React14.createElement(Text13, { color: "blue" }, " \xB7 branch", branchBudget) : null, reasoningEffort === "max" ? /* @__PURE__ */ React14.createElement(Text13, { color: "green" }, " \xB7 max") : null, reasoningEffort === "high" ? /* @__PURE__ */ React14.createElement(Text13, { color: "yellow" }, " \xB7 high") : null, planMode ? /* @__PURE__ */ React14.createElement(Text13, { color: "red", bold: true }, " \xB7 PLAN") : null, editMode ? /* @__PURE__ */ React14.createElement(Text13, { color: editMode === "auto" ? "magenta" : "cyan", bold: true }, editMode === "auto" ? " \xB7 AUTO" : " \xB7 review") : null), /* @__PURE__ */ React14.createElement(Text13, null, updateAvailable ? /* @__PURE__ */ React14.createElement(Text13, { color: "yellow", bold: true }, `update: ${updateAvailable} \xB7 `) : null, /* @__PURE__ */ React14.createElement(Text13, { dimColor: true }, narrow ? `turn ${turns}` : `turn ${turns} \xB7 /help`)));
 }
 function InlineMetrics({
   summary,
@@ -7282,7 +8071,7 @@ function InlineMetrics({
   balance,
   coldStart
 }) {
-  return /* @__PURE__ */ React13.createElement(Box12, { marginTop: 1, gap: 3 }, /* @__PURE__ */ React13.createElement(ContextCell, { ratio: ctxRatio, promptTokens: summary.lastPromptTokens, ctxMax }), /* @__PURE__ */ React13.createElement(CacheCell, { hitRatio: summary.cacheHitRatio, coldStart, turns: summary.turns }), /* @__PURE__ */ React13.createElement(CostCell, { summary, coldStart }), balance ? /* @__PURE__ */ React13.createElement(BalanceCell, { balance }) : null);
+  return /* @__PURE__ */ React14.createElement(Box13, { marginTop: 1, gap: 3 }, /* @__PURE__ */ React14.createElement(ContextCell, { ratio: ctxRatio, promptTokens: summary.lastPromptTokens, ctxMax }), /* @__PURE__ */ React14.createElement(CacheCell, { hitRatio: summary.cacheHitRatio, coldStart, turns: summary.turns }), /* @__PURE__ */ React14.createElement(CostCell, { summary, coldStart }), balance ? /* @__PURE__ */ React14.createElement(BalanceCell, { balance }) : null);
 }
 function StackedMetrics({
   summary,
@@ -7291,7 +8080,7 @@ function StackedMetrics({
   balance,
   coldStart
 }) {
-  return /* @__PURE__ */ React13.createElement(Box12, { marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React13.createElement(
+  return /* @__PURE__ */ React14.createElement(Box13, { marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React14.createElement(
     ContextCell,
     {
       ratio: ctxRatio,
@@ -7299,7 +8088,7 @@ function StackedMetrics({
       ctxMax,
       showBar: true
     }
-  ), balance ? /* @__PURE__ */ React13.createElement(BalanceCell, { balance }) : null, /* @__PURE__ */ React13.createElement(CacheCell, { hitRatio: summary.cacheHitRatio, coldStart, turns: summary.turns }), /* @__PURE__ */ React13.createElement(CostCell, { summary, coldStart }));
+  ), balance ? /* @__PURE__ */ React14.createElement(BalanceCell, { balance }) : null, /* @__PURE__ */ React14.createElement(CacheCell, { hitRatio: summary.cacheHitRatio, coldStart, turns: summary.turns }), /* @__PURE__ */ React14.createElement(CostCell, { summary, coldStart }));
 }
 function ContextCell({
   ratio,
@@ -7308,11 +8097,11 @@ function ContextCell({
   showBar
 }) {
   if (promptTokens === 0) {
-    return /* @__PURE__ */ React13.createElement(Text12, null, /* @__PURE__ */ React13.createElement(Text12, { dimColor: true }, "ctx "), /* @__PURE__ */ React13.createElement(Text12, { dimColor: true }, "\u2014 (no turns yet)"));
+    return /* @__PURE__ */ React14.createElement(Text13, null, /* @__PURE__ */ React14.createElement(Text13, { dimColor: true }, "ctx "), /* @__PURE__ */ React14.createElement(Text13, { dimColor: true }, "\u2014 (no turns yet)"));
   }
   const color = ratio >= 0.8 ? "red" : ratio >= 0.6 ? "yellow" : "green";
   const pct2 = Math.round(ratio * 100);
-  return /* @__PURE__ */ React13.createElement(Text12, null, /* @__PURE__ */ React13.createElement(Text12, { dimColor: true }, "ctx "), showBar ? /* @__PURE__ */ React13.createElement(Bar, { ratio, color }) : null, showBar ? /* @__PURE__ */ React13.createElement(Text12, null, " ") : null, /* @__PURE__ */ React13.createElement(Text12, { color, bold: true }, formatTokens(promptTokens), "/", formatTokens(ctxMax)), /* @__PURE__ */ React13.createElement(Text12, { dimColor: true }, " (", pct2, "%)"), ratio >= 0.8 ? /* @__PURE__ */ React13.createElement(Text12, { color: "red", bold: true }, "  \xB7  /compact") : null);
+  return /* @__PURE__ */ React14.createElement(Text13, null, /* @__PURE__ */ React14.createElement(Text13, { dimColor: true }, "ctx "), showBar ? /* @__PURE__ */ React14.createElement(Bar, { ratio, color }) : null, showBar ? /* @__PURE__ */ React14.createElement(Text13, null, " ") : null, /* @__PURE__ */ React14.createElement(Text13, { color, bold: true }, formatTokens(promptTokens), "/", formatTokens(ctxMax)), /* @__PURE__ */ React14.createElement(Text13, { dimColor: true }, " (", pct2, "%)"), ratio >= 0.8 ? /* @__PURE__ */ React14.createElement(Text13, { color: "red", bold: true }, "  \xB7  /compact") : null);
 }
 function CacheCell({
   hitRatio,
@@ -7321,33 +8110,33 @@ function CacheCell({
 }) {
   const pct2 = (hitRatio * 100).toFixed(1);
   if (turns === 0) {
-    return /* @__PURE__ */ React13.createElement(Text12, null, /* @__PURE__ */ React13.createElement(Text12, { dimColor: true }, "cache "), /* @__PURE__ */ React13.createElement(Text12, { dimColor: true }, "\u2014"));
+    return /* @__PURE__ */ React14.createElement(Text13, null, /* @__PURE__ */ React14.createElement(Text13, { dimColor: true }, "cache "), /* @__PURE__ */ React14.createElement(Text13, { dimColor: true }, "\u2014"));
   }
   if (coldStart) {
-    return /* @__PURE__ */ React13.createElement(Text12, null, /* @__PURE__ */ React13.createElement(Text12, { dimColor: true }, "cache "), /* @__PURE__ */ React13.createElement(Text12, { dimColor: true }, pct2, "% "), /* @__PURE__ */ React13.createElement(Text12, { dimColor: true, italic: true }, "(cold start)"));
+    return /* @__PURE__ */ React14.createElement(Text13, null, /* @__PURE__ */ React14.createElement(Text13, { dimColor: true }, "cache "), /* @__PURE__ */ React14.createElement(Text13, { dimColor: true }, pct2, "% "), /* @__PURE__ */ React14.createElement(Text13, { dimColor: true, italic: true }, "(cold start)"));
   }
   const color = hitRatio >= 0.7 ? "green" : hitRatio >= 0.4 ? "yellow" : "red";
-  return /* @__PURE__ */ React13.createElement(Text12, null, /* @__PURE__ */ React13.createElement(Text12, { dimColor: true }, "cache "), /* @__PURE__ */ React13.createElement(Text12, { color, bold: true }, pct2, "%"));
+  return /* @__PURE__ */ React14.createElement(Text13, null, /* @__PURE__ */ React14.createElement(Text13, { dimColor: true }, "cache "), /* @__PURE__ */ React14.createElement(Text13, { color, bold: true }, pct2, "%"));
 }
 function CostCell({
   summary,
   coldStart
 }) {
   if (summary.turns === 0) {
-    return /* @__PURE__ */ React13.createElement(Text12, null, /* @__PURE__ */ React13.createElement(Text12, { dimColor: true }, "cost "), /* @__PURE__ */ React13.createElement(Text12, { dimColor: true }, "\u2014"));
+    return /* @__PURE__ */ React14.createElement(Text13, null, /* @__PURE__ */ React14.createElement(Text13, { dimColor: true }, "cost "), /* @__PURE__ */ React14.createElement(Text13, { dimColor: true }, "\u2014"));
   }
   const primaryColor = coldStart ? void 0 : "green";
-  return /* @__PURE__ */ React13.createElement(Text12, null, /* @__PURE__ */ React13.createElement(Text12, { dimColor: true }, "cost "), /* @__PURE__ */ React13.createElement(Text12, { color: primaryColor, bold: !coldStart, dimColor: coldStart }, "$", summary.totalCostUsd.toFixed(6)), /* @__PURE__ */ React13.createElement(Text12, { dimColor: true }, " (in ", "$", summary.totalInputCostUsd.toFixed(6), " \xB7 out ", "$", summary.totalOutputCostUsd.toFixed(6), ")"));
+  return /* @__PURE__ */ React14.createElement(Text13, null, /* @__PURE__ */ React14.createElement(Text13, { dimColor: true }, "cost "), /* @__PURE__ */ React14.createElement(Text13, { color: primaryColor, bold: !coldStart, dimColor: coldStart }, "$", summary.totalCostUsd.toFixed(6)), /* @__PURE__ */ React14.createElement(Text13, { dimColor: true }, " (in ", "$", summary.totalInputCostUsd.toFixed(6), " \xB7 out ", "$", summary.totalOutputCostUsd.toFixed(6), ")"));
 }
 function BalanceCell({ balance }) {
   const color = balance.total < 1 ? "red" : balance.total < 5 ? "yellow" : "green";
-  return /* @__PURE__ */ React13.createElement(Text12, null, /* @__PURE__ */ React13.createElement(Text12, { dimColor: true }, "balance "), /* @__PURE__ */ React13.createElement(Text12, { color, bold: true }, balance.currency === "USD" ? "$" : "", balance.total.toFixed(2), balance.currency !== "USD" ? ` ${balance.currency}` : ""));
+  return /* @__PURE__ */ React14.createElement(Text13, null, /* @__PURE__ */ React14.createElement(Text13, { dimColor: true }, "balance "), /* @__PURE__ */ React14.createElement(Text13, { color, bold: true }, balance.currency === "USD" ? "$" : "", balance.total.toFixed(2), balance.currency !== "USD" ? ` ${balance.currency}` : ""));
 }
 function Bar({ ratio, color }) {
   const cells = 10;
   const filled = Math.max(0, Math.min(cells, Math.round(ratio * cells)));
   const bar = "\u2588".repeat(filled) + "\u2591".repeat(cells - filled);
-  return /* @__PURE__ */ React13.createElement(Text12, { color }, bar);
+  return /* @__PURE__ */ React14.createElement(Text13, { color }, bar);
 }
 function formatTokens(n) {
   if (n < 1024) return String(n);
@@ -7783,7 +8572,7 @@ var SLASH_COMMANDS = [
   {
     cmd: "compact",
     argsHint: "[tokens]",
-    summary: "shrink oversized tool results in the log (cap in tokens, default 4000)"
+    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: "sessions", summary: "list saved sessions (current marked with \u25B8)" },
@@ -7796,6 +8585,17 @@ var SLASH_COMMANDS = [
   { cmd: "apply", summary: "commit pending edit blocks to disk", contextual: "code" },
   { cmd: "discard", summary: "drop pending edit blocks without writing", contextual: "code" },
   { cmd: "undo", summary: "roll back the last applied edit batch", contextual: "code" },
+  {
+    cmd: "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"',
@@ -7813,6 +8613,26 @@ var SLASH_COMMANDS = [
     cmd: "apply-plan",
     summary: "force-approve a pending / in-text plan (fallback if picker was missed)",
     contextual: "code"
+  },
+  {
+    cmd: "mode",
+    argsHint: "[review|auto]",
+    summary: "edit-gate: review (queue for /apply) or auto (apply+undo banner). Shift+Tab cycles.",
+    contextual: "code",
+    argCompleter: ["review", "auto"]
+  },
+  { cmd: "jobs", summary: "list background jobs started by run_background", contextual: "code" },
+  {
+    cmd: "kill",
+    argsHint: "<id>",
+    summary: "stop a background job by id (SIGTERM \u2192 SIGKILL after grace)",
+    contextual: "code"
+  },
+  {
+    cmd: "logs",
+    argsHint: "<id> [lines]",
+    summary: "tail a background job's output (default last 80 lines)",
+    contextual: "code"
   }
 ];
 function suggestSlashCommands(prefix, codeMode = false) {
@@ -7881,6 +8701,8 @@ function handleSlash(cmd, args, loop, ctx = {}) {
           "  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 \u2194 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",
@@ -7929,10 +8751,16 @@ function handleSlash(cmd, args, loop, ctx = {}) {
           "  /retry                   truncate & resend your last message (fresh sample from the model)",
           "  /apply                   (code mode) commit the pending edit blocks to disk",
           "  /discard                 (code mode) drop pending edits without writing",
-          "  /undo                    (code mode) roll back the last applied edit batch",
+          "  /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]      (code mode) edit-gate: queue edits for /apply or apply instantly (Shift+Tab cycles, u undoes within 5s)",
+          "  /jobs                    (code mode) list background processes (run_background) \u2014 running and exited",
+          "  /kill <id>               (code mode) stop a background job by id (SIGTERM \u2192 SIGKILL)",
+          "  /logs <id> [lines]       (code mode) tail a background job's output (default 80 lines)",
           "  /sessions                list saved sessions (current is marked with \u25B8)",
           "  /forget                  delete the current session from disk",
           "  /new                     start fresh: drop all context + clear scrollback",
@@ -8097,7 +8925,19 @@ ${entry.text}`
           info: "/undo is only available inside `reasonix code` \u2014 chat mode doesn't apply edits."
         };
       }
-      return { info: ctx.codeUndo() };
+      return { info: ctx.codeUndo(args) };
+    }
+    case "history": {
+      if (!ctx.codeHistory) {
+        return { info: "/history is only available inside `reasonix code`." };
+      }
+      return { info: ctx.codeHistory() };
+    }
+    case "show": {
+      if (!ctx.codeShowEdit) {
+        return { info: "/show is only available inside `reasonix code`." };
+      }
+      return { info: ctx.codeShowEdit(args) };
     }
     case "apply": {
       if (!ctx.codeApply) {
@@ -8137,6 +8977,81 @@ ${entry.text}`
         info: "\u25B8 plan mode OFF \u2014 write tools are live again. Model can still propose plans autonomously for large tasks."
       };
     }
+    case "jobs": {
+      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 \u2014 use run_background to start one" };
+      }
+      const lines = ["Background jobs:"];
+      for (const r of rows) {
+        const age = ((Date.now() - r.startedAt) / 1e3).toFixed(1);
+        const state = r.running ? `running   \xB7 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 \xB7 /logs <id> [lines] to tail output");
+      return { info: lines.join("\n") };
+    }
+    case "kill": {
+      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 ?? "?"})` };
+      const jobsRef = ctx.jobs;
+      void (async () => {
+        const final = await jobsRef.stop(id);
+        if (!final) return;
+        const status = final.running ? "still alive after SIGKILL (!) \u2014 report this as a bug" : final.exitCode !== null ? `exit ${final.exitCode}` : "stopped";
+        ctx.postInfo?.(`\u25B8 job ${id} ${status}`);
+      })();
+      return {
+        info: `\u25B8 stopping job ${id} (tree kill: SIGTERM \u2192 SIGKILL after 2s grace; Windows: taskkill /T /F)`
+      };
+    }
+    case "logs": {
+      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 \xB7 pid ${out.pid ?? "?"}` : out.exitCode !== null ? `exited ${out.exitCode}` : out.spawnError ? `failed (${out.spawnError})` : "stopped";
+      const header2 = `[job ${id} \xB7 ${status}]
+$ ${out.command}`;
+      return { info: out.output ? `${header2}
+${out.output}` : header2 };
+    }
+    case "mode": {
+      if (!ctx.setEditMode) {
+        return {
+          info: "/mode is only available inside `reasonix code`."
+        };
+      }
+      const raw = (args[0] ?? "").toLowerCase();
+      const current = ctx.editMode ?? "review";
+      let target;
+      if (raw === "review") target = "review";
+      else if (raw === "auto") target = "auto";
+      else if (raw === "") {
+        target = current === "auto" ? "review" : "auto";
+      } else {
+        return { info: "usage: /mode <review|auto>   (Shift+Tab also cycles)" };
+      }
+      ctx.setEditMode(target);
+      return {
+        info: target === "auto" ? "\u25B8 edit mode: AUTO \u2014 edits apply immediately; press u within 5s to undo, or /undo later" : "\u25B8 edit mode: review \u2014 edits queue for /apply (or y) / /discard (or n)"
+      };
+    }
     case "apply-plan":
     case "applyplan": {
       if (!ctx.setPlanMode) {
@@ -8172,11 +9087,11 @@ ${entry.text}`
       const { healedCount, tokensSaved, charsSaved } = loop.compact(cap);
       if (healedCount === 0) {
         return {
-          info: `\u25B8 nothing to compact \u2014 no tool result in history exceeds ${cap.toLocaleString()} tokens.`
+          info: `\u25B8 nothing to compact \u2014 no tool result or tool-call args in history exceed ${cap.toLocaleString()} tokens.`
         };
       }
       return {
-        info: `\u25B8 compacted ${healedCount} tool result(s) to ${cap.toLocaleString()} tokens each, saved ${tokensSaved.toLocaleString()} tokens (${charsSaved.toLocaleString()} chars). Session file rewritten.`
+        info: `\u25B8 compacted ${healedCount} payload(s) to ${cap.toLocaleString()} tokens each (tool results + tool-call args), saved ${tokensSaved.toLocaleString()} tokens (${charsSaved.toLocaleString()} chars). Session file rewritten.`
       };
     }
     case "sessions": {
@@ -8282,6 +9197,7 @@ ${entry.text}`
       const mcpLine = `  mcp     ${mcpCount} server(s), ${toolCount} tool(s) in registry`;
       const pendingLine = pending > 0 ? `  edits   ${pending} pending (/apply to commit, /discard to drop)` : "";
       const planLine = ctx.planMode ? "  plan    ON \u2014 writes gated (submit_plan + approval)" : "";
+      const modeLine = ctx.editMode === "auto" ? "  mode    AUTO \u2014 edits apply immediately (u to undo within 5s \xB7 Shift+Tab to flip)" : ctx.editMode === "review" ? "  mode    review \u2014 edits queue for /apply or y  (Shift+Tab to flip)" : "";
       const lines = [
         `  model   ${loop.model}`,
         `  flags   harvest=${loop.harvestEnabled ? "on" : "off"} \xB7 branch=${branchBudget > 1 ? branchBudget : "off"} \xB7 stream=${loop.stream ? "on" : "off"} \xB7 effort=${loop.reasoningEffort}`,
@@ -8291,6 +9207,7 @@ ${entry.text}`
       ];
       if (pendingLine) lines.push(pendingLine);
       if (planLine) lines.push(planLine);
+      if (modeLine) lines.push(modeLine);
       return { info: lines.join("\n") };
     }
     case "model": {
@@ -8377,14 +9294,18 @@ ${entry.text}`
       const raw = (args[0] ?? "").toLowerCase();
       if (raw === "") {
         return {
-          info: `reasoning_effort \u2192 ${loop.reasoningEffort}  (use /effort high for cheaper/faster, /effort max for the agent-class default)`
+          info: `reasoning_effort \u2192 ${loop.reasoningEffort}  (use /effort high for cheaper/faster, /effort max for the agent-class default \xB7 persisted across relaunches)`
         };
       }
       if (raw !== "high" && raw !== "max") {
         return { info: "usage: /effort <high|max>" };
       }
       loop.configure({ reasoningEffort: raw });
-      return { info: `reasoning_effort \u2192 ${raw}` };
+      try {
+        saveReasoningEffort(raw);
+      } catch {
+      }
+      return { info: `reasoning_effort \u2192 ${raw} (persisted)` };
     }
     default:
       return { unknown: true, info: `unknown command: /${cmd}  (try /help)` };
@@ -8796,6 +9717,14 @@ function gitTail(res) {
 
 // src/cli/ui/App.tsx
 var FLUSH_INTERVAL_MS = 100;
+function isEntryFullyUndone(e) {
+  return e.snapshots.length > 0 && e.snapshots.every((s) => e.undoneFiles.has(s.path));
+}
+function entryStatus(e) {
+  if (e.undoneFiles.size === 0) return "applied";
+  if (isEntryFullyUndone(e)) return "UNDONE";
+  return "PARTIAL";
+}
 var PLAIN_UI = process.env.REASONIX_UI === "plain";
 function App({
   model,
@@ -8811,36 +9740,66 @@ function App({
   codeMode
 }) {
   const { exit } = useApp();
-  const [historical, setHistorical] = useState5([]);
-  const [streaming, setStreaming] = useState5(null);
-  const [input, setInput] = useState5("");
-  const [busy, setBusy] = useState5(false);
+  const [historical, setHistorical] = useState6([]);
+  const [streaming, setStreaming] = useState6(null);
+  const [input, setInput] = useState6("");
+  const [busy, setBusy] = useState6(false);
   const abortedThisTurn = useRef2(false);
-  const [ongoingTool, setOngoingTool] = useState5(null);
-  const [toolProgress, setToolProgress] = useState5(null);
-  const [subagentActivity, setSubagentActivity] = useState5(null);
-  const [statusLine, setStatusLine] = useState5(null);
-  const [balance, setBalance] = useState5(null);
-  const [models, setModels] = useState5(null);
-  const [latestVersion, setLatestVersion] = useState5(null);
+  const [ongoingTool, setOngoingTool] = useState6(null);
+  const [toolProgress, setToolProgress] = useState6(null);
+  const [subagentActivity, setSubagentActivity] = useState6(null);
+  const [statusLine, setStatusLine] = useState6(null);
+  const [balance, setBalance] = useState6(null);
+  const [models, setModels] = useState6(null);
+  const [latestVersion, setLatestVersion] = useState6(null);
   const updateAvailable = latestVersion && compareVersions(VERSION, latestVersion) < 0 ? latestVersion : null;
-  const [hookList, setHookList] = useState5(
+  const [hookList, setHookList] = useState6(
     () => loadHooks({ projectRoot: codeMode?.rootDir })
   );
   const hookCwd = codeMode?.rootDir ?? process.cwd();
-  const lastEditSnapshots = useRef2(null);
+  const editHistory = useRef2([]);
+  const nextHistoryId = useRef2(1);
+  const currentTurnEntry = useRef2(null);
   const pendingEdits = useRef2([]);
-  const [pendingShell, setPendingShell] = useState5(null);
-  const [pendingPlan, setPendingPlan] = useState5(null);
-  const [stagedInput, setStagedInput] = useState5(null);
-  const [planMode, setPlanMode] = useState5(false);
-  const [queuedSubmit, setQueuedSubmit] = useState5(null);
+  const [pendingCount, setPendingCount] = useState6(0);
+  const syncPendingCount = useCallback(() => {
+    setPendingCount(pendingEdits.current.length);
+  }, []);
+  const [editMode, setEditMode] = useState6(() => codeMode ? loadEditMode() : "review");
+  const editModeRef = useRef2(editMode);
+  useEffect2(() => {
+    editModeRef.current = editMode;
+    if (codeMode) saveEditMode(editMode);
+  }, [editMode, codeMode]);
+  const [undoBanner, setUndoBanner] = useState6(null);
+  const undoTimeoutRef = useRef2(null);
+  const [pendingEditReview, setPendingEditReview] = useState6(null);
+  const editReviewResolveRef = useRef2(null);
+  const turnEditPolicyRef = useRef2("ask");
+  const [modeFlash, setModeFlash] = useState6(false);
+  const modeFlashTimeoutRef = useRef2(null);
+  const prevEditModeRef = useRef2(editMode);
+  useEffect2(() => {
+    if (prevEditModeRef.current === editMode) return;
+    prevEditModeRef.current = editMode;
+    setModeFlash(true);
+    if (modeFlashTimeoutRef.current) clearTimeout(modeFlashTimeoutRef.current);
+    modeFlashTimeoutRef.current = setTimeout(() => {
+      setModeFlash(false);
+      modeFlashTimeoutRef.current = null;
+    }, 1200);
+  }, [editMode]);
+  const [pendingShell, setPendingShell] = useState6(null);
+  const [pendingPlan, setPendingPlan] = useState6(null);
+  const [stagedInput, setStagedInput] = useState6(null);
+  const [planMode, setPlanMode] = useState6(false);
+  const [queuedSubmit, setQueuedSubmit] = useState6(null);
   const promptHistory = useRef2([]);
   const historyCursor = useRef2(-1);
   const assistantIterCounter = useRef2(0);
   const toolHistoryRef = useRef2([]);
-  const [slashSelected, setSlashSelected] = useState5(0);
-  const [summary, setSummary] = useState5({
+  const [slashSelected, setSlashSelected] = useState6(0);
+  const [summary, setSummary] = useState6({
     turns: 0,
     totalCostUsd: 0,
     totalInputCostUsd: 0,
@@ -8864,7 +9823,7 @@ function App({
       transcriptRef.current?.end();
     };
   }, []);
-  const slashMatches = useMemo(() => {
+  const slashMatches = useMemo2(() => {
     if (!input.startsWith("/") || input.includes(" ")) return null;
     return suggestSlashCommands(input.slice(1), !!codeMode);
   }, [input, codeMode]);
@@ -8875,8 +9834,8 @@ function App({
       return prev;
     });
   }, [slashMatches]);
-  const [atSelected, setAtSelected] = useState5(0);
-  const atFiles = useMemo(() => {
+  const [atSelected, setAtSelected] = useState6(0);
+  const atFiles = useMemo2(() => {
     if (!codeMode?.rootDir) return [];
     try {
       return listFilesWithStatsSync(codeMode.rootDir, { maxResults: 500 });
@@ -8892,12 +9851,12 @@ function App({
     list.unshift(p);
     if (list.length > 20) list.length = 20;
   }, []);
-  const atPicker = useMemo(() => {
+  const atPicker = useMemo2(() => {
     if (!codeMode?.rootDir) return null;
     if (slashMatches !== null) return null;
     return detectAtPicker(input);
   }, [codeMode?.rootDir, input, slashMatches]);
-  const atMatches = useMemo(() => {
+  const atMatches = useMemo2(() => {
     if (!atPicker) return null;
     return rankPickerCandidates(atFiles, atPicker.query, {
       limit: 40,
@@ -8919,13 +9878,13 @@ function App({
     },
     [atPicker, input]
   );
-  const [slashArgSelected, setSlashArgSelected] = useState5(0);
-  const slashArgContext = useMemo(() => {
+  const [slashArgSelected, setSlashArgSelected] = useState6(0);
+  const slashArgContext = useMemo2(() => {
     if (!input.startsWith("/")) return null;
     if (slashMatches !== null) return null;
     return detectSlashArgContext(input, !!codeMode);
   }, [input, slashMatches, codeMode]);
-  const slashArgMatches = useMemo(() => {
+  const slashArgMatches = useMemo2(() => {
     if (!slashArgContext || slashArgContext.kind !== "picker") return null;
     const completer = slashArgContext.spec.argCompleter;
     const partial = slashArgContext.partial;
@@ -8982,7 +9941,7 @@ function App({
   );
   const loopRef = useRef2(null);
   const subagentSinkRef = useRef2({ current: null });
-  const loop = useMemo(() => {
+  const loop = useMemo2(() => {
     if (loopRef.current) return loopRef.current;
     const client = new DeepSeekClient();
     if (tools && !tools.has("run_skill")) {
@@ -9021,7 +9980,11 @@ function App({
       branch,
       session,
       hooks: hookList,
-      hookCwd
+      hookCwd,
+      // Restore the user's last-chosen effort cap. Without this a
+      // `/effort high` silently reverted to `max` on relaunch — the
+      // loop's constructor default wins over persisted state.
+      reasoningEffort: loadReasoningEffort()
     });
     loopRef.current = l;
     return l;
@@ -9161,6 +10124,7 @@ function App({
       const restored = loadPendingEdits(session);
       if (restored && restored.length > 0) {
         pendingEdits.current = restored;
+        syncPendingCount();
         setHistorical((prev) => [
           ...prev,
           {
@@ -9171,14 +10135,54 @@ function App({
         ]);
       }
     }
-  }, [session, loop, codeMode]);
-  useInput4((_input, key) => {
+    if (codeMode && !editModeHintShown()) {
+      setHistorical((prev) => [
+        ...prev,
+        {
+          id: `sys-edittip-${Date.now()}`,
+          role: "info",
+          text: "\u25B8 TIP: edit-gate keybindings\n    y / n       accept or drop pending edits\n    Shift+Tab   switch review \u2194 AUTO (persisted; AUTO applies instantly)\n    u           undo the last auto-applied batch (within the 5s banner)\n  Current mode is shown in the bottom status bar. Run /keys anytime for the full list.\n  (This tip shows once \u2014 suppressed after.)"
+        }
+      ]);
+      markEditModeHintShown();
+    }
+  }, [session, loop, codeMode, syncPendingCount]);
+  useInput5((chKey, key) => {
     if (key.escape && busy) {
       if (abortedThisTurn.current) return;
       abortedThisTurn.current = true;
+      const resolve8 = editReviewResolveRef.current;
+      if (resolve8) {
+        editReviewResolveRef.current = null;
+        setPendingEditReview(null);
+        resolve8("reject");
+      }
       loop.abort();
       return;
     }
+    if (codeMode && key.shift && key.tab && !pendingShell && !pendingPlan && !stagedInput && !pendingEditReview) {
+      setEditMode((m) => {
+        const next = m === "auto" ? "review" : "auto";
+        setHistorical((prev) => [
+          ...prev,
+          {
+            id: `mode-${Date.now()}`,
+            role: "info",
+            text: next === "auto" ? "\u25B8 edit mode: AUTO \u2014 edits apply immediately; press u within 5s to undo" : "\u25B8 edit mode: review \u2014 edits queue for /apply (or y) / /discard (or n)"
+          }
+        ]);
+        return next;
+      });
+      return;
+    }
+    if (codeMode && input.length === 0 && (chKey === "u" || chKey === "U") && !pendingShell && !pendingPlan && !stagedInput && !pendingEditReview && // Fire when EITHER the banner is up OR there's any non-undone
+    // history entry — the keybind is useful long after the 5-second
+    // banner expires, which users rightly want.
+    (undoBanner || editHistory.current.some((e) => !isEntryFullyUndone(e)))) {
+      const out = codeUndo([]);
+      setHistorical((prev) => [...prev, { id: `undo-${Date.now()}`, role: "info", text: out }]);
+      return;
+    }
     if (busy) return;
     if (pendingShell) return;
     if (atMatches && atMatches.length > 0) {
@@ -9244,16 +10248,269 @@ function App({
       }
     }
   });
-  const codeUndo = useCallback(() => {
+  const recordEdit = useCallback(
+    (source, blocks, results, snaps) => {
+      if (snaps.length === 0) return;
+      let entry = currentTurnEntry.current;
+      if (!entry) {
+        entry = {
+          id: nextHistoryId.current++,
+          at: Date.now(),
+          source,
+          blocks: [],
+          results: [],
+          snapshots: [],
+          undoneFiles: /* @__PURE__ */ new Set()
+        };
+        currentTurnEntry.current = entry;
+        editHistory.current.push(entry);
+      }
+      entry.blocks.push(...blocks);
+      entry.results.push(...results);
+      const seen = new Set(entry.snapshots.map((s) => s.path));
+      for (const s of snaps) {
+        if (!seen.has(s.path)) entry.snapshots.push(s);
+      }
+    },
+    []
+  );
+  const armUndoBanner = useCallback((results) => {
+    setUndoBanner({ results, expiresAt: Date.now() + 5e3 });
+    if (undoTimeoutRef.current) clearTimeout(undoTimeoutRef.current);
+    undoTimeoutRef.current = setTimeout(() => {
+      setUndoBanner(null);
+      undoTimeoutRef.current = null;
+    }, 5e3);
+  }, []);
+  const codeUndo = useCallback(
+    (args = []) => {
+      if (!codeMode) return "not in code mode";
+      const root = codeMode.rootDir;
+      const revert = (entry2, paths) => {
+        const subset = entry2.snapshots.filter((s) => paths.includes(s.path));
+        if (subset.length === 0) {
+          return `batch #${entry2.id}: nothing to undo (already restored or path not in batch)`;
+        }
+        const results = restoreSnapshots(subset, root);
+        for (const s of subset) entry2.undoneFiles.add(s.path);
+        if (currentTurnEntry.current === entry2 && isEntryFullyUndone(entry2)) {
+          currentTurnEntry.current = null;
+        }
+        if (undoTimeoutRef.current) {
+          clearTimeout(undoTimeoutRef.current);
+          undoTimeoutRef.current = null;
+        }
+        setUndoBanner(null);
+        const when = new Date(entry2.at).toISOString().replace("T", " ").slice(11, 19);
+        const scope = subset.length === 1 ? subset[0].path : `${subset.length} file(s)`;
+        const header2 = `\u25B8 undo: reverted ${scope} from batch #${entry2.id} (${when})`;
+        return [header2, ...formatUndoRows(results)].join("\n");
+      };
+      const idArg = args[0];
+      const pathArg = args[1];
+      if (!idArg) {
+        for (let i = editHistory.current.length - 1; i >= 0; i--) {
+          const e = editHistory.current[i];
+          if (isEntryFullyUndone(e)) continue;
+          const remaining = e.snapshots.map((s) => s.path).filter((p) => !e.undoneFiles.has(p));
+          return revert(e, remaining);
+        }
+        return "nothing to undo \u2014 every batch in the session history is already undone";
+      }
+      const id = Number.parseInt(idArg, 10);
+      if (!Number.isFinite(id)) {
+        return "usage: /undo [id] [path]   (omit id for newest; id from /history; path from /show <id>)";
+      }
+      const entry = editHistory.current.find((e) => e.id === id);
+      if (!entry) return `no edit #${id} \u2014 run /history to see valid ids`;
+      if (!pathArg) {
+        const remaining = entry.snapshots.map((s) => s.path).filter((p) => !entry.undoneFiles.has(p));
+        if (remaining.length === 0) return `batch #${id} is already fully undone`;
+        return revert(entry, remaining);
+      }
+      const snap = entry.snapshots.find((s) => s.path === pathArg);
+      if (!snap) {
+        const files = [...new Set(entry.blocks.map((b) => b.path))];
+        return `batch #${id} doesn't include "${pathArg}" \u2014 files in this batch: ${files.join(", ")}`;
+      }
+      if (entry.undoneFiles.has(pathArg)) {
+        return `${pathArg} in batch #${id} is already undone`;
+      }
+      return revert(entry, [pathArg]);
+    },
+    [codeMode]
+  );
+  const codeHistory = useCallback(() => {
     if (!codeMode) return "not in code mode";
-    const snaps = lastEditSnapshots.current;
-    if (!snaps || snaps.length === 0) {
-      return "nothing to undo \u2014 no recent edit batch to restore";
+    const entries = editHistory.current;
+    if (entries.length === 0) return "no edits recorded this session yet";
+    const lines = ["Edit history (oldest first):"];
+    for (const e of entries) {
+      const when = new Date(e.at).toISOString().replace("T", " ").slice(11, 19);
+      const files = new Set(e.blocks.map((b) => b.path));
+      const fileList = [...files].join(", ");
+      const fileSummary = fileList.length > 60 ? `${fileList.slice(0, 60)}\u2026` : fileList;
+      const status = entryStatus(e);
+      const statusText = status === "applied" ? "applied" : status === "PARTIAL" ? "PARTIAL" : "UNDONE ";
+      lines.push(
+        `  #${String(e.id).padStart(3)}  ${when}  ${statusText}  ${e.source.padEnd(12)} ${files.size} file \xB7 ${e.blocks.length} block   ${fileSummary}`
+      );
     }
-    const results = restoreSnapshots(snaps, codeMode.rootDir);
-    lastEditSnapshots.current = null;
-    return formatUndoResults(results);
+    lines.push("");
+    lines.push(
+      "/show <id>            \u2192 per-file summary    \xB7    /show <id> <path>  \u2192 full diff of one file"
+    );
+    lines.push(
+      "/undo                 \u2192 newest non-undone   \xB7    /undo <id> [path]  \u2192 target a specific batch or file"
+    );
+    return lines.join("\n");
   }, [codeMode]);
+  const codeShowEdit = useCallback(
+    (args = []) => {
+      if (!codeMode) return "not in code mode";
+      const entries = editHistory.current;
+      if (entries.length === 0) return "no edits recorded this session \u2014 /history is empty";
+      const idArg = args[0];
+      const pathArg = args[1];
+      let entry;
+      if (!idArg) {
+        entry = [...entries].reverse().find((e) => !isEntryFullyUndone(e)) ?? entries[entries.length - 1];
+      } else {
+        const id = Number.parseInt(idArg, 10);
+        if (!Number.isFinite(id)) {
+          return "usage: /show [id] [path]   (omit id for newest; path from the per-file summary)";
+        }
+        entry = entries.find((e) => e.id === id);
+        if (!entry) return `no edit #${id} \u2014 run /history to see valid ids`;
+      }
+      if (!entry) return "unexpected: history lookup failed";
+      if (pathArg) {
+        const fileBlocks = entry.blocks.filter((b) => b.path === pathArg);
+        if (fileBlocks.length === 0) {
+          const files2 = [...new Set(entry.blocks.map((b) => b.path))];
+          return `batch #${entry.id} doesn't include "${pathArg}" \u2014 files in this batch: ${files2.join(", ")}`;
+        }
+        const when2 = new Date(entry.at).toISOString().replace("T", " ").slice(11, 19);
+        const state = entry.undoneFiles.has(pathArg) ? "UNDONE" : "applied";
+        const header3 = `\u25B8 edit #${entry.id} \xB7 ${when2} \xB7 ${pathArg} \xB7 ${state} \xB7 ${fileBlocks.length} block(s)`;
+        const diff = formatAllBlockDiffs(fileBlocks, { maxLines: 60, contextLines: 2 });
+        const footer = entry.undoneFiles.has(pathArg) ? "(already reverted \u2014 /history shows the batch-level status)" : `/undo ${entry.id} ${pathArg}  \u2192 revert just this file`;
+        return [header3, ...diff, "", footer].join("\n");
+      }
+      const when = new Date(entry.at).toISOString().replace("T", " ").slice(11, 19);
+      const files = [...new Set(entry.blocks.map((b) => b.path))];
+      const status = entryStatus(entry);
+      const header2 = `\u25B8 edit #${entry.id} \xB7 ${when} \xB7 ${entry.source} \xB7 ${status} \xB7 ${files.length} file(s)`;
+      const countLines3 = (s) => s.length === 0 ? 0 : (s.match(/\n/g)?.length ?? 0) + 1;
+      const fileLines = files.map((path) => {
+        const fileBlocks = entry.blocks.filter((b) => b.path === path);
+        let removed = 0;
+        let added = 0;
+        for (const b of fileBlocks) {
+          removed += countLines3(b.search);
+          added += countLines3(b.replace);
+        }
+        const state = entry.undoneFiles.has(path) ? "UNDONE" : "applied";
+        return `  ${state.padEnd(7)}  -${String(removed).padStart(3)}/+${String(added).padStart(3)}   ${path}  (${fileBlocks.length} block${fileBlocks.length === 1 ? "" : "s"})`;
+      });
+      return [
+        header2,
+        ...fileLines,
+        "",
+        `/show ${entry.id} <path>   \u2192 full diff of one file`,
+        `/undo ${entry.id} <path>   \u2192 revert just that file   \xB7   /undo ${entry.id} \u2192 revert whole batch`
+      ].join("\n");
+    },
+    [codeMode]
+  );
+  useEffect2(() => {
+    if (!tools || !codeMode) return;
+    tools.setToolInterceptor(async (name, args) => {
+      if (name !== "edit_file" && name !== "write_file") return null;
+      const rawPath = typeof args.path === "string" ? args.path : "";
+      if (!rawPath) return null;
+      let relPath = rawPath;
+      while (relPath.startsWith("/") || relPath.startsWith("\\")) {
+        relPath = relPath.slice(1);
+      }
+      if (!relPath) return null;
+      let block;
+      if (name === "edit_file") {
+        const search = typeof args.search === "string" ? args.search : "";
+        const replace = typeof args.replace === "string" ? args.replace : "";
+        if (!search) return null;
+        block = { path: relPath, search, replace, offset: 0 };
+      } else {
+        const content = typeof args.content === "string" ? args.content : "";
+        block = toWholeFileEditBlock(relPath, content, codeMode.rootDir);
+      }
+      const applyNow = () => {
+        const snaps = snapshotBeforeEdits([block], codeMode.rootDir);
+        const results = applyEditBlocks([block], codeMode.rootDir);
+        const good = results.some((r) => r.status === "applied" || r.status === "created");
+        if (good) {
+          recordEdit("auto", [block], results, snaps);
+          armUndoBanner(results);
+        }
+        setHistorical((prev) => [
+          ...prev,
+          {
+            id: `ae-${Date.now()}-${Math.random()}`,
+            role: "info",
+            text: formatEditResults(results)
+          }
+        ]);
+        return formatEditResults(results);
+      };
+      if (editModeRef.current === "auto") return applyNow();
+      if (turnEditPolicyRef.current === "apply-all") return applyNow();
+      const choice = await new Promise((resolveChoice) => {
+        editReviewResolveRef.current = resolveChoice;
+        setPendingEditReview(block);
+      });
+      editReviewResolveRef.current = null;
+      setPendingEditReview(null);
+      if (choice === "reject") {
+        setHistorical((prev) => [
+          ...prev,
+          {
+            id: `er-${Date.now()}-${Math.random()}`,
+            role: "info",
+            text: `\u25B8 rejected edit to ${block.path}`
+          }
+        ]);
+        return `User rejected this edit to ${block.path}. Don't retry the same SEARCH/REPLACE \u2014 either try a different approach or ask the user what they want instead.`;
+      }
+      if (choice === "apply-rest-of-turn") {
+        turnEditPolicyRef.current = "apply-all";
+        setHistorical((prev) => [
+          ...prev,
+          {
+            id: `er-${Date.now()}-${Math.random()}`,
+            role: "info",
+            text: "\u25B8 auto-approving remaining edits for this turn"
+          }
+        ]);
+        return applyNow();
+      }
+      if (choice === "flip-to-auto") {
+        setEditMode("auto");
+        setHistorical((prev) => [
+          ...prev,
+          {
+            id: `er-${Date.now()}-${Math.random()}`,
+            role: "info",
+            text: "\u25B8 flipped to AUTO mode for the rest of the session (persisted)"
+          }
+        ]);
+        return applyNow();
+      }
+      return applyNow();
+    });
+    return () => {
+      tools.setToolInterceptor(null);
+    };
+  }, [tools, codeMode, session, recordEdit, armUndoBanner, syncPendingCount, setEditMode]);
   const codeApply = useCallback(() => {
     if (!codeMode) return "not in code mode";
     const blocks = pendingEdits.current;
@@ -9263,18 +10520,20 @@ function App({
     const snaps = snapshotBeforeEdits(blocks, codeMode.rootDir);
     const results = applyEditBlocks(blocks, codeMode.rootDir);
     const anyApplied = results.some((r) => r.status === "applied" || r.status === "created");
-    if (anyApplied) lastEditSnapshots.current = snaps;
+    if (anyApplied) recordEdit("review-apply", blocks, results, snaps);
     pendingEdits.current = [];
     clearPendingEdits(session ?? null);
+    syncPendingCount();
     return formatEditResults(results);
-  }, [codeMode, session]);
+  }, [codeMode, session, syncPendingCount, recordEdit]);
   const codeDiscard = useCallback(() => {
     const count = pendingEdits.current.length;
     if (count === 0) return "nothing pending to discard.";
     pendingEdits.current = [];
     clearPendingEdits(session ?? null);
+    syncPendingCount();
     return `\u25B8 discarded ${count} pending edit block(s). Nothing was written to disk.`;
-  }, [session]);
+  }, [session, syncPendingCount]);
   const prefixHash = loop.prefix.fingerprint;
   const writeTranscript = useCallback(
     (ev) => {
@@ -9392,6 +10651,8 @@ function App({
           codeUndo: codeMode ? codeUndo : void 0,
           codeApply: codeMode ? codeApply : void 0,
           codeDiscard: codeMode ? codeDiscard : void 0,
+          codeHistory: codeMode ? codeHistory : void 0,
+          codeShowEdit: codeMode ? codeShowEdit : void 0,
           codeRoot: codeMode?.rootDir,
           pendingEditCount: codeMode ? pendingEdits.current.length : void 0,
           toolHistory: () => toolHistoryRef.current,
@@ -9399,6 +10660,13 @@ function App({
           planMode,
           setPlanMode: codeMode ? togglePlanMode : void 0,
           clearPendingPlan: codeMode ? clearPendingPlan : void 0,
+          editMode: codeMode ? editMode : void 0,
+          setEditMode: codeMode ? setEditMode : void 0,
+          jobs: codeMode?.jobs,
+          postInfo: (text2) => setHistorical((prev) => [
+            ...prev,
+            { id: `sys-late-${Date.now()}-${Math.random()}`, role: "info", text: text2 }
+          ]),
           reloadHooks: () => {
             const fresh = loadHooks({ projectRoot: codeMode?.rootDir });
             setHookList(fresh);
@@ -9435,6 +10703,7 @@ function App({
           if (codeMode) {
             pendingEdits.current = [];
             clearPendingEdits(session ?? null);
+            syncPendingCount();
           }
           return;
         }
@@ -9443,6 +10712,7 @@ function App({
           if (codeMode) {
             pendingEdits.current = [];
             clearPendingEdits(session ?? null);
+            syncPendingCount();
           }
           return;
         }
@@ -9505,6 +10775,10 @@ function App({
       setStreaming({ id: assistantId, role: "assistant", text: "", streaming: true });
       setBusy(true);
       abortedThisTurn.current = false;
+      if (codeMode) {
+        currentTurnEntry.current = null;
+      }
+      turnEditPolicyRef.current = "ask";
       const flush = () => {
         if (!contentBuf.current && !reasoningBuf.current && !toolCallBuildBuf.current) return;
         streamRef.text += contentBuf.current;
@@ -9618,16 +10892,37 @@ function App({
             if (codeMode && finalText && !ev.forcedSummary) {
               const blocks = parseEditBlocks(finalText);
               if (blocks.length > 0) {
-                pendingEdits.current = blocks;
-                savePendingEdits(session ?? null, blocks);
-                setHistorical((prev) => [
-                  ...prev,
-                  {
-                    id: `pending-${Date.now()}`,
-                    role: "info",
-                    text: formatPendingPreview(blocks)
+                if (editModeRef.current === "auto") {
+                  const snaps = snapshotBeforeEdits(blocks, codeMode.rootDir);
+                  const results = applyEditBlocks(blocks, codeMode.rootDir);
+                  const good = results.some(
+                    (r) => r.status === "applied" || r.status === "created"
+                  );
+                  if (good) {
+                    recordEdit("auto-text", blocks, results, snaps);
+                    armUndoBanner(results);
                   }
-                ]);
+                  setHistorical((prev) => [
+                    ...prev,
+                    {
+                      id: `applied-${Date.now()}`,
+                      role: "info",
+                      text: formatEditResults(results)
+                    }
+                  ]);
+                } else {
+                  pendingEdits.current = [...pendingEdits.current, ...blocks];
+                  savePendingEdits(session ?? null, pendingEdits.current);
+                  syncPendingCount();
+                  setHistorical((prev) => [
+                    ...prev,
+                    {
+                      id: `pending-${Date.now()}`,
+                      role: "info",
+                      text: formatPendingPreview(pendingEdits.current)
+                    }
+                  ]);
+                }
               }
             }
           } else if (ev.role === "tool_start") {
@@ -9663,11 +10958,14 @@ function App({
                 toolName: ev.toolName
               }
             ]);
-            if (codeMode && ev.toolName === "run_command" && ev.content.includes('"NeedsConfirmationError:') && ev.toolArgs) {
+            if (codeMode && (ev.toolName === "run_command" || ev.toolName === "run_background") && ev.content.includes('"NeedsConfirmationError:') && ev.toolArgs) {
               try {
                 const parsed = JSON.parse(ev.toolArgs);
                 if (typeof parsed.command === "string" && parsed.command.trim()) {
-                  setPendingShell(parsed.command.trim());
+                  setPendingShell({
+                    command: parsed.command.trim(),
+                    kind: ev.toolName
+                  });
                 }
               } catch {
               }
@@ -9738,7 +11036,9 @@ function App({
       clearPendingPlan,
       codeApply,
       codeDiscard,
+      codeHistory,
       codeMode,
+      codeShowEdit,
       codeUndo,
       exit,
       hookCwd,
@@ -9761,13 +11061,18 @@ function App({
       slashArgSelected,
       pickSlashArg,
       togglePlanMode,
-      writeTranscript
+      writeTranscript,
+      recordEdit,
+      armUndoBanner,
+      editMode,
+      syncPendingCount
     ]
   );
   const handleShellConfirm = useCallback(
     async (choice) => {
-      const cmd = pendingShell;
-      if (!cmd || !codeMode) return;
+      const pending = pendingShell;
+      if (!pending || !codeMode) return;
+      const { command: cmd, kind } = pending;
       setPendingShell(null);
       let synthetic;
       if (choice === "deny") {
@@ -9791,23 +11096,65 @@ function App({
         }
         setHistorical((prev) => [
           ...prev,
-          { id: `sh-run-${Date.now()}`, role: "info", text: `\u25B8 running: ${cmd}` }
+          {
+            id: `sh-run-${Date.now()}`,
+            role: "info",
+            text: kind === "run_background" ? `\u25B8 starting (background): ${cmd}` : `\u25B8 running: ${cmd}`
+          }
         ]);
-        let body;
-        try {
-          const res = await runCommand(cmd, { cwd: codeMode.rootDir });
-          body = formatCommandResult(cmd, res);
-        } catch (err) {
-          body = `$ ${cmd}
+        if (kind === "run_background" && codeMode.jobs) {
+          let startedOk = false;
+          let jobId = null;
+          let preview = "";
+          try {
+            const res = await codeMode.jobs.start(cmd, { cwd: codeMode.rootDir });
+            startedOk = true;
+            jobId = res.jobId;
+            preview = res.preview;
+            const header2 = res.stillRunning ? `[job ${res.jobId} started \xB7 pid ${res.pid ?? "?"} \xB7 ${res.readyMatched ? "READY signal matched" : "running"}]` : res.exitCode !== null ? `[job ${res.jobId} exited during startup \xB7 exit ${res.exitCode}]` : `[job ${res.jobId} failed to start]`;
+            const body = preview ? `${header2}
+${preview}` : header2;
+            setHistorical((prev) => [
+              ...prev,
+              { id: `sh-out-${Date.now()}`, role: "info", text: body }
+            ]);
+            synthetic = `I approved the background spawn. ${header2}
+
+Startup preview:
+
+${preview || "(no output yet)"}
+
+The process is still running \u2014 use job_output to read newer logs, stop_job to halt it.`;
+          } catch (err) {
+            const msg = `$ ${cmd}
+[failed to start] ${err.message}`;
+            setHistorical((prev) => [
+              ...prev,
+              { id: `sh-out-${Date.now()}`, role: "info", text: msg }
+            ]);
+            synthetic = `I approved the background spawn but it failed to start:
+
+${msg}`;
+          }
+          void startedOk;
+          void jobId;
+        } else {
+          let body;
+          try {
+            const res = await runCommand(cmd, { cwd: codeMode.rootDir });
+            body = formatCommandResult(cmd, res);
+          } catch (err) {
+            body = `$ ${cmd}
 [failed to spawn] ${err.message}`;
-        }
-        setHistorical((prev) => [
-          ...prev,
-          { id: `sh-out-${Date.now()}`, role: "info", text: body }
-        ]);
-        synthetic = `I ran the command you requested. Output:
+          }
+          setHistorical((prev) => [
+            ...prev,
+            { id: `sh-out-${Date.now()}`, role: "info", text: body }
+          ]);
+          synthetic = `I ran the command you requested. Output:
 
 ${body}`;
+        }
       }
       if (busy) {
         loop.abort();
@@ -9918,7 +11265,7 @@ Stay in plan mode \u2014 address the feedback (explore more if needed), then sub
     if (stagedInput?.plan) setPendingPlan(stagedInput.plan);
     setStagedInput(null);
   }, [stagedInput]);
-  return /* @__PURE__ */ React14.createElement(TickerProvider, { disabled: PLAIN_UI || !!pendingPlan || !!pendingShell }, /* @__PURE__ */ React14.createElement(Box13, { flexDirection: "column" }, /* @__PURE__ */ React14.createElement(
+  return /* @__PURE__ */ React15.createElement(TickerProvider, { disabled: PLAIN_UI || !!pendingPlan || !!pendingShell || !!pendingEditReview }, /* @__PURE__ */ React15.createElement(Box14, { flexDirection: "column" }, /* @__PURE__ */ React15.createElement(
     StatsPanel,
     {
       summary,
@@ -9928,32 +11275,56 @@ Stay in plan mode \u2014 address the feedback (explore more if needed), then sub
       branchBudget: loop.branchOptions.budget,
       reasoningEffort: loop.reasoningEffort,
       planMode,
+      editMode: codeMode ? editMode : void 0,
       balance,
       busy,
       updateAvailable
     }
-  ), /* @__PURE__ */ React14.createElement(Static, { items: historical }, (item) => /* @__PURE__ */ React14.createElement(EventRow, { key: item.id, event: item, projectRoot: hookCwd })), !PLAIN_UI && !pendingShell && !pendingPlan && !stagedInput && streaming ? /* @__PURE__ */ React14.createElement(Box13, { marginY: 1 }, /* @__PURE__ */ React14.createElement(EventRow, { event: streaming, projectRoot: hookCwd })) : null, !PLAIN_UI && !pendingShell && !pendingPlan && !stagedInput && ongoingTool ? /* @__PURE__ */ React14.createElement(OngoingToolRow, { tool: ongoingTool, progress: toolProgress }) : null, !PLAIN_UI && !pendingShell && !pendingPlan && !stagedInput && subagentActivity ? /* @__PURE__ */ React14.createElement(SubagentRow, { activity: subagentActivity }) : null, !PLAIN_UI && !pendingShell && !pendingPlan && !stagedInput && !ongoingTool && statusLine ? /* @__PURE__ */ React14.createElement(StatusRow, { text: statusLine }) : null, !PLAIN_UI && !pendingShell && !pendingPlan && !stagedInput && busy && !streaming && !ongoingTool && !statusLine ? /* @__PURE__ */ React14.createElement(StatusRow, { text: "processing\u2026" }) : null, stagedInput ? /* @__PURE__ */ React14.createElement(
+  ), /* @__PURE__ */ React15.createElement(Static, { items: historical }, (item) => /* @__PURE__ */ React15.createElement(EventRow, { key: item.id, event: item, projectRoot: hookCwd })), !PLAIN_UI && !pendingShell && !pendingPlan && !stagedInput && !pendingEditReview && streaming ? /* @__PURE__ */ React15.createElement(Box14, { marginY: 1 }, /* @__PURE__ */ React15.createElement(EventRow, { event: streaming, projectRoot: hookCwd })) : null, !PLAIN_UI && !pendingShell && !pendingPlan && !stagedInput && !pendingEditReview && ongoingTool ? /* @__PURE__ */ React15.createElement(OngoingToolRow, { tool: ongoingTool, progress: toolProgress }) : null, !PLAIN_UI && !pendingShell && !pendingPlan && !stagedInput && !pendingEditReview && subagentActivity ? /* @__PURE__ */ React15.createElement(SubagentRow, { activity: subagentActivity }) : null, !PLAIN_UI && !pendingShell && !pendingPlan && !stagedInput && !pendingEditReview && !ongoingTool && statusLine ? /* @__PURE__ */ React15.createElement(StatusRow, { text: statusLine }) : null, !PLAIN_UI && undoBanner && !pendingShell && !pendingPlan && !stagedInput && !pendingEditReview ? /* @__PURE__ */ React15.createElement(UndoBanner, { banner: undoBanner }) : null, !PLAIN_UI && !pendingShell && !pendingPlan && !stagedInput && !pendingEditReview && busy && !streaming && !ongoingTool && !statusLine ? /* @__PURE__ */ React15.createElement(StatusRow, { text: "processing\u2026" }) : null, stagedInput ? /* @__PURE__ */ React15.createElement(
     PlanRefineInput,
     {
       mode: stagedInput.mode,
       onSubmit: handleStagedInputSubmit,
       onCancel: handleStagedInputCancel
     }
-  ) : pendingPlan ? /* @__PURE__ */ React14.createElement(
+  ) : pendingPlan ? /* @__PURE__ */ React15.createElement(
     PlanConfirm,
     {
       plan: pendingPlan,
       onChoose: stableHandlePlanConfirm,
       projectRoot: hookCwd
     }
-  ) : pendingShell ? /* @__PURE__ */ React14.createElement(
+  ) : pendingShell ? /* @__PURE__ */ React15.createElement(
     ShellConfirm,
     {
-      command: pendingShell,
-      allowPrefix: derivePrefix(pendingShell),
+      command: pendingShell.command,
+      allowPrefix: derivePrefix(pendingShell.command),
+      kind: pendingShell.kind,
       onChoose: handleShellConfirm
     }
-  ) : /* @__PURE__ */ React14.createElement(React14.Fragment, null, /* @__PURE__ */ React14.createElement(
+  ) : pendingEditReview ? /* @__PURE__ */ React15.createElement(
+    EditConfirm,
+    {
+      block: pendingEditReview,
+      onChoose: (choice) => {
+        const resolve8 = editReviewResolveRef.current;
+        if (resolve8) {
+          editReviewResolveRef.current = null;
+          resolve8(choice);
+        }
+      }
+    }
+  ) : /* @__PURE__ */ React15.createElement(React15.Fragment, null, codeMode ? /* @__PURE__ */ React15.createElement(
+    ModeStatusBar,
+    {
+      editMode,
+      pendingCount,
+      flash: modeFlash,
+      planMode,
+      undoArmed: !!undoBanner || editHistory.current.some((e) => !isEntryFullyUndone(e)),
+      jobs: codeMode.jobs
+    }
+  ) : null, /* @__PURE__ */ React15.createElement(
     PromptInput,
     {
       value: input,
@@ -9961,14 +11332,14 @@ Stay in plan mode \u2014 address the feedback (explore more if needed), then sub
       onSubmit: handleSubmit,
       disabled: busy
     }
-  ), /* @__PURE__ */ React14.createElement(SlashSuggestions, { matches: slashMatches, selectedIndex: slashSelected }), /* @__PURE__ */ React14.createElement(
+  ), /* @__PURE__ */ React15.createElement(SlashSuggestions, { matches: slashMatches, selectedIndex: slashSelected }), /* @__PURE__ */ React15.createElement(
     AtMentionSuggestions,
     {
       matches: atMatches,
       selectedIndex: atSelected,
       query: atPicker?.query ?? ""
     }
-  ), slashArgContext ? /* @__PURE__ */ React14.createElement(
+  ), slashArgContext ? /* @__PURE__ */ React15.createElement(
     SlashArgPicker,
     {
       matches: slashArgMatches,
@@ -9983,14 +11354,44 @@ var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834"
 function StatusRow({ text }) {
   const tick = useTick();
   const elapsed = useElapsedSeconds();
-  return /* @__PURE__ */ React14.createElement(Box13, { marginY: 1 }, /* @__PURE__ */ React14.createElement(Text13, { color: "magenta" }, SPINNER_FRAMES[tick % SPINNER_FRAMES.length]), /* @__PURE__ */ React14.createElement(Text13, { color: "magenta" }, ` ${text}`), /* @__PURE__ */ React14.createElement(Text13, { dimColor: true }, ` ${elapsed}s`));
+  return /* @__PURE__ */ React15.createElement(Box14, { marginY: 1 }, /* @__PURE__ */ React15.createElement(Text14, { color: "magenta" }, SPINNER_FRAMES[tick % SPINNER_FRAMES.length]), /* @__PURE__ */ React15.createElement(Text14, { color: "magenta" }, ` ${text}`), /* @__PURE__ */ React15.createElement(Text14, { dimColor: true }, ` ${elapsed}s`));
+}
+function ModeStatusBar({
+  editMode,
+  pendingCount,
+  flash,
+  planMode,
+  undoArmed,
+  jobs
+}) {
+  useTick();
+  const running = jobs?.runningCount() ?? 0;
+  const jobsTag = running > 0 ? /* @__PURE__ */ React15.createElement(Text14, { color: "yellow", bold: true }, `  \xB7  \u23F5 ${running} job${running === 1 ? "" : "s"}`) : null;
+  if (planMode) {
+    return /* @__PURE__ */ React15.createElement(Box14, { paddingX: 1 }, /* @__PURE__ */ React15.createElement(Text14, { color: "red", bold: true, inverse: flash }, "\u25B8 PLAN"), /* @__PURE__ */ React15.createElement(Text14, { dimColor: true }, "  writes gated \u2014 submit_plan + approval required  \xB7  /plan off to leave"), jobsTag);
+  }
+  const label = editMode === "auto" ? "AUTO" : "review";
+  const color = editMode === "auto" ? "magenta" : "cyan";
+  const mid = editMode === "auto" ? undoArmed ? "edits apply immediately  \xB7  u = undo last batch" : "edits apply immediately  \xB7  5s undo window after each batch" : pendingCount > 0 ? `${pendingCount} queued  \xB7  y = /apply  \xB7  n = /discard` : "edits queue for review  \xB7  y = /apply  \xB7  n = /discard";
+  const flip = editMode === "auto" ? "Shift+Tab \u2192 review" : "Shift+Tab \u2192 AUTO";
+  return /* @__PURE__ */ React15.createElement(Box14, { paddingX: 1 }, /* @__PURE__ */ React15.createElement(Text14, { color, bold: true, inverse: flash }, `\u25B8 ${label}`), /* @__PURE__ */ React15.createElement(Text14, { dimColor: true }, `  ${mid}  \xB7  ${flip}`), jobsTag);
+}
+function UndoBanner({
+  banner
+}) {
+  useTick();
+  const remainingMs = Math.max(0, banner.expiresAt - Date.now());
+  const remainingSec = Math.ceil(remainingMs / 1e3);
+  const ok = banner.results.filter((r) => r.status === "applied" || r.status === "created").length;
+  const total = banner.results.length;
+  return /* @__PURE__ */ React15.createElement(Box14, { marginY: 1, borderStyle: "round", borderColor: "magenta", paddingX: 1 }, /* @__PURE__ */ React15.createElement(Text14, { color: "magenta", bold: true }, "\u2713 auto-applied "), /* @__PURE__ */ React15.createElement(Text14, { color: "magenta" }, `${ok}/${total} edit${total === 1 ? "" : "s"}`), /* @__PURE__ */ React15.createElement(Text14, { dimColor: true }, " \xB7 press "), /* @__PURE__ */ React15.createElement(Text14, { color: "magenta", bold: true }, "u"), /* @__PURE__ */ React15.createElement(Text14, { dimColor: true }, " to undo  ("), /* @__PURE__ */ React15.createElement(Text14, { color: remainingSec <= 1 ? "red" : "magenta" }, `${remainingSec}s`), /* @__PURE__ */ React15.createElement(Text14, { dimColor: true }, ")"));
 }
 function SubagentRow({
   activity
 }) {
   const tick = useTick();
   const seconds = (activity.elapsedMs / 1e3).toFixed(1);
-  return /* @__PURE__ */ React14.createElement(Box13, { paddingLeft: 2 }, /* @__PURE__ */ React14.createElement(Text13, { color: "magenta" }, SPINNER_FRAMES[tick % SPINNER_FRAMES.length]), /* @__PURE__ */ React14.createElement(Text13, { color: "magenta" }, ` \u232C subagent: ${activity.task}`), /* @__PURE__ */ React14.createElement(Text13, { dimColor: true }, ` \xB7 iter ${activity.iter} \xB7 ${seconds}s`));
+  return /* @__PURE__ */ React15.createElement(Box14, { paddingLeft: 2 }, /* @__PURE__ */ React15.createElement(Text14, { color: "magenta" }, SPINNER_FRAMES[tick % SPINNER_FRAMES.length]), /* @__PURE__ */ React15.createElement(Text14, { color: "magenta" }, ` \u232C subagent: ${activity.task}`), /* @__PURE__ */ React15.createElement(Text14, { dimColor: true }, ` \xB7 iter ${activity.iter} \xB7 ${seconds}s`));
 }
 function OngoingToolRow({
   tool,
@@ -9999,7 +11400,7 @@ function OngoingToolRow({
   const tick = useTick();
   const elapsed = useElapsedSeconds();
   const summary = summarizeToolArgs(tool.name, tool.args);
-  return /* @__PURE__ */ React14.createElement(Box13, { marginY: 1, flexDirection: "column" }, /* @__PURE__ */ React14.createElement(Box13, null, /* @__PURE__ */ React14.createElement(Text13, { color: "cyan" }, SPINNER_FRAMES[tick % SPINNER_FRAMES.length]), /* @__PURE__ */ React14.createElement(Text13, { color: "yellow" }, ` tool<${tool.name}> running\u2026`), /* @__PURE__ */ React14.createElement(Text13, { dimColor: true }, ` ${elapsed}s`)), progress ? /* @__PURE__ */ React14.createElement(Box13, { paddingLeft: 2 }, /* @__PURE__ */ React14.createElement(Text13, { color: "cyan" }, renderProgressLine(progress))) : null, summary ? /* @__PURE__ */ React14.createElement(Box13, { paddingLeft: 2 }, /* @__PURE__ */ React14.createElement(Text13, { dimColor: true }, summary)) : null);
+  return /* @__PURE__ */ React15.createElement(Box14, { marginY: 1, flexDirection: "column" }, /* @__PURE__ */ React15.createElement(Box14, null, /* @__PURE__ */ React15.createElement(Text14, { color: "cyan" }, SPINNER_FRAMES[tick % SPINNER_FRAMES.length]), /* @__PURE__ */ React15.createElement(Text14, { color: "yellow" }, ` tool<${tool.name}> running\u2026`), /* @__PURE__ */ React15.createElement(Text14, { dimColor: true }, ` ${elapsed}s`)), progress ? /* @__PURE__ */ React15.createElement(Box14, { paddingLeft: 2 }, /* @__PURE__ */ React15.createElement(Text14, { color: "cyan" }, renderProgressLine(progress))) : null, summary ? /* @__PURE__ */ React15.createElement(Box14, { paddingLeft: 2 }, /* @__PURE__ */ React15.createElement(Text14, { dimColor: true }, summary)) : null);
 }
 function renderProgressLine(p) {
   const msg = p.message ? `  ${p.message}` : "";
@@ -10069,13 +11470,12 @@ function formatPendingPreview(blocks) {
   const diffLines = formatAllBlockDiffs(blocks);
   return [header2, ...diffLines].join("\n");
 }
-function formatUndoResults(results) {
-  const lines = results.map((r) => {
+function formatUndoRows(results) {
+  return results.map((r) => {
     const mark = r.status === "applied" ? "\u2713" : "\u2717";
     const detail = r.message ? ` (${r.message})` : "";
     return `  ${mark} ${r.path}${detail}`;
   });
-  return [`\u25B8 undo: restored ${results.length} file(s) to pre-edit state`, ...lines].join("\n");
 }
 function describeRepair(repair) {
   const parts = [];
@@ -10086,15 +11486,15 @@ function describeRepair(repair) {
 }
 
 // src/cli/ui/SessionPicker.tsx
-import { Box as Box14, Text as Text14 } from "ink";
-import React15 from "react";
+import { Box as Box15, Text as Text15 } from "ink";
+import React16 from "react";
 function SessionPicker({
   sessionName,
   messageCount,
   lastActive,
   onChoose
 }) {
-  return /* @__PURE__ */ React15.createElement(Box14, { flexDirection: "column", marginY: 1 }, /* @__PURE__ */ React15.createElement(Box14, { marginBottom: 1 }, /* @__PURE__ */ React15.createElement(Text14, { bold: true, color: "cyan" }, `Session "${sessionName}" has ${messageCount} prior message${messageCount === 1 ? "" : "s"}`), /* @__PURE__ */ React15.createElement(Text14, { dimColor: true }, ` \xB7 last active ${relativeTime(lastActive)}`)), /* @__PURE__ */ React15.createElement(
+  return /* @__PURE__ */ React16.createElement(Box15, { flexDirection: "column", marginY: 1 }, /* @__PURE__ */ React16.createElement(Box15, { marginBottom: 1 }, /* @__PURE__ */ React16.createElement(Text15, { bold: true, color: "cyan" }, `Session "${sessionName}" has ${messageCount} prior message${messageCount === 1 ? "" : "s"}`), /* @__PURE__ */ React16.createElement(Text15, { dimColor: true }, ` \xB7 last active ${relativeTime(lastActive)}`)), /* @__PURE__ */ React16.createElement(
     SingleSelect,
     {
       initialValue: "new",
@@ -10117,7 +11517,7 @@ function SessionPicker({
       ],
       onSubmit: (v) => onChoose(v)
     }
-  ), /* @__PURE__ */ React15.createElement(Box14, { marginTop: 1 }, /* @__PURE__ */ React15.createElement(Text14, { dimColor: true }, "\u2191\u2193 to move \xB7 Enter to pick")));
+  ), /* @__PURE__ */ React16.createElement(Box15, { marginTop: 1 }, /* @__PURE__ */ React16.createElement(Text15, { dimColor: true }, "\u2191\u2193 to move \xB7 Enter to pick")));
 }
 function relativeTime(date) {
   const ms = Date.now() - date.getTime();
@@ -10133,12 +11533,12 @@ function relativeTime(date) {
 }
 
 // src/cli/ui/Setup.tsx
-import { Box as Box15, Text as Text15, useApp as useApp2 } from "ink";
+import { Box as Box16, Text as Text16, useApp as useApp2 } from "ink";
 import TextInput from "ink-text-input";
-import React16, { useState as useState6 } from "react";
+import React17, { useState as useState7 } from "react";
 function Setup({ onReady }) {
-  const [value, setValue] = useState6("");
-  const [error, setError] = useState6(null);
+  const [value, setValue] = useState7("");
+  const [error, setError] = useState7(null);
   const { exit } = useApp2();
   const handleSubmit = (raw) => {
     const trimmed = raw.trim();
@@ -10159,7 +11559,7 @@ function Setup({ onReady }) {
     }
     onReady(trimmed);
   };
-  return /* @__PURE__ */ React16.createElement(Box15, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1 }, /* @__PURE__ */ React16.createElement(Text15, { bold: true, color: "cyan" }, "Welcome to Reasonix."), /* @__PURE__ */ React16.createElement(Box15, { marginTop: 1 }, /* @__PURE__ */ React16.createElement(Text15, null, "Paste your DeepSeek API key to get started.")), /* @__PURE__ */ React16.createElement(Text15, { dimColor: true }, "Get one (free credit on signup): https://platform.deepseek.com/api_keys"), /* @__PURE__ */ React16.createElement(Text15, { dimColor: true }, "Saved locally to ", defaultConfigPath()), /* @__PURE__ */ React16.createElement(Box15, { marginTop: 1 }, /* @__PURE__ */ React16.createElement(Text15, { bold: true, color: "cyan" }, "key \u203A "), /* @__PURE__ */ React16.createElement(
+  return /* @__PURE__ */ React17.createElement(Box16, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1 }, /* @__PURE__ */ React17.createElement(Text16, { bold: true, color: "cyan" }, "Welcome to Reasonix."), /* @__PURE__ */ React17.createElement(Box16, { marginTop: 1 }, /* @__PURE__ */ React17.createElement(Text16, null, "Paste your DeepSeek API key to get started.")), /* @__PURE__ */ React17.createElement(Text16, { dimColor: true }, "Get one (free credit on signup): https://platform.deepseek.com/api_keys"), /* @__PURE__ */ React17.createElement(Text16, { dimColor: true }, "Saved locally to ", defaultConfigPath()), /* @__PURE__ */ React17.createElement(Box16, { marginTop: 1 }, /* @__PURE__ */ React17.createElement(Text16, { bold: true, color: "cyan" }, "key \u203A "), /* @__PURE__ */ React17.createElement(
     TextInput,
     {
       value,
@@ -10168,7 +11568,7 @@ function Setup({ onReady }) {
       mask: "\u2022",
       placeholder: "sk-..."
     }
-  )), error ? /* @__PURE__ */ React16.createElement(Box15, { marginTop: 1 }, /* @__PURE__ */ React16.createElement(Text15, { color: "red" }, error)) : value ? /* @__PURE__ */ React16.createElement(Box15, { marginTop: 1 }, /* @__PURE__ */ React16.createElement(Text15, { dimColor: true }, "preview: ", redactKey(value))) : null, /* @__PURE__ */ React16.createElement(Box15, { marginTop: 1 }, /* @__PURE__ */ React16.createElement(Text15, { dimColor: true }, "(Type /exit to abort.)")));
+  )), error ? /* @__PURE__ */ React17.createElement(Box16, { marginTop: 1 }, /* @__PURE__ */ React17.createElement(Text16, { color: "red" }, error)) : value ? /* @__PURE__ */ React17.createElement(Box16, { marginTop: 1 }, /* @__PURE__ */ React17.createElement(Text16, { dimColor: true }, "preview: ", redactKey(value))) : null, /* @__PURE__ */ React17.createElement(Box16, { marginTop: 1 }, /* @__PURE__ */ React17.createElement(Text16, { dimColor: true }, "(Type /exit to abort.)")));
 }
 
 // src/cli/commands/chat.tsx
@@ -10181,10 +11581,10 @@ function Root({
   sessionPreview,
   ...appProps
 }) {
-  const [key, setKey] = useState7(initialKey);
-  const [pending, setPending] = useState7(sessionPreview);
+  const [key, setKey] = useState8(initialKey);
+  const [pending, setPending] = useState8(sessionPreview);
   if (!key) {
-    return /* @__PURE__ */ React17.createElement(
+    return /* @__PURE__ */ React18.createElement(
       Setup,
       {
         onReady: (k) => {
@@ -10196,7 +11596,7 @@ function Root({
   }
   process.env.DEEPSEEK_API_KEY = key;
   if (pending && appProps.session) {
-    return /* @__PURE__ */ React17.createElement(
+    return /* @__PURE__ */ React18.createElement(
       SessionPicker,
       {
         sessionName: appProps.session,
@@ -10211,7 +11611,7 @@ function Root({
       }
     );
   }
-  return /* @__PURE__ */ React17.createElement(
+  return /* @__PURE__ */ React18.createElement(
     App,
     {
       model: appProps.model,
@@ -10315,7 +11715,7 @@ async function chatCommand(opts) {
     rewriteSession(opts.session, []);
   }
   const { waitUntilExit } = render(
-    /* @__PURE__ */ React17.createElement(
+    /* @__PURE__ */ React18.createElement(
       Root,
       {
         initialKey,
@@ -10339,13 +11739,14 @@ async function chatCommand(opts) {
 }
 
 // src/cli/commands/code.tsx
-import { basename, resolve as resolve6 } from "path";
+import { basename, resolve as resolve7 } from "path";
 async function codeCommand(opts = {}) {
-  const { codeSystemPrompt: codeSystemPrompt2 } = await import("./prompt-75XLIUTO.js");
-  const rootDir = resolve6(opts.dir ?? process.cwd());
+  const { codeSystemPrompt: codeSystemPrompt2 } = await import("./prompt-OVVMCH5F.js");
+  const rootDir = resolve7(opts.dir ?? process.cwd());
   const session = opts.noSession ? void 0 : `code-${sanitizeName(basename(rootDir))}`;
   const tools = new ToolRegistry();
   registerFilesystemTools(tools, { rootDir });
+  const jobs = new JobRegistry();
   registerShellTools(tools, {
     rootDir,
     // Per-project "always allow" list persisted from prior ShellConfirm
@@ -10353,7 +11754,8 @@ async function codeCommand(opts = {}) {
     // GETTER form — re-read every dispatch so a prefix the user adds
     // via ShellConfirm mid-session takes effect on the next shell call
     // instead of waiting for `/new` or a relaunch.
-    extraAllowed: () => loadProjectShellAllowed(rootDir)
+    extraAllowed: () => loadProjectShellAllowed(rootDir),
+    jobs
   });
   registerPlanTool(tools);
   registerMemoryTools(tools, { projectRoot: rootDir });
@@ -10361,6 +11763,12 @@ async function codeCommand(opts = {}) {
     `\u25B8 reasonix code: rooted at ${rootDir}, session "${session ?? "(ephemeral)"}" \xB7 ${tools.size} native tool(s)
 `
   );
+  const sigShutdown = () => {
+    void jobs.shutdown();
+  };
+  process.once("SIGINT", sigShutdown);
+  process.once("SIGTERM", sigShutdown);
+  process.once("exit", sigShutdown);
   await chatCommand({
     model: opts.model ?? "deepseek-v4-pro",
     harvest: opts.harvest ?? false,
@@ -10368,7 +11776,7 @@ async function codeCommand(opts = {}) {
     transcript: opts.transcript,
     session,
     seedTools: tools,
-    codeMode: { rootDir },
+    codeMode: { rootDir, jobs },
     forceResume: opts.forceResume,
     forceNew: opts.forceNew
   });
@@ -10378,34 +11786,34 @@ async function codeCommand(opts = {}) {
 import { writeFileSync as writeFileSync6 } from "fs";
 import { basename as basename2 } from "path";
 import { render as render2 } from "ink";
-import React20 from "react";
+import React21 from "react";
 
 // src/cli/ui/DiffApp.tsx
-import { Box as Box17, Static as Static2, Text as Text17, useApp as useApp3, useInput as useInput5 } from "ink";
-import React19, { useState as useState8 } from "react";
+import { Box as Box18, Static as Static2, Text as Text18, useApp as useApp3, useInput as useInput6 } from "ink";
+import React20, { useState as useState9 } from "react";
 
 // src/cli/ui/RecordView.tsx
-import { Box as Box16, Text as Text16 } from "ink";
-import React18 from "react";
+import { Box as Box17, Text as Text17 } from "ink";
+import React19 from "react";
 function RecordView({ rec, compact = false }) {
   const toolArgsMax = compact ? 120 : 200;
   const toolContentMax = compact ? 200 : 400;
   if (rec.role === "user") {
-    return /* @__PURE__ */ React18.createElement(Box16, { marginTop: 1 }, /* @__PURE__ */ React18.createElement(Text16, { bold: true, color: "cyan" }, "you \u203A", " "), /* @__PURE__ */ React18.createElement(Text16, null, rec.content));
+    return /* @__PURE__ */ React19.createElement(Box17, { marginTop: 1 }, /* @__PURE__ */ React19.createElement(Text17, { bold: true, color: "cyan" }, "you \u203A", " "), /* @__PURE__ */ React19.createElement(Text17, null, rec.content));
   }
   if (rec.role === "assistant_final") {
-    return /* @__PURE__ */ React18.createElement(Box16, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React18.createElement(Box16, null, /* @__PURE__ */ React18.createElement(Text16, { bold: true, color: "green" }, "assistant"), rec.cost !== void 0 ? /* @__PURE__ */ React18.createElement(Text16, { dimColor: true }, "  $", rec.cost.toFixed(6)) : null, rec.usage ? /* @__PURE__ */ React18.createElement(CacheBadge, { usage: rec.usage }) : null), rec.planState ? /* @__PURE__ */ React18.createElement(PlanStateBlock, { planState: rec.planState }) : null, rec.content ? /* @__PURE__ */ React18.createElement(Text16, null, rec.content) : /* @__PURE__ */ React18.createElement(Text16, { dimColor: true, italic: true }, "(tool-call response only)"));
+    return /* @__PURE__ */ React19.createElement(Box17, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React19.createElement(Box17, null, /* @__PURE__ */ React19.createElement(Text17, { bold: true, color: "green" }, "assistant"), rec.cost !== void 0 ? /* @__PURE__ */ React19.createElement(Text17, { dimColor: true }, "  $", rec.cost.toFixed(6)) : null, rec.usage ? /* @__PURE__ */ React19.createElement(CacheBadge, { usage: rec.usage }) : null), rec.planState ? /* @__PURE__ */ React19.createElement(PlanStateBlock, { planState: rec.planState }) : null, rec.content ? /* @__PURE__ */ React19.createElement(Text17, null, rec.content) : /* @__PURE__ */ React19.createElement(Text17, { dimColor: true, italic: true }, "(tool-call response only)"));
   }
   if (rec.role === "tool") {
-    return /* @__PURE__ */ React18.createElement(Box16, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React18.createElement(Text16, { color: "yellow" }, "tool<", rec.tool ?? "?", ">"), rec.args ? /* @__PURE__ */ React18.createElement(Text16, { dimColor: true }, "  args: ", truncate3(rec.args, toolArgsMax)) : null, /* @__PURE__ */ React18.createElement(Text16, { dimColor: true }, "  \u2192 ", truncate3(rec.content, toolContentMax)));
+    return /* @__PURE__ */ React19.createElement(Box17, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React19.createElement(Text17, { color: "yellow" }, "tool<", rec.tool ?? "?", ">"), rec.args ? /* @__PURE__ */ React19.createElement(Text17, { dimColor: true }, "  args: ", truncate3(rec.args, toolArgsMax)) : null, /* @__PURE__ */ React19.createElement(Text17, { dimColor: true }, "  \u2192 ", truncate3(rec.content, toolContentMax)));
   }
   if (rec.role === "error") {
-    return /* @__PURE__ */ React18.createElement(Box16, { marginTop: 1 }, /* @__PURE__ */ React18.createElement(Text16, { color: "red", bold: true }, "error", " "), /* @__PURE__ */ React18.createElement(Text16, { color: "red" }, rec.error ?? rec.content));
+    return /* @__PURE__ */ React19.createElement(Box17, { marginTop: 1 }, /* @__PURE__ */ React19.createElement(Text17, { color: "red", bold: true }, "error", " "), /* @__PURE__ */ React19.createElement(Text17, { color: "red" }, rec.error ?? rec.content));
   }
   if (rec.role === "done" || rec.role === "assistant_delta") {
     return null;
   }
-  return /* @__PURE__ */ React18.createElement(Box16, null, /* @__PURE__ */ React18.createElement(Text16, { dimColor: true }, "[", rec.role, "] ", rec.content));
+  return /* @__PURE__ */ React19.createElement(Box17, null, /* @__PURE__ */ React19.createElement(Text17, { dimColor: true }, "[", rec.role, "] ", rec.content));
 }
 function CacheBadge({ usage }) {
   const hit = usage.prompt_cache_hit_tokens ?? 0;
@@ -10414,7 +11822,7 @@ function CacheBadge({ usage }) {
   if (total === 0) return null;
   const pct2 = hit / total * 100;
   const color = pct2 >= 70 ? "green" : pct2 >= 40 ? "yellow" : "red";
-  return /* @__PURE__ */ React18.createElement(Text16, null, /* @__PURE__ */ React18.createElement(Text16, { dimColor: true }, "  \xB7 cache "), /* @__PURE__ */ React18.createElement(Text16, { color }, pct2.toFixed(1), "%"));
+  return /* @__PURE__ */ React19.createElement(Text17, null, /* @__PURE__ */ React19.createElement(Text17, { dimColor: true }, "  \xB7 cache "), /* @__PURE__ */ React19.createElement(Text17, { color }, pct2.toFixed(1), "%"));
 }
 function truncate3(s, max) {
   return s.length <= max ? s : `${s.slice(0, max)}\u2026 (+${s.length - max} chars)`;
@@ -10425,8 +11833,8 @@ function DiffApp({ report }) {
   const { exit } = useApp3();
   const maxIdx = Math.max(0, report.pairs.length - 1);
   const initialIdx = report.firstDivergenceTurn ? report.pairs.findIndex((p) => p.turn === report.firstDivergenceTurn) : 0;
-  const [idx, setIdx] = useState8(Math.max(0, initialIdx));
-  useInput5((input, key) => {
+  const [idx, setIdx] = useState9(Math.max(0, initialIdx));
+  useInput6((input, key) => {
     if (input === "q" || key.ctrl && input === "c") {
       exit();
       return;
@@ -10448,7 +11856,7 @@ function DiffApp({ report }) {
     }
   });
   const pair = report.pairs[idx];
-  return /* @__PURE__ */ React19.createElement(Box17, { flexDirection: "column" }, /* @__PURE__ */ React19.createElement(DiffHeader, { report }), /* @__PURE__ */ React19.createElement(Box17, { marginTop: 1, paddingX: 1, justifyContent: "space-between" }, /* @__PURE__ */ React19.createElement(Text17, { color: "cyan", bold: true }, "turn ", pair?.turn ?? "?", " (", idx + 1, " / ", report.pairs.length, ")"), /* @__PURE__ */ React19.createElement(Text17, null, pair ? /* @__PURE__ */ React19.createElement(KindBadge, { kind: pair.kind }) : null)), /* @__PURE__ */ React19.createElement(Box17, { flexDirection: "row", marginTop: 1 }, /* @__PURE__ */ React19.createElement(Pane, { label: report.a.label, headerColor: "blue", records: paneRecords(pair, "a") }), /* @__PURE__ */ React19.createElement(Pane, { label: report.b.label, headerColor: "magenta", records: paneRecords(pair, "b") })), pair?.divergenceNote ? /* @__PURE__ */ React19.createElement(Box17, { marginTop: 1, paddingX: 1 }, /* @__PURE__ */ React19.createElement(Text17, { color: "yellow" }, "\u2605 "), /* @__PURE__ */ React19.createElement(Text17, null, pair.divergenceNote)) : null, /* @__PURE__ */ React19.createElement(Box17, { marginTop: 1, paddingX: 1, borderStyle: "single", borderColor: "gray" }, /* @__PURE__ */ React19.createElement(Text17, { dimColor: true }, /* @__PURE__ */ React19.createElement(Text17, { bold: true }, "j"), "/", /* @__PURE__ */ React19.createElement(Text17, { bold: true }, "\u2193"), " next \xB7 ", /* @__PURE__ */ React19.createElement(Text17, { bold: true }, "k"), "/", /* @__PURE__ */ React19.createElement(Text17, { bold: true }, "\u2191"), " ", "prev \xB7 ", /* @__PURE__ */ React19.createElement(Text17, { bold: true }, "n"), " next-diverge \xB7 ", /* @__PURE__ */ React19.createElement(Text17, { bold: true }, "N"), "/", /* @__PURE__ */ React19.createElement(Text17, { bold: true }, "p"), " ", "prev-diverge \xB7 ", /* @__PURE__ */ React19.createElement(Text17, { bold: true }, "g"), "/", /* @__PURE__ */ React19.createElement(Text17, { bold: true }, "G"), " first/last \xB7 ", /* @__PURE__ */ React19.createElement(Text17, { bold: true }, "q"), " ", "quit")));
+  return /* @__PURE__ */ React20.createElement(Box18, { flexDirection: "column" }, /* @__PURE__ */ React20.createElement(DiffHeader, { report }), /* @__PURE__ */ React20.createElement(Box18, { marginTop: 1, paddingX: 1, justifyContent: "space-between" }, /* @__PURE__ */ React20.createElement(Text18, { color: "cyan", bold: true }, "turn ", pair?.turn ?? "?", " (", idx + 1, " / ", report.pairs.length, ")"), /* @__PURE__ */ React20.createElement(Text18, null, pair ? /* @__PURE__ */ React20.createElement(KindBadge, { kind: pair.kind }) : null)), /* @__PURE__ */ React20.createElement(Box18, { flexDirection: "row", marginTop: 1 }, /* @__PURE__ */ React20.createElement(Pane, { label: report.a.label, headerColor: "blue", records: paneRecords(pair, "a") }), /* @__PURE__ */ React20.createElement(Pane, { label: report.b.label, headerColor: "magenta", records: paneRecords(pair, "b") })), pair?.divergenceNote ? /* @__PURE__ */ React20.createElement(Box18, { marginTop: 1, paddingX: 1 }, /* @__PURE__ */ React20.createElement(Text18, { color: "yellow" }, "\u2605 "), /* @__PURE__ */ React20.createElement(Text18, null, pair.divergenceNote)) : null, /* @__PURE__ */ React20.createElement(Box18, { marginTop: 1, paddingX: 1, borderStyle: "single", borderColor: "gray" }, /* @__PURE__ */ React20.createElement(Text18, { dimColor: true }, /* @__PURE__ */ React20.createElement(Text18, { bold: true }, "j"), "/", /* @__PURE__ */ React20.createElement(Text18, { bold: true }, "\u2193"), " next \xB7 ", /* @__PURE__ */ React20.createElement(Text18, { bold: true }, "k"), "/", /* @__PURE__ */ React20.createElement(Text18, { bold: true }, "\u2191"), " ", "prev \xB7 ", /* @__PURE__ */ React20.createElement(Text18, { bold: true }, "n"), " next-diverge \xB7 ", /* @__PURE__ */ React20.createElement(Text18, { bold: true }, "N"), "/", /* @__PURE__ */ React20.createElement(Text18, { bold: true }, "p"), " ", "prev-diverge \xB7 ", /* @__PURE__ */ React20.createElement(Text18, { bold: true }, "g"), "/", /* @__PURE__ */ React20.createElement(Text18, { bold: true }, "G"), " first/last \xB7 ", /* @__PURE__ */ React20.createElement(Text18, { bold: true }, "q"), " ", "quit")));
 }
 function DiffHeader({ report }) {
   const a = report.a;
@@ -10466,15 +11874,15 @@ function DiffHeader({ report }) {
   } else if (a.stats.prefixHashes[0] && a.stats.prefixHashes[0] === b.stats.prefixHashes[0]) {
     prefixLine = `shared prefix hash ${a.stats.prefixHashes[0].slice(0, 12)}\u2026 \u2014 cache delta attributable to log stability, not prompt change.`;
   }
-  return /* @__PURE__ */ React19.createElement(Box17, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1 }, /* @__PURE__ */ React19.createElement(Box17, { justifyContent: "space-between" }, /* @__PURE__ */ React19.createElement(Text17, null, /* @__PURE__ */ React19.createElement(Text17, { color: "cyan", bold: true }, "reasonix diff"), /* @__PURE__ */ React19.createElement(Text17, { dimColor: true }, " \xB7 A="), /* @__PURE__ */ React19.createElement(Text17, { color: "blue" }, a.label), /* @__PURE__ */ React19.createElement(Text17, { dimColor: true }, " vs B="), /* @__PURE__ */ React19.createElement(Text17, { color: "magenta" }, b.label)), /* @__PURE__ */ React19.createElement(Text17, { dimColor: true }, report.pairs.length, " turns aligned")), /* @__PURE__ */ React19.createElement(Box17, { marginTop: 1, gap: 3 }, /* @__PURE__ */ React19.createElement(Text17, null, /* @__PURE__ */ React19.createElement(Text17, { dimColor: true }, "cache "), /* @__PURE__ */ React19.createElement(Text17, null, (a.stats.cacheHitRatio * 100).toFixed(1), "%"), /* @__PURE__ */ React19.createElement(Text17, { dimColor: true }, " \u2192 "), /* @__PURE__ */ React19.createElement(Text17, null, (b.stats.cacheHitRatio * 100).toFixed(1), "%"), /* @__PURE__ */ React19.createElement(Text17, { color: cacheDelta >= 0 ? "green" : "red", bold: true }, "  ", cacheDelta >= 0 ? "+" : "", (cacheDelta * 100).toFixed(1), "pp")), /* @__PURE__ */ React19.createElement(Text17, null, /* @__PURE__ */ React19.createElement(Text17, { dimColor: true }, "cost "), /* @__PURE__ */ React19.createElement(Text17, null, "$", a.stats.totalCostUsd.toFixed(6)), /* @__PURE__ */ React19.createElement(Text17, { dimColor: true }, " \u2192 "), /* @__PURE__ */ React19.createElement(Text17, null, "$", b.stats.totalCostUsd.toFixed(6)), /* @__PURE__ */ React19.createElement(Text17, { color: costDelta2 <= 0 ? "green" : "red", bold: true }, "  ", costDelta2 >= 0 ? "+" : "", costDelta2.toFixed(1), "%")), /* @__PURE__ */ React19.createElement(Text17, null, /* @__PURE__ */ React19.createElement(Text17, { dimColor: true }, "model calls "), /* @__PURE__ */ React19.createElement(Text17, null, a.stats.turns, " \u2192 ", b.stats.turns))), prefixLine ? /* @__PURE__ */ React19.createElement(Box17, { marginTop: 1 }, /* @__PURE__ */ React19.createElement(Text17, { dimColor: true, italic: true }, prefixLine)) : null);
+  return /* @__PURE__ */ React20.createElement(Box18, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1 }, /* @__PURE__ */ React20.createElement(Box18, { justifyContent: "space-between" }, /* @__PURE__ */ React20.createElement(Text18, null, /* @__PURE__ */ React20.createElement(Text18, { color: "cyan", bold: true }, "reasonix diff"), /* @__PURE__ */ React20.createElement(Text18, { dimColor: true }, " \xB7 A="), /* @__PURE__ */ React20.createElement(Text18, { color: "blue" }, a.label), /* @__PURE__ */ React20.createElement(Text18, { dimColor: true }, " vs B="), /* @__PURE__ */ React20.createElement(Text18, { color: "magenta" }, b.label)), /* @__PURE__ */ React20.createElement(Text18, { dimColor: true }, report.pairs.length, " turns aligned")), /* @__PURE__ */ React20.createElement(Box18, { marginTop: 1, gap: 3 }, /* @__PURE__ */ React20.createElement(Text18, null, /* @__PURE__ */ React20.createElement(Text18, { dimColor: true }, "cache "), /* @__PURE__ */ React20.createElement(Text18, null, (a.stats.cacheHitRatio * 100).toFixed(1), "%"), /* @__PURE__ */ React20.createElement(Text18, { dimColor: true }, " \u2192 "), /* @__PURE__ */ React20.createElement(Text18, null, (b.stats.cacheHitRatio * 100).toFixed(1), "%"), /* @__PURE__ */ React20.createElement(Text18, { color: cacheDelta >= 0 ? "green" : "red", bold: true }, "  ", cacheDelta >= 0 ? "+" : "", (cacheDelta * 100).toFixed(1), "pp")), /* @__PURE__ */ React20.createElement(Text18, null, /* @__PURE__ */ React20.createElement(Text18, { dimColor: true }, "cost "), /* @__PURE__ */ React20.createElement(Text18, null, "$", a.stats.totalCostUsd.toFixed(6)), /* @__PURE__ */ React20.createElement(Text18, { dimColor: true }, " \u2192 "), /* @__PURE__ */ React20.createElement(Text18, null, "$", b.stats.totalCostUsd.toFixed(6)), /* @__PURE__ */ React20.createElement(Text18, { color: costDelta2 <= 0 ? "green" : "red", bold: true }, "  ", costDelta2 >= 0 ? "+" : "", costDelta2.toFixed(1), "%")), /* @__PURE__ */ React20.createElement(Text18, null, /* @__PURE__ */ React20.createElement(Text18, { dimColor: true }, "model calls "), /* @__PURE__ */ React20.createElement(Text18, null, a.stats.turns, " \u2192 ", b.stats.turns))), prefixLine ? /* @__PURE__ */ React20.createElement(Box18, { marginTop: 1 }, /* @__PURE__ */ React20.createElement(Text18, { dimColor: true, italic: true }, prefixLine)) : null);
 }
 function Pane({
   label,
   headerColor,
   records
 }) {
-  return /* @__PURE__ */ React19.createElement(
-    Box17,
+  return /* @__PURE__ */ React20.createElement(
+    Box18,
     {
       flexDirection: "column",
       flexGrow: 1,
@@ -10482,21 +11890,21 @@ function Pane({
       borderStyle: "single",
       borderColor: headerColor
     },
-    /* @__PURE__ */ React19.createElement(Text17, { color: headerColor, bold: true }, label),
-    records.length === 0 ? /* @__PURE__ */ React19.createElement(Box17, { marginTop: 1 }, /* @__PURE__ */ React19.createElement(Text17, { dimColor: true, italic: true }, "(no records on this side for this turn)")) : /* @__PURE__ */ React19.createElement(Static2, { items: records.map((rec, i) => ({ key: `${label}-${i}`, rec })) }, ({ key, rec }) => /* @__PURE__ */ React19.createElement(RecordView, { key, rec, compact: true }))
+    /* @__PURE__ */ React20.createElement(Text18, { color: headerColor, bold: true }, label),
+    records.length === 0 ? /* @__PURE__ */ React20.createElement(Box18, { marginTop: 1 }, /* @__PURE__ */ React20.createElement(Text18, { dimColor: true, italic: true }, "(no records on this side for this turn)")) : /* @__PURE__ */ React20.createElement(Static2, { items: records.map((rec, i) => ({ key: `${label}-${i}`, rec })) }, ({ key, rec }) => /* @__PURE__ */ React20.createElement(RecordView, { key, rec, compact: true }))
   );
 }
 function KindBadge({ kind }) {
   if (kind === "match") {
-    return /* @__PURE__ */ React19.createElement(Text17, { color: "green" }, "\u2713 match");
+    return /* @__PURE__ */ React20.createElement(Text18, { color: "green" }, "\u2713 match");
   }
   if (kind === "diverge") {
-    return /* @__PURE__ */ React19.createElement(Text17, { color: "yellow" }, "\u2605 diverge");
+    return /* @__PURE__ */ React20.createElement(Text18, { color: "yellow" }, "\u2605 diverge");
   }
   if (kind === "only_in_a") {
-    return /* @__PURE__ */ React19.createElement(Text17, { color: "blue" }, "\u2190 only in A");
+    return /* @__PURE__ */ React20.createElement(Text18, { color: "blue" }, "\u2190 only in A");
   }
-  return /* @__PURE__ */ React19.createElement(Text17, { color: "magenta" }, "\u2192 only in B");
+  return /* @__PURE__ */ React20.createElement(Text18, { color: "magenta" }, "\u2192 only in B");
 }
 function paneRecords(pair, side) {
   if (!pair) return [];
@@ -10527,7 +11935,7 @@ markdown report written to ${opts.mdPath}`);
     return;
   }
   if (wantTui) {
-    const { waitUntilExit } = render2(React20.createElement(DiffApp, { report }), {
+    const { waitUntilExit } = render2(React21.createElement(DiffApp, { report }), {
       exitOnCtrlC: true,
       patchConsole: false
     });
@@ -10668,16 +12076,16 @@ function pad2(s, width) {
 
 // src/cli/commands/replay.ts
 import { render as render3 } from "ink";
-import React22 from "react";
+import React23 from "react";
 
 // src/cli/ui/ReplayApp.tsx
-import { Box as Box18, Static as Static3, Text as Text18, useApp as useApp4, useInput as useInput6 } from "ink";
-import React21, { useMemo as useMemo2, useState as useState9 } from "react";
+import { Box as Box19, Static as Static3, Text as Text19, useApp as useApp4, useInput as useInput7 } from "ink";
+import React22, { useMemo as useMemo3, useState as useState10 } from "react";
 function ReplayApp({ meta, pages }) {
   const { exit } = useApp4();
   const maxIdx = Math.max(0, pages.length - 1);
-  const [idx, setIdx] = useState9(maxIdx);
-  useInput6((input, key) => {
+  const [idx, setIdx] = useState10(maxIdx);
+  useInput7((input, key) => {
     if (input === "q" || key.ctrl && input === "c") {
       exit();
       return;
@@ -10696,7 +12104,7 @@ function ReplayApp({ meta, pages }) {
       setIdx(maxIdx);
     }
   });
-  const cumStats = useMemo2(() => computeCumulativeStats(pages, idx), [pages, idx]);
+  const cumStats = useMemo3(() => computeCumulativeStats(pages, idx), [pages, idx]);
   const summary = {
     turns: cumStats.turns,
     totalCostUsd: cumStats.totalCostUsd,
@@ -10711,14 +12119,14 @@ function ReplayApp({ meta, pages }) {
   const prefixHash = cumStats.prefixHashes.length === 1 ? cumStats.prefixHashes[0].slice(0, 16) : cumStats.prefixHashes.length === 0 ? "(untracked)" : `(churned \xD7${cumStats.prefixHashes.length})`;
   const currentPage = pages[idx];
   const progressLabel = pages.length === 0 ? "empty transcript" : `turn ${idx + 1} / ${pages.length}`;
-  return /* @__PURE__ */ React21.createElement(Box18, { flexDirection: "column" }, /* @__PURE__ */ React21.createElement(
+  return /* @__PURE__ */ React22.createElement(Box19, { flexDirection: "column" }, /* @__PURE__ */ React22.createElement(
     StatsPanel,
     {
       summary,
       model: cumStats.models[0] ?? meta?.model ?? "?",
       prefixHash
     }
-  ), /* @__PURE__ */ React21.createElement(Box18, { flexDirection: "column", marginTop: 1, paddingX: 1 }, /* @__PURE__ */ React21.createElement(Box18, { justifyContent: "space-between" }, /* @__PURE__ */ React21.createElement(Text18, { color: "cyan", bold: true }, progressLabel), meta ? /* @__PURE__ */ React21.createElement(Text18, { dimColor: true }, meta.source, meta.task ? ` \xB7 ${meta.task}` : "", meta.mode ? ` \xB7 ${meta.mode}` : "") : null), currentPage ? /* @__PURE__ */ React21.createElement(Static3, { items: currentPage.records.map((rec, i) => ({ key: `${idx}-${i}`, rec })) }, ({ key, rec }) => /* @__PURE__ */ React21.createElement(RecordView, { key, rec })) : /* @__PURE__ */ React21.createElement(Text18, { dimColor: true, italic: true }, "no records")), /* @__PURE__ */ React21.createElement(Box18, { marginTop: 1, paddingX: 1, borderStyle: "single", borderColor: "gray" }, /* @__PURE__ */ React21.createElement(Text18, { dimColor: true }, /* @__PURE__ */ React21.createElement(Text18, { bold: true }, "j"), "/", /* @__PURE__ */ React21.createElement(Text18, { bold: true }, "\u2193"), "/", /* @__PURE__ */ React21.createElement(Text18, { bold: true }, "space"), " next \xB7 ", /* @__PURE__ */ React21.createElement(Text18, { bold: true }, "k"), "/", /* @__PURE__ */ React21.createElement(Text18, { bold: true }, "\u2191"), " prev \xB7 ", /* @__PURE__ */ React21.createElement(Text18, { bold: true }, "g"), " first \xB7 ", /* @__PURE__ */ React21.createElement(Text18, { bold: true }, "G"), " last \xB7", " ", /* @__PURE__ */ React21.createElement(Text18, { bold: true }, "q"), " quit")));
+  ), /* @__PURE__ */ React22.createElement(Box19, { flexDirection: "column", marginTop: 1, paddingX: 1 }, /* @__PURE__ */ React22.createElement(Box19, { justifyContent: "space-between" }, /* @__PURE__ */ React22.createElement(Text19, { color: "cyan", bold: true }, progressLabel), meta ? /* @__PURE__ */ React22.createElement(Text19, { dimColor: true }, meta.source, meta.task ? ` \xB7 ${meta.task}` : "", meta.mode ? ` \xB7 ${meta.mode}` : "") : null), currentPage ? /* @__PURE__ */ React22.createElement(Static3, { items: currentPage.records.map((rec, i) => ({ key: `${idx}-${i}`, rec })) }, ({ key, rec }) => /* @__PURE__ */ React22.createElement(RecordView, { key, rec })) : /* @__PURE__ */ React22.createElement(Text19, { dimColor: true, italic: true }, "no records")), /* @__PURE__ */ React22.createElement(Box19, { marginTop: 1, paddingX: 1, borderStyle: "single", borderColor: "gray" }, /* @__PURE__ */ React22.createElement(Text19, { dimColor: true }, /* @__PURE__ */ React22.createElement(Text19, { bold: true }, "j"), "/", /* @__PURE__ */ React22.createElement(Text19, { bold: true }, "\u2193"), "/", /* @__PURE__ */ React22.createElement(Text19, { bold: true }, "space"), " next \xB7 ", /* @__PURE__ */ React22.createElement(Text19, { bold: true }, "k"), "/", /* @__PURE__ */ React22.createElement(Text19, { bold: true }, "\u2191"), " prev \xB7 ", /* @__PURE__ */ React22.createElement(Text19, { bold: true }, "g"), " first \xB7 ", /* @__PURE__ */ React22.createElement(Text19, { bold: true }, "G"), " last \xB7", " ", /* @__PURE__ */ React22.createElement(Text19, { bold: true }, "q"), " quit")));
 }
 
 // src/cli/commands/replay.ts
@@ -10730,7 +12138,7 @@ async function replayCommand(opts) {
   }
   const { parsed } = replayFromFile(opts.path);
   const pages = groupRecordsByTurn(parsed.records);
-  const { waitUntilExit } = render3(React22.createElement(ReplayApp, { meta: parsed.meta, pages }), {
+  const { waitUntilExit } = render3(React23.createElement(ReplayApp, { meta: parsed.meta, pages }), {
     exitOnCtrlC: true,
     patchConsole: false
   });
@@ -11035,12 +12443,12 @@ function truncate4(s, max) {
 
 // src/cli/commands/setup.tsx
 import { render as render4 } from "ink";
-import React24 from "react";
+import React25 from "react";
 
 // src/cli/ui/Wizard.tsx
-import { Box as Box19, Text as Text19, useApp as useApp5, useInput as useInput7 } from "ink";
+import { Box as Box20, Text as Text20, useApp as useApp5, useInput as useInput8 } from "ink";
 import TextInput2 from "ink-text-input";
-import React23, { useState as useState10 } from "react";
+import React24, { useState as useState11 } from "react";
 
 // src/cli/ui/presets.ts
 var PRESETS = {
@@ -11072,19 +12480,19 @@ var PRESET_DESCRIPTIONS = {
 var CATALOG_BY_NAME = new Map(MCP_CATALOG.map((e) => [e.name, e]));
 function Wizard({ onComplete, onCancel, existingApiKey, initial }) {
   const { exit } = useApp5();
-  const [step, setStep] = useState10(existingApiKey ? "preset" : "apiKey");
-  const [data, setData] = useState10({
+  const [step, setStep] = useState11(existingApiKey ? "preset" : "apiKey");
+  const [data, setData] = useState11({
     apiKey: existingApiKey ?? "",
     preset: initial?.preset ?? "fast",
     selectedCatalog: deriveInitialCatalog(initial?.mcp ?? []),
     catalogArgs: {}
   });
-  const [error, setError] = useState10(null);
-  useInput7((_input, key) => {
+  const [error, setError] = useState11(null);
+  useInput8((_input, key) => {
     if (key.escape && step !== "saved" && onCancel) onCancel();
   });
   if (step === "apiKey") {
-    return /* @__PURE__ */ React23.createElement(
+    return /* @__PURE__ */ React24.createElement(
       ApiKeyStep,
       {
         onSubmit: (key) => {
@@ -11098,7 +12506,7 @@ function Wizard({ onComplete, onCancel, existingApiKey, initial }) {
     );
   }
   if (step === "preset") {
-    return /* @__PURE__ */ React23.createElement(StepFrame, { title: "Pick a preset", step: 1, total: 3 }, /* @__PURE__ */ React23.createElement(
+    return /* @__PURE__ */ React24.createElement(StepFrame, { title: "Pick a preset", step: 1, total: 3 }, /* @__PURE__ */ React24.createElement(
       SingleSelect,
       {
         items: presetItems(),
@@ -11108,10 +12516,10 @@ function Wizard({ onComplete, onCancel, existingApiKey, initial }) {
           setStep("mcp");
         }
       }
-    ), /* @__PURE__ */ React23.createElement(Box19, { marginTop: 1 }, /* @__PURE__ */ React23.createElement(Text19, { dimColor: true }, "\u2191/\u2193 move \xB7 enter confirm \xB7 esc cancel")));
+    ), /* @__PURE__ */ React24.createElement(Box20, { marginTop: 1 }, /* @__PURE__ */ React24.createElement(Text20, { dimColor: true }, "\u2191/\u2193 move \xB7 enter confirm \xB7 esc cancel")));
   }
   if (step === "mcp") {
-    return /* @__PURE__ */ React23.createElement(StepFrame, { title: "Which MCP servers should Reasonix wire up for you?", step: 2, total: 3 }, /* @__PURE__ */ React23.createElement(
+    return /* @__PURE__ */ React24.createElement(StepFrame, { title: "Which MCP servers should Reasonix wire up for you?", step: 2, total: 3 }, /* @__PURE__ */ React24.createElement(
       MultiSelect,
       {
         items: mcpItems(),
@@ -11136,7 +12544,7 @@ function Wizard({ onComplete, onCancel, existingApiKey, initial }) {
     }
     const currentName = pending[0];
     const entry = CATALOG_BY_NAME.get(currentName);
-    return /* @__PURE__ */ React23.createElement(
+    return /* @__PURE__ */ React24.createElement(
       McpArgsStep,
       {
         entry,
@@ -11154,7 +12562,7 @@ function Wizard({ onComplete, onCancel, existingApiKey, initial }) {
   }
   if (step === "review") {
     const specs = data.selectedCatalog.map((name) => buildSpec(name, data.catalogArgs));
-    return /* @__PURE__ */ React23.createElement(StepFrame, { title: "Ready to save", step: 3, total: 3 }, /* @__PURE__ */ React23.createElement(Box19, { flexDirection: "column" }, /* @__PURE__ */ React23.createElement(SummaryLine, { label: "API key", value: redactKey(data.apiKey) }), /* @__PURE__ */ React23.createElement(SummaryLine, { label: "Preset", value: data.preset }), /* @__PURE__ */ React23.createElement(
+    return /* @__PURE__ */ React24.createElement(StepFrame, { title: "Ready to save", step: 3, total: 3 }, /* @__PURE__ */ React24.createElement(Box20, { flexDirection: "column" }, /* @__PURE__ */ React24.createElement(SummaryLine, { label: "API key", value: redactKey(data.apiKey) }), /* @__PURE__ */ React24.createElement(SummaryLine, { label: "Preset", value: data.preset }), /* @__PURE__ */ React24.createElement(
       SummaryLine,
       {
         label: "MCP",
@@ -11162,8 +12570,8 @@ function Wizard({ onComplete, onCancel, existingApiKey, initial }) {
       }
     ), specs.map((spec, i) => (
       // biome-ignore lint/suspicious/noArrayIndexKey: review-only render, order fixed
-      /* @__PURE__ */ React23.createElement(Box19, { key: i, paddingLeft: 14 }, /* @__PURE__ */ React23.createElement(Text19, { dimColor: true }, "\xB7 ", spec))
-    )), /* @__PURE__ */ React23.createElement(Box19, { marginTop: 1 }, /* @__PURE__ */ React23.createElement(Text19, null, "Saves to ", defaultConfigPath())), error ? /* @__PURE__ */ React23.createElement(Box19, { marginTop: 1 }, /* @__PURE__ */ React23.createElement(Text19, { color: "red" }, error)) : null, /* @__PURE__ */ React23.createElement(Box19, { marginTop: 1 }, /* @__PURE__ */ React23.createElement(Text19, { dimColor: true }, "enter save \xB7 esc cancel"))), /* @__PURE__ */ React23.createElement(
+      /* @__PURE__ */ React24.createElement(Box20, { key: i, paddingLeft: 14 }, /* @__PURE__ */ React24.createElement(Text20, { dimColor: true }, "\xB7 ", spec))
+    )), /* @__PURE__ */ React24.createElement(Box20, { marginTop: 1 }, /* @__PURE__ */ React24.createElement(Text20, null, "Saves to ", defaultConfigPath())), error ? /* @__PURE__ */ React24.createElement(Box20, { marginTop: 1 }, /* @__PURE__ */ React24.createElement(Text20, { color: "red" }, error)) : null, /* @__PURE__ */ React24.createElement(Box20, { marginTop: 1 }, /* @__PURE__ */ React24.createElement(Text20, { dimColor: true }, "enter save \xB7 esc cancel"))), /* @__PURE__ */ React24.createElement(
       ReviewConfirm,
       {
         onConfirm: () => {
@@ -11189,15 +12597,15 @@ function Wizard({ onComplete, onCancel, existingApiKey, initial }) {
       }
     ));
   }
-  return /* @__PURE__ */ React23.createElement(Box19, { flexDirection: "column", borderStyle: "round", borderColor: "green", paddingX: 1 }, /* @__PURE__ */ React23.createElement(Text19, { bold: true, color: "green" }, "\u25B8 Saved."), /* @__PURE__ */ React23.createElement(Box19, { marginTop: 1 }, /* @__PURE__ */ React23.createElement(Text19, null, "Run `reasonix` any time to start chatting \u2014 your settings are remembered.")), /* @__PURE__ */ React23.createElement(Box19, { marginTop: 1 }, /* @__PURE__ */ React23.createElement(Text19, { dimColor: true }, "Press enter to exit.")), /* @__PURE__ */ React23.createElement(ExitOnEnter, { onExit: exit }));
+  return /* @__PURE__ */ React24.createElement(Box20, { flexDirection: "column", borderStyle: "round", borderColor: "green", paddingX: 1 }, /* @__PURE__ */ React24.createElement(Text20, { bold: true, color: "green" }, "\u25B8 Saved."), /* @__PURE__ */ React24.createElement(Box20, { marginTop: 1 }, /* @__PURE__ */ React24.createElement(Text20, null, "Run `reasonix` any time to start chatting \u2014 your settings are remembered.")), /* @__PURE__ */ React24.createElement(Box20, { marginTop: 1 }, /* @__PURE__ */ React24.createElement(Text20, { dimColor: true }, "Press enter to exit.")), /* @__PURE__ */ React24.createElement(ExitOnEnter, { onExit: exit }));
 }
 function ApiKeyStep({
   onSubmit,
   error,
   onError
 }) {
-  const [value, setValue] = useState10("");
-  return /* @__PURE__ */ React23.createElement(Box19, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1 }, /* @__PURE__ */ React23.createElement(Text19, { bold: true, color: "cyan" }, "Welcome to Reasonix."), /* @__PURE__ */ React23.createElement(Box19, { marginTop: 1 }, /* @__PURE__ */ React23.createElement(Text19, null, "Paste your DeepSeek API key to get started.")), /* @__PURE__ */ React23.createElement(Text19, { dimColor: true }, "Get one (free credit on signup): https://platform.deepseek.com/api_keys"), /* @__PURE__ */ React23.createElement(Text19, { dimColor: true }, "Saved locally to ", defaultConfigPath()), /* @__PURE__ */ React23.createElement(Box19, { marginTop: 1 }, /* @__PURE__ */ React23.createElement(Text19, { bold: true, color: "cyan" }, "key \u203A "), /* @__PURE__ */ React23.createElement(
+  const [value, setValue] = useState11("");
+  return /* @__PURE__ */ React24.createElement(Box20, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1 }, /* @__PURE__ */ React24.createElement(Text20, { bold: true, color: "cyan" }, "Welcome to Reasonix."), /* @__PURE__ */ React24.createElement(Box20, { marginTop: 1 }, /* @__PURE__ */ React24.createElement(Text20, null, "Paste your DeepSeek API key to get started.")), /* @__PURE__ */ React24.createElement(Text20, { dimColor: true }, "Get one (free credit on signup): https://platform.deepseek.com/api_keys"), /* @__PURE__ */ React24.createElement(Text20, { dimColor: true }, "Saved locally to ", defaultConfigPath()), /* @__PURE__ */ React24.createElement(Box20, { marginTop: 1 }, /* @__PURE__ */ React24.createElement(Text20, { bold: true, color: "cyan" }, "key \u203A "), /* @__PURE__ */ React24.createElement(
     TextInput2,
     {
       value,
@@ -11214,7 +12622,7 @@ function ApiKeyStep({
       mask: "\u2022",
       placeholder: "sk-..."
     }
-  )), error ? /* @__PURE__ */ React23.createElement(Box19, { marginTop: 1 }, /* @__PURE__ */ React23.createElement(Text19, { color: "red" }, error)) : value ? /* @__PURE__ */ React23.createElement(Box19, { marginTop: 1 }, /* @__PURE__ */ React23.createElement(Text19, { dimColor: true }, "preview: ", redactKey(value))) : null);
+  )), error ? /* @__PURE__ */ React24.createElement(Box20, { marginTop: 1 }, /* @__PURE__ */ React24.createElement(Text20, { color: "red" }, error)) : value ? /* @__PURE__ */ React24.createElement(Box20, { marginTop: 1 }, /* @__PURE__ */ React24.createElement(Text20, { dimColor: true }, "preview: ", redactKey(value))) : null);
 }
 function McpArgsStep({
   entry,
@@ -11222,8 +12630,8 @@ function McpArgsStep({
   onSubmit,
   onError
 }) {
-  const [value, setValue] = useState10("");
-  return /* @__PURE__ */ React23.createElement(StepFrame, { title: `Configure ${entry.name}`, step: 2, total: 3 }, /* @__PURE__ */ React23.createElement(Box19, { flexDirection: "column" }, /* @__PURE__ */ React23.createElement(Text19, null, entry.summary), entry.note ? /* @__PURE__ */ React23.createElement(Box19, { marginTop: 1 }, /* @__PURE__ */ React23.createElement(Text19, { dimColor: true }, entry.note)) : null, /* @__PURE__ */ React23.createElement(Box19, { marginTop: 1 }, /* @__PURE__ */ React23.createElement(Text19, null, "Required parameter: "), /* @__PURE__ */ React23.createElement(Text19, { bold: true }, entry.userArgs)), /* @__PURE__ */ React23.createElement(Box19, { marginTop: 1 }, /* @__PURE__ */ React23.createElement(Text19, { bold: true, color: "cyan" }, entry.userArgs, " \u203A "), /* @__PURE__ */ React23.createElement(
+  const [value, setValue] = useState11("");
+  return /* @__PURE__ */ React24.createElement(StepFrame, { title: `Configure ${entry.name}`, step: 2, total: 3 }, /* @__PURE__ */ React24.createElement(Box20, { flexDirection: "column" }, /* @__PURE__ */ React24.createElement(Text20, null, entry.summary), entry.note ? /* @__PURE__ */ React24.createElement(Box20, { marginTop: 1 }, /* @__PURE__ */ React24.createElement(Text20, { dimColor: true }, entry.note)) : null, /* @__PURE__ */ React24.createElement(Box20, { marginTop: 1 }, /* @__PURE__ */ React24.createElement(Text20, null, "Required parameter: "), /* @__PURE__ */ React24.createElement(Text20, { bold: true }, entry.userArgs)), /* @__PURE__ */ React24.createElement(Box20, { marginTop: 1 }, /* @__PURE__ */ React24.createElement(Text20, { bold: true, color: "cyan" }, entry.userArgs, " \u203A "), /* @__PURE__ */ React24.createElement(
     TextInput2,
     {
       value,
@@ -11239,16 +12647,16 @@ function McpArgsStep({
       },
       placeholder: placeholderFor(entry)
     }
-  )), error ? /* @__PURE__ */ React23.createElement(Box19, { marginTop: 1 }, /* @__PURE__ */ React23.createElement(Text19, { color: "red" }, error)) : null));
+  )), error ? /* @__PURE__ */ React24.createElement(Box20, { marginTop: 1 }, /* @__PURE__ */ React24.createElement(Text20, { color: "red" }, error)) : null));
 }
 function ReviewConfirm({ onConfirm }) {
-  useInput7((_i, key) => {
+  useInput8((_i, key) => {
     if (key.return) onConfirm();
   });
   return null;
 }
 function ExitOnEnter({ onExit }) {
-  useInput7((_i, key) => {
+  useInput8((_i, key) => {
     if (key.return) onExit();
   });
   return null;
@@ -11259,10 +12667,10 @@ function StepFrame({
   total,
   children
 }) {
-  return /* @__PURE__ */ React23.createElement(Box19, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1 }, /* @__PURE__ */ React23.createElement(Box19, null, /* @__PURE__ */ React23.createElement(Text19, { dimColor: true }, "Step ", step, "/", total, " \xB7", " "), /* @__PURE__ */ React23.createElement(Text19, { bold: true, color: "cyan" }, title)), /* @__PURE__ */ React23.createElement(Box19, { marginTop: 1, flexDirection: "column" }, children));
+  return /* @__PURE__ */ React24.createElement(Box20, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1 }, /* @__PURE__ */ React24.createElement(Box20, null, /* @__PURE__ */ React24.createElement(Text20, { dimColor: true }, "Step ", step, "/", total, " \xB7", " "), /* @__PURE__ */ React24.createElement(Text20, { bold: true, color: "cyan" }, title)), /* @__PURE__ */ React24.createElement(Box20, { marginTop: 1, flexDirection: "column" }, children));
 }
 function SummaryLine({ label, value }) {
-  return /* @__PURE__ */ React23.createElement(Box19, null, /* @__PURE__ */ React23.createElement(Text19, null, label.padEnd(12)), /* @__PURE__ */ React23.createElement(Text19, { bold: true }, value));
+  return /* @__PURE__ */ React24.createElement(Box20, null, /* @__PURE__ */ React24.createElement(Text20, null, label.padEnd(12)), /* @__PURE__ */ React24.createElement(Text20, { bold: true }, value));
 }
 function presetItems() {
   return ["fast", "smart", "max"].map((name) => ({
@@ -11318,7 +12726,7 @@ async function setupCommand(_opts = {}) {
   const existingKey = loadApiKey();
   const existing = readConfig();
   const { waitUntilExit, unmount } = render4(
-    /* @__PURE__ */ React24.createElement(
+    /* @__PURE__ */ React25.createElement(
       Wizard,
       {
         existingApiKey: existingKey,
@@ -11336,7 +12744,7 @@ async function setupCommand(_opts = {}) {
 }
 
 // src/cli/commands/update.ts
-import { spawn as spawn4 } from "child_process";
+import { spawn as spawn5 } from "child_process";
 function planUpdate(input) {
   const diff = compareVersions(input.current, input.latest);
   if (diff > 0) {
@@ -11366,13 +12774,13 @@ function planUpdate(input) {
   };
 }
 function defaultSpawn(argv) {
-  return new Promise((resolve7, reject) => {
-    const child = spawn4(argv[0], argv.slice(1), {
+  return new Promise((resolve8, reject) => {
+    const child = spawn5(argv[0], argv.slice(1), {
       stdio: "inherit",
       shell: process.platform === "win32"
     });
     child.once("error", reject);
-    child.once("exit", (code) => resolve7(code ?? 1));
+    child.once("exit", (code) => resolve8(code ?? 1));
   });
 }
 async function updateCommand(opts = {}) {