reasonix 0.3.2 → 0.4.3

package/dist/cli/index.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import "./chunk-2P2MZLCE.js";
 
 // src/cli/index.ts
 import { Command } from "commander";
@@ -95,8 +96,8 @@ function computeWait(attempt, initial, cap, retryAfter) {
 }
 function sleep(ms, signal) {
   if (ms <= 0) return Promise.resolve();
-  return new Promise((resolve2, reject) => {
-    const timer = setTimeout(resolve2, ms);
+  return new Promise((resolve4, reject) => {
+    const timer = setTimeout(resolve4, ms);
     if (signal) {
       const onAbort = () => {
         clearTimeout(timer);
@@ -1166,7 +1167,7 @@ var CacheFirstLoop = class {
     this.prefix = opts.prefix;
     this.tools = opts.tools ?? new ToolRegistry();
     this.model = opts.model ?? "deepseek-chat";
-    this.maxToolIters = opts.maxToolIters ?? 24;
+    this.maxToolIters = opts.maxToolIters ?? 64;
     if (typeof opts.branch === "number") {
       this.branchOptions = { budget: opts.branch };
     } else if (opts.branch && typeof opts.branch === "object") {
@@ -1282,6 +1283,39 @@ var CacheFirstLoop = class {
   abort() {
     this._aborted = true;
   }
+  /**
+   * Drop everything in the log after (and including) the most recent
+   * user message. Used by `/retry` so the caller can re-send that
+   * message with a fresh turn instead of layering another response on
+   * top of the prior exchange. Returns the content of the dropped user
+   * message, or `null` if there isn't one yet.
+   *
+   * Persists by rewriting the session file — otherwise the next
+   * launch would rehydrate the old exchange and `/retry` would seem
+   * to have done nothing.
+   */
+  retryLastUser() {
+    const entries = this.log.entries;
+    let lastUserIdx = -1;
+    for (let i = entries.length - 1; i >= 0; i--) {
+      if (entries[i].role === "user") {
+        lastUserIdx = i;
+        break;
+      }
+    }
+    if (lastUserIdx < 0) return null;
+    const raw = entries[lastUserIdx].content;
+    const userText = typeof raw === "string" ? raw : "";
+    const preserved = entries.slice(0, lastUserIdx).map((m) => ({ ...m }));
+    this.log.compactInPlace(preserved);
+    if (this.sessionName) {
+      try {
+        rewriteSession(this.sessionName, preserved);
+      } catch {
+      }
+    }
+    return userText;
+  }
   async *step(userInput) {
     this._turn++;
     this.scratch.reset();
@@ -1295,9 +1329,17 @@ var CacheFirstLoop = class {
         yield {
           turn: this._turn,
           role: "warning",
-          content: `aborted at iter ${iter}/${this.maxToolIters} \u2014 forcing summary from what was gathered`
+          content: `aborted at iter ${iter}/${this.maxToolIters} \u2014 stopped without producing a summary (press \u2191 + Enter or /retry to resume)`
         };
-        yield* this.forceSummaryAfterIterLimit({ reason: "aborted" });
+        const stoppedMsg = "[aborted by user (Esc) \u2014 no summary produced. Ask again or /retry when ready; prior tool output is still in the log.]";
+        this.appendAndPersist({ role: "assistant", content: stoppedMsg });
+        yield {
+          turn: this._turn,
+          role: "assistant_final",
+          content: stoppedMsg,
+          forcedSummary: true
+        };
+        yield { turn: this._turn, role: "done", content: stoppedMsg };
         return;
       }
       if (!warnedForIterBudget && iter >= warnAt) {
@@ -1355,8 +1397,8 @@ var CacheFirstLoop = class {
             }
           );
           for (let k = 0; k < budget; k++) {
-            const sample = queue.shift() ?? await new Promise((resolve2) => {
-              waiter = resolve2;
+            const sample = queue.shift() ?? await new Promise((resolve4) => {
+              waiter = resolve4;
             });
             yield {
               turn: this._turn,
@@ -1476,9 +1518,28 @@ var CacheFirstLoop = class {
         yield { turn: this._turn, role: "done", content: assistantContent };
         return;
       }
+      const ctxMax = DEEPSEEK_CONTEXT_TOKENS[this.model] ?? DEFAULT_CONTEXT_TOKENS;
+      if (usage && usage.promptTokens / ctxMax > 0.8) {
+        yield {
+          turn: this._turn,
+          role: "warning",
+          content: `context ${usage.promptTokens}/${ctxMax} (${Math.round(
+            usage.promptTokens / ctxMax * 100
+          )}%) \u2014 more tools would overflow. Forcing summary from what was gathered.`
+        };
+        yield* this.forceSummaryAfterIterLimit({ reason: "context-guard" });
+        return;
+      }
       for (const call of repairedCalls) {
         const name = call.function?.name ?? "";
         const args = call.function?.arguments ?? "{}";
+        yield {
+          turn: this._turn,
+          role: "tool_start",
+          content: "",
+          toolName: name,
+          toolArgs: args
+        };
         const result = await this.tools.dispatch(name, args);
         this.appendAndPersist({
           role: "tool",
@@ -1500,13 +1561,19 @@ var CacheFirstLoop = class {
   async *forceSummaryAfterIterLimit(opts = { reason: "budget" }) {
     try {
       const messages = this.buildMessages(null);
+      messages.push({
+        role: "user",
+        content: "I'm out of tool-call budget for this turn. Summarize in plain prose what you learned from the tool results above. Do NOT emit any tool calls, function-call markup, DSML invocations, or SEARCH/REPLACE edit blocks \u2014 they will be silently discarded. Just plain text."
+      });
       const resp = await this.client.chat({
         model: this.model,
         messages
         // no tools → model is forced to answer in text
       });
-      const summary = resp.content?.trim() || "(model returned no text; try a narrower question or raise --max-tool-iters)";
-      const reasonPrefix = opts.reason === "aborted" ? "[aborted by user (Esc) \u2014 summarizing what I found so far]" : `[tool-call budget (${this.maxToolIters}) reached \u2014 forcing summary from what I found]`;
+      const rawContent = resp.content?.trim() ?? "";
+      const cleaned = stripHallucinatedToolMarkup(rawContent);
+      const summary = cleaned || "(model emitted fake tool-call markup instead of a prose summary \u2014 try /retry with a narrower question, or /think to inspect R1's reasoning)";
+      const reasonPrefix = reasonPrefixFor(opts.reason, this.maxToolIters);
       const annotated = `${reasonPrefix}
 
 ${summary}`;
@@ -1516,11 +1583,12 @@ ${summary}`;
         turn: this._turn,
         role: "assistant_final",
         content: annotated,
-        stats: summaryStats
+        stats: summaryStats,
+        forcedSummary: true
       };
       yield { turn: this._turn, role: "done", content: summary };
     } catch (err) {
-      const label = opts.reason === "aborted" ? "aborted by user" : `tool-call budget (${this.maxToolIters}) reached`;
+      const label = errorLabelFor(opts.reason, this.maxToolIters);
       yield {
         turn: this._turn,
         role: "error",
@@ -1545,6 +1613,26 @@ ${summary}`;
     return msg;
   }
 };
+function stripHallucinatedToolMarkup(s) {
+  let out = s;
+  out = out.replace(/<｜DSML｜function_calls>[\s\S]*?<\/?｜DSML｜function_calls>/g, "");
+  out = out.replace(/<\|DSML\|function_calls>[\s\S]*?<\/?\|DSML\|function_calls>/g, "");
+  out = out.replace(/<function_calls>[\s\S]*?<\/function_calls>/g, "");
+  out = out.replace(/<｜DSML｜[\s\S]*$/g, "");
+  return out.trim();
+}
+function reasonPrefixFor(reason, iterCap) {
+  if (reason === "aborted") return "[aborted by user (Esc) \u2014 summarizing what I found so far]";
+  if (reason === "context-guard") {
+    return "[context budget running low \u2014 summarizing before the next call would overflow]";
+  }
+  return `[tool-call budget (${iterCap}) reached \u2014 forcing summary from what I found]`;
+}
+function errorLabelFor(reason, iterCap) {
+  if (reason === "aborted") return "aborted by user";
+  if (reason === "context-guard") return "context-guard triggered (prompt > 80% of window)";
+  return `tool-call budget (${iterCap}) reached`;
+}
 function summarizeBranch(chosen, samples) {
   return {
     budget: samples.length,
@@ -2198,7 +2286,7 @@ var McpClient = class {
   async request(method, params) {
     const id = this.nextId++;
     const frame = { jsonrpc: "2.0", id, method, params };
-    const promise = new Promise((resolve2, reject) => {
+    const promise = new Promise((resolve4, reject) => {
       const timeout = setTimeout(() => {
         this.pending.delete(id);
         reject(
@@ -2206,7 +2294,7 @@ var McpClient = class {
         );
       }, this.requestTimeoutMs);
       this.pending.set(id, {
-        resolve: resolve2,
+        resolve: resolve4,
         reject,
         timeout
       });
@@ -2290,12 +2378,12 @@ var StdioTransport = class {
   }
   async send(message) {
     if (this.closed) throw new Error("MCP transport is closed");
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve4, reject) => {
       const line = `${JSON.stringify(message)}
 `;
       this.child.stdin.write(line, "utf8", (err) => {
         if (err) reject(err);
-        else resolve2();
+        else resolve4();
       });
     });
   }
@@ -2306,8 +2394,8 @@ var StdioTransport = class {
         continue;
       }
       if (this.closed) return;
-      const next = await new Promise((resolve2) => {
-        this.waiters.push(resolve2);
+      const next = await new Promise((resolve4) => {
+        this.waiters.push(resolve4);
       });
       if (next === null) return;
       yield next;
@@ -2373,8 +2461,8 @@ var SseTransport = class {
   constructor(opts) {
     this.url = opts.url;
     this.headers = opts.headers ?? {};
-    this.endpointReady = new Promise((resolve2, reject) => {
-      this.resolveEndpoint = resolve2;
+    this.endpointReady = new Promise((resolve4, reject) => {
+      this.resolveEndpoint = resolve4;
       this.rejectEndpoint = reject;
     });
     this.endpointReady.catch(() => void 0);
@@ -2401,8 +2489,8 @@ var SseTransport = class {
         continue;
       }
       if (this.closed) return;
-      const next = await new Promise((resolve2) => {
-        this.waiters.push(resolve2);
+      const next = await new Promise((resolve4) => {
+        this.waiters.push(resolve4);
       });
       if (next === null) return;
       yield next;
@@ -2570,8 +2658,133 @@ function parseMcpSpec(input) {
   return { transport: "stdio", name, command, args };
 }
 
+// src/code/edit-blocks.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync5, unlinkSync as unlinkSync2, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname3, resolve as resolve2 } 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 = [];
+  BLOCK_RE.lastIndex = 0;
+  let m = BLOCK_RE.exec(text);
+  while (m !== null) {
+    out.push({
+      path: m[1].trim(),
+      search: m[2],
+      replace: m[3],
+      offset: m.index
+    });
+    m = BLOCK_RE.exec(text);
+  }
+  return out;
+}
+function applyEditBlock(block, rootDir) {
+  const absRoot = resolve2(rootDir);
+  const absTarget = resolve2(absRoot, block.path);
+  if (absTarget !== absRoot && !absTarget.startsWith(`${absRoot}${sep()}`)) {
+    return {
+      path: block.path,
+      status: "path-escape",
+      message: `resolved path ${absTarget} is outside rootDir ${absRoot}`
+    };
+  }
+  const searchEmpty = block.search.length === 0;
+  const exists = existsSync2(absTarget);
+  try {
+    if (!exists) {
+      if (!searchEmpty) {
+        return {
+          path: block.path,
+          status: "file-missing",
+          message: "file does not exist; to create it, use an empty SEARCH block"
+        };
+      }
+      mkdirSync3(dirname3(absTarget), { recursive: true });
+      writeFileSync3(absTarget, block.replace, "utf8");
+      return { path: block.path, status: "created" };
+    }
+    const content = readFileSync5(absTarget, "utf8");
+    if (searchEmpty) {
+      return {
+        path: block.path,
+        status: "not-found",
+        message: "empty SEARCH only creates new files \u2014 this file already exists"
+      };
+    }
+    const idx = content.indexOf(block.search);
+    if (idx === -1) {
+      return {
+        path: block.path,
+        status: "not-found",
+        message: "SEARCH text does not match the current file content exactly"
+      };
+    }
+    const replaced = `${content.slice(0, idx)}${block.replace}${content.slice(idx + block.search.length)}`;
+    writeFileSync3(absTarget, replaced, "utf8");
+    return { path: block.path, status: "applied" };
+  } catch (err) {
+    return { path: block.path, status: "error", message: err.message };
+  }
+}
+function applyEditBlocks(blocks, rootDir) {
+  return blocks.map((b) => applyEditBlock(b, rootDir));
+}
+function snapshotBeforeEdits(blocks, rootDir) {
+  const absRoot = resolve2(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 = resolve2(absRoot, b.path);
+    if (!existsSync2(abs)) {
+      snapshots.push({ path: b.path, prevContent: null });
+      continue;
+    }
+    try {
+      snapshots.push({ path: b.path, prevContent: readFileSync5(abs, "utf8") });
+    } catch {
+      snapshots.push({ path: b.path, prevContent: null });
+    }
+  }
+  return snapshots;
+}
+function restoreSnapshots(snapshots, rootDir) {
+  const absRoot = resolve2(rootDir);
+  return snapshots.map((snap) => {
+    const abs = resolve2(absRoot, snap.path);
+    if (abs !== absRoot && !abs.startsWith(`${absRoot}${sep()}`)) {
+      return {
+        path: snap.path,
+        status: "path-escape",
+        message: "snapshot path escapes rootDir \u2014 refusing to restore"
+      };
+    }
+    try {
+      if (snap.prevContent === null) {
+        if (existsSync2(abs)) unlinkSync2(abs);
+        return {
+          path: snap.path,
+          status: "applied",
+          message: "removed (the edit had created it)"
+        };
+      }
+      writeFileSync3(abs, snap.prevContent, "utf8");
+      return {
+        path: snap.path,
+        status: "applied",
+        message: "restored to pre-edit content"
+      };
+    } catch (err) {
+      return { path: snap.path, status: "error", message: err.message };
+    }
+  });
+}
+function sep() {
+  return process.platform === "win32" ? "\\" : "/";
+}
+
 // src/index.ts
-var VERSION = "0.3.2";
+var VERSION = "0.4.3";
 
 // src/cli/commands/chat.tsx
 import { render } from "ink";
@@ -2702,8 +2915,39 @@ function parseBlocks(raw) {
       listBuf = null;
     }
   };
-  for (const rawLine of lines) {
+  for (let i = 0; i < lines.length; i++) {
+    const rawLine = lines[i];
     const line = rawLine.replace(/\s+$/g, "");
+    if (!inCode && /^<{7} SEARCH\s*$/.test(line)) {
+      const filename = para.pop()?.trim();
+      if (filename) {
+        flushPara();
+        flushList();
+        let j = i + 1;
+        const searchLines = [];
+        while (j < lines.length && !/^={7}\s*$/.test(lines[j])) {
+          searchLines.push(lines[j]);
+          j++;
+        }
+        const replaceLines = [];
+        let k = j + 1;
+        while (k < lines.length && !/^>{7} REPLACE\s*$/.test(lines[k])) {
+          replaceLines.push(lines[k]);
+          k++;
+        }
+        if (j < lines.length && k < lines.length) {
+          out.push({
+            kind: "edit-block",
+            filename,
+            search: searchLines.join("\n"),
+            replace: replaceLines.join("\n")
+          });
+          i = k;
+          continue;
+        }
+        para.push(filename);
+      }
+    }
     const fence = line.match(/^```(\w*)/);
     if (fence) {
       if (inCode) {
@@ -2781,10 +3025,18 @@ function BlockView({ block }) {
       return /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column" }, block.items.map((item, i) => /* @__PURE__ */ React2.createElement(Box2, { key: `${i}-${item.slice(0, 24)}` }, /* @__PURE__ */ React2.createElement(Text2, { color: "cyan" }, block.ordered ? ` ${block.start + i}. ` : "  \u2022 "), /* @__PURE__ */ React2.createElement(InlineMd, { text: item }))));
     case "code":
       return /* @__PURE__ */ React2.createElement(Box2, { borderStyle: "single", borderColor: "gray", paddingX: 1 }, /* @__PURE__ */ React2.createElement(Text2, { color: "yellow" }, block.text));
+    case "edit-block":
+      return /* @__PURE__ */ React2.createElement(EditBlockRow, { block });
     case "hr":
       return /* @__PURE__ */ React2.createElement(Text2, { 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 EditBlockRow({ block }) {
+  const isNewFile = block.search.length === 0;
+  const searchLines = block.search.split("\n");
+  const replaceLines = block.replace.split("\n");
+  return /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1 }, /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "cyan" }, block.filename), isNewFile ? /* @__PURE__ */ React2.createElement(Text2, { color: "green", bold: true }, " (new file)") : null), isNewFile ? null : /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column", marginTop: 1 }, searchLines.map((line, i) => /* @__PURE__ */ React2.createElement(Text2, { key: `s-${i}-${line.length}`, color: "red" }, `- ${line}`))), /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column", marginTop: isNewFile ? 1 : 0 }, replaceLines.map((line, i) => /* @__PURE__ */ React2.createElement(Text2, { key: `r-${i}-${line.length}`, color: "green" }, `+ ${line}`))));
+}
 function Markdown({ text }) {
   const cleaned = stripMath(text);
   const blocks = React2.useMemo(() => parseBlocks(cleaned), [cleaned]);
@@ -2801,7 +3053,10 @@ var EventRow = React3.memo(function EventRow2({ event }) {
     return /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React3.createElement(Box3, null, /* @__PURE__ */ React3.createElement(Text3, { bold: true, color: "green" }, "assistant")), event.branch ? /* @__PURE__ */ React3.createElement(BranchBlock, { branch: event.branch }) : null, event.reasoning ? /* @__PURE__ */ React3.createElement(ReasoningBlock, { reasoning: event.reasoning }) : null, !isPlanStateEmpty(event.planState) ? /* @__PURE__ */ React3.createElement(PlanStateBlock, { planState: event.planState }) : null, event.text ? /* @__PURE__ */ React3.createElement(Markdown, { text: event.text }) : /* @__PURE__ */ React3.createElement(Text3, { dimColor: true }, "(no content)"), event.stats ? /* @__PURE__ */ React3.createElement(StatsLine, { stats: event.stats }) : null, event.repair ? /* @__PURE__ */ React3.createElement(Text3, { color: "magenta" }, event.repair) : null);
   }
   if (event.role === "tool") {
-    return /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React3.createElement(Text3, { color: "yellow" }, `tool<${event.toolName ?? "?"}>  \u2192`), /* @__PURE__ */ React3.createElement(Text3, { dimColor: true }, " ", truncate2(event.text, 400)));
+    const isError = event.text.startsWith("ERROR:");
+    const color = isError ? "red" : "yellow";
+    const marker = isError ? "\u2717" : "\u2192";
+    return /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React3.createElement(Text3, { color }, `tool<${event.toolName ?? "?"}>  ${marker}`), /* @__PURE__ */ React3.createElement(Text3, { color: isError ? "red" : void 0, dimColor: !isError }, " ", truncate2(event.text, 400)));
   }
   if (event.role === "error") {
     return /* @__PURE__ */ React3.createElement(Box3, { marginTop: 1 }, /* @__PURE__ */ React3.createElement(Text3, { color: "red", bold: true }, "error", " "), /* @__PURE__ */ React3.createElement(Text3, { color: "red" }, event.text));
@@ -2823,9 +3078,9 @@ function BranchBlock({ branch }) {
   return /* @__PURE__ */ React3.createElement(Box3, null, /* @__PURE__ */ React3.createElement(Text3, { color: "blue" }, "\u{1F500} branched ", /* @__PURE__ */ React3.createElement(Text3, { bold: true }, branch.budget), ` samples \u2192 picked #${branch.chosenIndex}   `, /* @__PURE__ */ React3.createElement(Text3, { dimColor: true }, per)));
 }
 function ReasoningBlock({ reasoning }) {
-  const max = 220;
+  const max = 260;
   const flat = reasoning.replace(/\s+/g, " ").trim();
-  const preview = flat.length <= max ? flat : `${flat.slice(0, max)}\u2026 (+${flat.length - max} chars)`;
+  const preview = flat.length <= max ? flat : `\u2026 (+${flat.length - max} earlier chars) ${flat.slice(-max)}`;
   return /* @__PURE__ */ React3.createElement(Box3, { marginBottom: 1 }, /* @__PURE__ */ React3.createElement(Text3, { dimColor: true, italic: true }, "\u21B3 thinking: ", preview));
 }
 function Elapsed() {
@@ -2850,7 +3105,17 @@ function StreamingAssistant({ event }) {
   }
   const tail = lastLine(event.text, 140);
   const reasoningTail = event.reasoning ? lastLine(event.reasoning, 120) : "";
-  return /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React3.createElement(Box3, null, /* @__PURE__ */ React3.createElement(Text3, { bold: true, color: "green" }, "assistant", " "), /* @__PURE__ */ React3.createElement(Text3, { dimColor: true }, "(streaming \xB7 ", event.text.length, event.reasoning ? ` + think ${event.reasoning.length}` : "", " chars)", " "), /* @__PURE__ */ React3.createElement(Elapsed, null)), reasoningTail ? /* @__PURE__ */ React3.createElement(Text3, { dimColor: true, italic: true }, "\u21B3 thinking: ", reasoningTail) : null, tail ? /* @__PURE__ */ React3.createElement(Text3, { dimColor: true }, "\u25B8 ", tail) : /* @__PURE__ */ React3.createElement(Text3, { dimColor: true, italic: true }, "  (waiting for first token\u2026)"));
+  const reasoningOnly = !event.text && !!event.reasoning;
+  return /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React3.createElement(Box3, null, /* @__PURE__ */ React3.createElement(Text3, { bold: true, color: "green" }, "assistant", " "), /* @__PURE__ */ React3.createElement(Pulse, null), /* @__PURE__ */ React3.createElement(Text3, { dimColor: true }, " ", "(", reasoningOnly ? "reasoning" : "streaming", " \xB7 ", event.text.length, event.reasoning ? ` + think ${event.reasoning.length}` : "", " chars)", " "), /* @__PURE__ */ React3.createElement(Elapsed, null)), reasoningTail ? /* @__PURE__ */ React3.createElement(Text3, { dimColor: true, italic: true }, "\u21B3 thinking: ", reasoningTail) : null, tail ? /* @__PURE__ */ React3.createElement(Text3, { dimColor: true }, "\u25B8 ", tail) : reasoningOnly ? /* @__PURE__ */ React3.createElement(Text3, { color: "yellow", dimColor: true }, "  R1 is thinking before it speaks \u2014 body text starts when reasoning completes (typically 20-90s).") : /* @__PURE__ */ React3.createElement(Text3, { dimColor: true, italic: true }, "  (waiting for first byte \u2014 connection is open)"));
+}
+function Pulse() {
+  const [tick, setTick] = useState(0);
+  useEffect(() => {
+    const id = setInterval(() => setTick((t) => t + 1), 500);
+    return () => clearInterval(id);
+  }, []);
+  const frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+  return /* @__PURE__ */ React3.createElement(Text3, { color: "cyan" }, frames[tick % frames.length]);
 }
 function lastLine(s, maxChars) {
   const flat = s.replace(/\s+/g, " ").trim();
@@ -2914,6 +3179,7 @@ function formatTokens(n) {
 }
 
 // src/cli/ui/slash.ts
+import { spawnSync } from "child_process";
 function parseSlash(text) {
   if (!text.startsWith("/")) return null;
   const parts = text.slice(1).trim().split(/\s+/);
@@ -2942,6 +3208,12 @@ function handleSlash(cmd, args, loop, ctx = {}) {
           "  /mcp                     list MCP servers + tools attached to this session",
           "  /setup                   (exit + reconfigure) \u2192 run `reasonix setup`",
           "  /compact [cap]           shrink large tool results in history (default 4k/result)",
+          "  /think                   dump the most recent turn's full R1 reasoning (reasoner only)",
+          "  /retry                   truncate & resend your last message (fresh sample from the model)",
+          "  /apply                   (code mode) commit the pending edit blocks to disk",
+          "  /discard                 (code mode) drop pending edits without writing",
+          "  /undo                    (code mode) roll back the last applied edit batch",
+          '  /commit "msg"            (code mode) git add -A && git commit -m "msg"',
           "  /sessions                list saved sessions (current is marked with \u25B8)",
           "  /forget                  delete the current session from disk",
           "  /clear                   clear displayed history (log + session kept)",
@@ -2983,6 +3255,70 @@ function handleSlash(cmd, args, loop, ctx = {}) {
       return {
         info: "To reconfigure (preset, MCP servers, API key), exit this chat and run `reasonix setup`. Changes take effect on next launch."
       };
+    case "retry": {
+      const prev = loop.retryLastUser();
+      if (!prev) {
+        return {
+          info: "nothing to retry \u2014 no prior user message in this session's log."
+        };
+      }
+      const preview = prev.length > 80 ? `${prev.slice(0, 80)}\u2026` : prev;
+      return {
+        info: `\u25B8 retrying: "${preview}"`,
+        resubmit: prev
+      };
+    }
+    case "think":
+    case "reasoning": {
+      const raw = loop.scratch.reasoning;
+      if (!raw || !raw.trim()) {
+        return {
+          info: "no reasoning cached. `/think` shows the full R1 thought for the most recent turn \u2014 only `deepseek-reasoner` produces it, and only once the turn completes."
+        };
+      }
+      return { info: `\u21B3 full thinking (${raw.length} chars):
+
+${raw.trim()}` };
+    }
+    case "undo": {
+      if (!ctx.codeUndo) {
+        return {
+          info: "/undo is only available inside `reasonix code` \u2014 chat mode doesn't apply edits."
+        };
+      }
+      return { info: ctx.codeUndo() };
+    }
+    case "apply": {
+      if (!ctx.codeApply) {
+        return {
+          info: "/apply is only available inside `reasonix code` (nothing to apply here)."
+        };
+      }
+      return { info: ctx.codeApply() };
+    }
+    case "discard": {
+      if (!ctx.codeDiscard) {
+        return {
+          info: "/discard is only available inside `reasonix code`."
+        };
+      }
+      return { info: ctx.codeDiscard() };
+    }
+    case "commit": {
+      if (!ctx.codeRoot) {
+        return {
+          info: "/commit is only available inside `reasonix code` (needs a rooted git repo)."
+        };
+      }
+      const raw = args.join(" ").trim();
+      const message = stripOuterQuotes(raw);
+      if (!message) {
+        return {
+          info: `usage: /commit "your commit message"  \u2014 runs \`git add -A && git commit -m "\u2026"\` in ${ctx.codeRoot}`
+        };
+      }
+      return runGitCommit(ctx.codeRoot, message);
+    }
     case "compact": {
       const tight = Number.parseInt(args[0] ?? "", 10);
       const cap = Number.isFinite(tight) && tight >= 500 ? tight : 4e3;
@@ -3028,9 +3364,25 @@ function handleSlash(cmd, args, loop, ctx = {}) {
     }
     case "status": {
       const branchBudget = loop.branchOptions.budget ?? 1;
-      return {
-        info: `model=${loop.model}  harvest=${loop.harvestEnabled ? "on" : "off"}  branch=${branchBudget > 1 ? branchBudget : "off"}  stream=${loop.stream ? "on" : "off"}`
-      };
+      const ctxMax = DEEPSEEK_CONTEXT_TOKENS[loop.model] ?? DEFAULT_CONTEXT_TOKENS;
+      const lastPromptTokens = loop.stats.summary().lastPromptTokens;
+      const ctxPct = ctxMax > 0 ? Math.round(lastPromptTokens / ctxMax * 100) : 0;
+      const ctxLine = lastPromptTokens > 0 ? `  ctx    ${compactNum(lastPromptTokens)}/${compactNum(ctxMax)} (${ctxPct}%)` : "  ctx    no turns yet";
+      const pending = ctx.pendingEditCount ?? 0;
+      const sessionLine = loop.sessionName ? `  session "${loop.sessionName}" \xB7 ${loop.log.length} messages in log (resumed ${loop.resumedMessageCount})` : "  session (ephemeral \u2014 no persistence)";
+      const mcpCount = ctx.mcpSpecs?.length ?? 0;
+      const toolCount = loop.prefix.toolSpecs.length;
+      const mcpLine = `  mcp     ${mcpCount} server(s), ${toolCount} tool(s) in registry`;
+      const pendingLine = pending > 0 ? `  edits   ${pending} pending (/apply to commit, /discard to drop)` : "";
+      const lines = [
+        `  model   ${loop.model}`,
+        `  flags   harvest=${loop.harvestEnabled ? "on" : "off"} \xB7 branch=${branchBudget > 1 ? branchBudget : "off"} \xB7 stream=${loop.stream ? "on" : "off"}`,
+        ctxLine,
+        mcpLine,
+        sessionLine
+      ];
+      if (pendingLine) lines.push(pendingLine);
+      return { info: lines.join("\n") };
     }
     case "model": {
       const id = args[0];
@@ -3082,6 +3434,43 @@ function handleSlash(cmd, args, loop, ctx = {}) {
       return { unknown: true, info: `unknown command: /${cmd}  (try /help)` };
   }
 }
+function compactNum(n) {
+  if (n < 1e3) return String(n);
+  const k = n / 1e3;
+  return k >= 100 ? `${Math.round(k)}k` : `${k.toFixed(1)}k`;
+}
+function stripOuterQuotes(s) {
+  if (s.length >= 2 && s.startsWith('"') && s.endsWith('"')) {
+    return s.slice(1, -1);
+  }
+  return s;
+}
+function runGitCommit(rootDir, message) {
+  const add = spawnSync("git", ["add", "-A"], { cwd: rootDir, encoding: "utf8" });
+  if (add.error || add.status !== 0) {
+    return { info: `git add failed (${add.status ?? "?"}):
+${gitTail(add)}` };
+  }
+  const commit = spawnSync("git", ["commit", "-m", message], {
+    cwd: rootDir,
+    encoding: "utf8"
+  });
+  if (commit.error || commit.status !== 0) {
+    return { info: `git commit failed (${commit.status ?? "?"}):
+${gitTail(commit)}` };
+  }
+  const firstLine = (commit.stdout || "").split(/\r?\n/)[0] ?? "";
+  return { info: `\u25B8 committed: ${message}${firstLine ? `
+  ${firstLine}` : ""}` };
+}
+function gitTail(res) {
+  const stderr = res.stderr ?? "";
+  const stdout2 = res.stdout ?? "";
+  const body = stderr.trim() || stdout2.trim();
+  if (body) return body;
+  if (res.error) return res.error.message;
+  return "(no output from git)";
+}
 
 // src/cli/ui/App.tsx
 var FLUSH_INTERVAL_MS = 60;
@@ -3093,7 +3482,8 @@ function App({
   branch,
   session,
   tools,
-  mcpSpecs
+  mcpSpecs,
+  codeMode
 }) {
   const { exit } = useApp();
   const [historical, setHistorical] = useState2([]);
@@ -3101,6 +3491,11 @@ function App({
   const [input, setInput] = useState2("");
   const [busy, setBusy] = useState2(false);
   const abortedThisTurn = useRef(false);
+  const [ongoingTool, setOngoingTool] = useState2(null);
+  const lastEditSnapshots = useRef(null);
+  const pendingEdits = useRef([]);
+  const promptHistory = useRef([]);
+  const historyCursor = useRef(-1);
   const [summary, setSummary] = useState2({
     turns: 0,
     totalCostUsd: 0,
@@ -3169,12 +3564,58 @@ function App({
     }
   }, [session, loop]);
   useInput((_input, key) => {
-    if (!key.escape) return;
-    if (!busy) return;
-    if (abortedThisTurn.current) return;
-    abortedThisTurn.current = true;
-    loop.abort();
+    if (key.escape && busy) {
+      if (abortedThisTurn.current) return;
+      abortedThisTurn.current = true;
+      loop.abort();
+      return;
+    }
+    if (busy) return;
+    const hist = promptHistory.current;
+    if (key.upArrow) {
+      if (hist.length === 0) return;
+      const nextCursor = Math.min(historyCursor.current + 1, hist.length - 1);
+      historyCursor.current = nextCursor;
+      setInput(hist[hist.length - 1 - nextCursor] ?? "");
+      return;
+    }
+    if (key.downArrow) {
+      if (historyCursor.current < 0) return;
+      const nextCursor = historyCursor.current - 1;
+      historyCursor.current = nextCursor;
+      setInput(nextCursor < 0 ? "" : hist[hist.length - 1 - nextCursor] ?? "");
+      return;
+    }
   });
+  const codeUndo = 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 results = restoreSnapshots(snaps, codeMode.rootDir);
+    lastEditSnapshots.current = null;
+    return formatUndoResults(results);
+  }, [codeMode]);
+  const codeApply = useCallback(() => {
+    if (!codeMode) return "not in code mode";
+    const blocks = pendingEdits.current;
+    if (blocks.length === 0) {
+      return "nothing pending \u2014 the assistant hasn't proposed edits since the last /apply or /discard.";
+    }
+    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;
+    pendingEdits.current = [];
+    return formatEditResults(results);
+  }, [codeMode]);
+  const codeDiscard = useCallback(() => {
+    const count = pendingEdits.current.length;
+    if (count === 0) return "nothing pending to discard.";
+    pendingEdits.current = [];
+    return `\u25B8 discarded ${count} pending edit block(s). Nothing was written to disk.`;
+  }, []);
   const prefixHash = loop.prefix.fingerprint;
   const writeTranscript = useCallback(
     (ev) => {
@@ -3186,12 +3627,26 @@ function App({
   );
   const handleSubmit = useCallback(
     async (raw) => {
-      const text = raw.trim();
+      let text = raw.trim();
       if (!text || busy) return;
       setInput("");
+      historyCursor.current = -1;
+      if (codeMode && pendingEdits.current.length > 0 && (text === "y" || text === "n")) {
+        const out = text === "y" ? codeApply() : codeDiscard();
+        setHistorical((prev) => [...prev, { id: `sys-${Date.now()}`, role: "info", text: out }]);
+        promptHistory.current.push(text);
+        return;
+      }
       const slash = parseSlash(text);
       if (slash) {
-        const result = handleSlash(slash.cmd, slash.args, loop, { mcpSpecs });
+        const result = handleSlash(slash.cmd, slash.args, loop, {
+          mcpSpecs,
+          codeUndo: codeMode ? codeUndo : void 0,
+          codeApply: codeMode ? codeApply : void 0,
+          codeDiscard: codeMode ? codeDiscard : void 0,
+          codeRoot: codeMode?.rootDir,
+          pendingEditCount: codeMode ? pendingEdits.current.length : void 0
+        });
         if (result.exit) {
           transcriptRef.current?.end();
           exit();
@@ -3211,8 +3666,14 @@ function App({
             }
           ]);
         }
-        return;
+        if (result.resubmit) {
+          text = result.resubmit;
+        } else {
+          promptHistory.current.push(text);
+          return;
+        }
       }
+      promptHistory.current.push(text);
       setHistorical((prev) => [...prev, { id: `u-${Date.now()}`, role: "user", text }]);
       const assistantId = `a-${Date.now()}`;
       const streamRef = { id: assistantId, text: "", reasoning: "" };
@@ -3263,12 +3724,13 @@ function App({
             flush();
             const repairNote = ev.repair ? describeRepair(ev.repair) : "";
             setStreaming(null);
+            const finalText = ev.content || streamRef.text;
             setHistorical((prev) => [
               ...prev,
               {
                 id: assistantId,
                 role: "assistant",
-                text: ev.content || streamRef.text,
+                text: finalText,
                 reasoning: streamRef.reasoning || void 0,
                 planState: ev.planState,
                 branch: ev.branch,
@@ -3277,8 +3739,25 @@ function App({
                 streaming: false
               }
             ]);
+            if (codeMode && finalText && !ev.forcedSummary) {
+              const blocks = parseEditBlocks(finalText);
+              if (blocks.length > 0) {
+                pendingEdits.current = blocks;
+                setHistorical((prev) => [
+                  ...prev,
+                  {
+                    id: `pending-${Date.now()}`,
+                    role: "info",
+                    text: formatPendingPreview(blocks)
+                  }
+                ]);
+              }
+            }
+          } else if (ev.role === "tool_start") {
+            setOngoingTool({ name: ev.toolName ?? "?", args: ev.toolArgs });
           } else if (ev.role === "tool") {
             flush();
+            setOngoingTool(null);
             setHistorical((prev) => [
               ...prev,
               {
@@ -3304,11 +3783,12 @@ function App({
       } finally {
         clearInterval(timer);
         setStreaming(null);
+        setOngoingTool(null);
         setSummary(loop.stats.summary());
         setBusy(false);
       }
     },
-    [busy, exit, loop, mcpSpecs, writeTranscript]
+    [busy, codeApply, codeDiscard, codeMode, codeUndo, exit, loop, mcpSpecs, writeTranscript]
   );
   return /* @__PURE__ */ React6.createElement(Box6, { flexDirection: "column" }, /* @__PURE__ */ React6.createElement(
     StatsPanel,
@@ -3319,10 +3799,99 @@ function App({
       harvestOn: loop.harvestEnabled,
       branchBudget: loop.branchOptions.budget
     }
-  ), /* @__PURE__ */ React6.createElement(Static, { items: historical }, (item) => /* @__PURE__ */ React6.createElement(EventRow, { key: item.id, event: item })), streaming ? /* @__PURE__ */ React6.createElement(Box6, { marginY: 1 }, /* @__PURE__ */ React6.createElement(EventRow, { event: streaming })) : null, /* @__PURE__ */ React6.createElement(PromptInput, { value: input, onChange: setInput, onSubmit: handleSubmit, disabled: busy }), /* @__PURE__ */ React6.createElement(CommandStrip, null));
+  ), /* @__PURE__ */ React6.createElement(Static, { items: historical }, (item) => /* @__PURE__ */ React6.createElement(EventRow, { key: item.id, event: item })), streaming ? /* @__PURE__ */ React6.createElement(Box6, { marginY: 1 }, /* @__PURE__ */ React6.createElement(EventRow, { event: streaming })) : null, ongoingTool ? /* @__PURE__ */ React6.createElement(OngoingToolRow, { tool: ongoingTool }) : null, /* @__PURE__ */ React6.createElement(PromptInput, { value: input, onChange: setInput, onSubmit: handleSubmit, disabled: busy }), /* @__PURE__ */ React6.createElement(CommandStrip, { codeMode: !!codeMode }));
 }
-function CommandStrip() {
-  return /* @__PURE__ */ React6.createElement(Box6, { paddingX: 2, flexDirection: "column" }, /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, "/help \xB7 /preset ", "<fast|smart|max>", " \xB7 /mcp \xB7 /compact \xB7 /sessions \xB7 /setup \xB7 /clear \xB7 /exit"), /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, "Esc (while thinking) \u2014 abort & summarize what was found so far"));
+function OngoingToolRow({ tool }) {
+  const [tick, setTick] = useState2(0);
+  const [elapsed, setElapsed] = useState2(0);
+  useEffect2(() => {
+    const start = Date.now();
+    const frameId = setInterval(() => setTick((t) => t + 1), 120);
+    const secId = setInterval(() => setElapsed(Math.floor((Date.now() - start) / 1e3)), 1e3);
+    return () => {
+      clearInterval(frameId);
+      clearInterval(secId);
+    };
+  }, []);
+  const frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+  const summary = summarizeToolArgs(tool.name, tool.args);
+  return /* @__PURE__ */ React6.createElement(Box6, { marginY: 1, flexDirection: "column" }, /* @__PURE__ */ React6.createElement(Box6, null, /* @__PURE__ */ React6.createElement(Text6, { color: "cyan" }, frames[tick % frames.length]), /* @__PURE__ */ React6.createElement(Text6, { color: "yellow" }, ` tool<${tool.name}> running\u2026`), /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, ` ${elapsed}s`)), summary ? /* @__PURE__ */ React6.createElement(Box6, { paddingLeft: 2 }, /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, summary)) : null);
+}
+function summarizeToolArgs(name, args) {
+  if (!args || args === "{}") return "";
+  let parsed;
+  try {
+    parsed = JSON.parse(args);
+  } catch {
+    return args.length > 80 ? `${args.slice(0, 80)}\u2026` : args;
+  }
+  const hasSuffix = (s) => name === s || name.endsWith(`_${s}`);
+  const path = typeof parsed.path === "string" ? parsed.path : void 0;
+  if (hasSuffix("read_file")) {
+    const head = typeof parsed.head === "number" ? `, head=${parsed.head}` : "";
+    const tail = typeof parsed.tail === "number" ? `, tail=${parsed.tail}` : "";
+    return `path: ${path ?? "?"}${head}${tail}`;
+  }
+  if (hasSuffix("write_file")) {
+    const content = typeof parsed.content === "string" ? parsed.content : "";
+    return `path: ${path ?? "?"} (${content.length} chars)`;
+  }
+  if (hasSuffix("edit_file")) {
+    const edits = Array.isArray(parsed.edits) ? parsed.edits.length : 0;
+    return `path: ${path ?? "?"} (${edits} edit${edits === 1 ? "" : "s"})`;
+  }
+  if (hasSuffix("list_directory") || hasSuffix("directory_tree")) {
+    return `path: ${path ?? "?"}`;
+  }
+  if (hasSuffix("search_files")) {
+    const pattern = typeof parsed.pattern === "string" ? parsed.pattern : "?";
+    return `path: ${path ?? "?"} \xB7 pattern: ${pattern}`;
+  }
+  if (hasSuffix("move_file")) {
+    const src = typeof parsed.source === "string" ? parsed.source : "?";
+    const dst = typeof parsed.destination === "string" ? parsed.destination : "?";
+    return `${src} \u2192 ${dst}`;
+  }
+  if (hasSuffix("get_file_info")) {
+    return `path: ${path ?? "?"}`;
+  }
+  return args.length > 80 ? `${args.slice(0, 80)}\u2026` : args;
+}
+function CommandStrip({ codeMode }) {
+  return /* @__PURE__ */ React6.createElement(Box6, { paddingX: 2, flexDirection: "column" }, /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, "/help \xB7 /preset ", "<fast|smart|max>", " \xB7 /mcp \xB7 /compact \xB7 /sessions \xB7 /setup \xB7 /clear \xB7 /exit"), codeMode ? /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, 'code mode: /apply (y) \xB7 /discard (n) \xB7 /undo \xB7 /commit "msg" \u2014 edits NEVER write without /apply') : null, /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, "\u2191/\u2193 recall prompts \xB7 /retry re-send last \xB7 /think see R1 full reasoning"), /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, "Esc (while thinking) \u2014 abort & summarize what was found so far"));
+}
+function formatEditResults(results) {
+  const lines = results.map((r) => {
+    const mark = r.status === "applied" || r.status === "created" ? "\u2713" : "\u2717";
+    const detail = r.message ? ` (${r.message})` : "";
+    return `  ${mark} ${r.status.padEnd(11)} ${r.path}${detail}`;
+  });
+  const ok = results.filter((r) => r.status === "applied" || r.status === "created").length;
+  const total = results.length;
+  const header = `\u25B8 edit blocks: ${ok}/${total} applied \u2014 /undo to roll back, or \`git diff\` to review`;
+  return [header, ...lines].join("\n");
+}
+function formatPendingPreview(blocks) {
+  const lines = blocks.map((b) => {
+    const removed = b.search === "" ? 0 : countLines2(b.search);
+    const added = countLines2(b.replace);
+    const tag = b.search === "" ? "NEW " : "    ";
+    return `  ${tag}${b.path}  (-${removed} +${added} lines)`;
+  });
+  const header = `\u25B8 ${blocks.length} pending edit block(s) \u2014 /apply (or y) to commit \xB7 /discard (or n) to drop`;
+  return [header, ...lines].join("\n");
+}
+function countLines2(s) {
+  if (s.length === 0) return 0;
+  return (s.match(/\n/g)?.length ?? 0) + 1;
+}
+function formatUndoResults(results) {
+  const lines = 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 = [];
@@ -3396,7 +3965,8 @@ function Root({ initialKey, tools, mcpSpecs, ...appProps }) {
       branch: appProps.branch,
       session: appProps.session,
       tools,
-      mcpSpecs
+      mcpSpecs,
+      codeMode: appProps.codeMode
     }
   );
 }
@@ -3452,9 +4022,35 @@ async function chatCommand(opts) {
   }
 }
 
+// src/cli/commands/code.tsx
+import { basename, resolve as resolve3 } from "path";
+async function codeCommand(opts = {}) {
+  const { codeSystemPrompt: codeSystemPrompt2 } = await import("./prompt-MMANQ36Z.js");
+  const rootDir = resolve3(opts.dir ?? process.cwd());
+  const session = opts.noSession ? void 0 : `code-${sanitizeName(basename(rootDir))}`;
+  const fsSpec = `filesystem=npx -y @modelcontextprotocol/server-filesystem ${quoteIfNeeded(rootDir)}`;
+  process.stderr.write(
+    `\u25B8 reasonix code: rooted at ${rootDir}, session "${session ?? "(ephemeral)"}"
+`
+  );
+  await chatCommand({
+    model: opts.model ?? "deepseek-reasoner",
+    harvest: true,
+    // smart preset's harvest setting, always on for code
+    system: codeSystemPrompt2(rootDir),
+    transcript: opts.transcript,
+    session,
+    mcp: [fsSpec],
+    codeMode: { rootDir }
+  });
+}
+function quoteIfNeeded(s) {
+  return /\s|"/.test(s) ? `"${s.replace(/"/g, '\\"')}"` : s;
+}
+
 // src/cli/commands/diff.ts
-import { writeFileSync as writeFileSync3 } from "fs";
-import { basename } from "path";
+import { writeFileSync as writeFileSync4 } from "fs";
+import { basename as basename2 } from "path";
 import { render as render2 } from "ink";
 import React11 from "react";
 
@@ -3590,8 +4186,8 @@ async function diffCommand(opts) {
   const aParsed = readTranscript(opts.a);
   const bParsed = readTranscript(opts.b);
   const report = diffTranscripts(
-    { label: opts.labelA ?? basename(opts.a), parsed: aParsed },
-    { label: opts.labelB ?? basename(opts.b), parsed: bParsed }
+    { label: opts.labelA ?? basename2(opts.a), parsed: aParsed },
+    { label: opts.labelB ?? basename2(opts.b), parsed: bParsed }
   );
   const wantMarkdown = !!opts.mdPath;
   const wantPrint = opts.print || !process.stdout.isTTY;
@@ -3599,7 +4195,7 @@ async function diffCommand(opts) {
   if (wantMarkdown) {
     console.log(renderSummaryTable(report));
     const md = renderMarkdown(report);
-    writeFileSync3(opts.mdPath, md, "utf8");
+    writeFileSync4(opts.mdPath, md, "utf8");
     console.log(`
 markdown report written to ${opts.mdPath}`);
     return;
@@ -4408,10 +5004,10 @@ function buildSpec(name, argsByName) {
   const entry = CATALOG_BY_NAME.get(name);
   if (!entry) return name;
   const userArg = entry.userArgs ? argsByName[name] : void 0;
-  const tail = userArg ? ` ${quoteIfNeeded(userArg)}` : "";
+  const tail = userArg ? ` ${quoteIfNeeded2(userArg)}` : "";
   return `${entry.name}=npx -y ${entry.package}${tail}`;
 }
-function quoteIfNeeded(s) {
+function quoteIfNeeded2(s) {
   return /\s|"/.test(s) ? `"${s.replace(/"/g, '\\"')}"` : s;
 }
 
@@ -4439,13 +5035,13 @@ async function setupCommand(_opts = {}) {
 }
 
 // src/cli/commands/stats.ts
-import { existsSync as existsSync2, readFileSync as readFileSync5 } from "fs";
+import { existsSync as existsSync3, readFileSync as readFileSync6 } from "fs";
 function statsCommand(opts) {
-  if (!existsSync2(opts.transcript)) {
+  if (!existsSync3(opts.transcript)) {
     console.error(`no such transcript: ${opts.transcript}`);
     process.exit(1);
   }
-  const lines = readFileSync5(opts.transcript, "utf8").split(/\r?\n/).filter(Boolean);
+  const lines = readFileSync6(opts.transcript, "utf8").split(/\r?\n/).filter(Boolean);
   let assistantTurns = 0;
   let toolCalls = 0;
   let lastTurn = 0;
@@ -4526,6 +5122,16 @@ program.action(async () => {
 program.command("setup").description("Interactive wizard \u2014 API key, preset, MCP servers. Re-run any time to reconfigure.").action(async () => {
   await setupCommand({});
 });
+program.command("code [dir]").description(
+  "Code-editing chat \u2014 filesystem MCP auto-bridged at <dir> (default: cwd), coding system prompt, smart preset. Model proposes SEARCH/REPLACE blocks; Reasonix applies them to disk."
+).option("-m, --model <id>", "Override default reasoner model").option("--no-session", "Disable session persistence for this run").option("--transcript <path>", "Write a JSONL transcript to this path").action(async (dir, opts) => {
+  await codeCommand({
+    dir,
+    model: opts.model,
+    noSession: opts.session === false,
+    transcript: opts.transcript
+  });
+});
 program.command("chat").description("Interactive Ink TUI with live cache/cost panel.").option("-m, --model <id>", "DeepSeek model id (overrides preset)").option("-s, --system <prompt>", "System prompt (pinned in the immutable prefix)", DEFAULT_SYSTEM).option("--transcript <path>", "Write a JSONL transcript to this path").option(
   "--preset <name>",
   "Bundle of model + harvest + branch. One of: fast, smart, max. Overrides config.preset."