reasonix 0.3.1 → 0.4.1

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);
@@ -1155,12 +1156,18 @@ var CacheFirstLoop = class {
   resumedMessageCount;
   _turn = 0;
   _streamPreference;
+  /**
+   * Set by {@link abort} to short-circuit the tool-call loop after the
+   * current iteration. Reset at the start of each `step()` so an Esc
+   * during one turn doesn't poison the next.
+   */
+  _aborted = false;
   constructor(opts) {
     this.client = opts.client;
     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") {
@@ -1266,12 +1273,42 @@ var CacheFirstLoop = class {
     if (pendingUser !== null) msgs.push({ role: "user", content: pendingUser });
     return msgs;
   }
+  /**
+   * Signal the currently-running {@link step} that the user wants to
+   * stop exploring. Takes effect at the next iteration boundary — if a
+   * tool call is mid-flight it will be allowed to finish, then the
+   * loop diverts to the forced-summary path so the user gets an
+   * answer instead of a cliff. Called by the TUI on Esc.
+   */
+  abort() {
+    this._aborted = true;
+  }
   async *step(userInput) {
     this._turn++;
     this.scratch.reset();
+    this._aborted = false;
     let pendingUser = userInput;
     const toolSpecs = this.prefix.tools();
+    const warnAt = Math.max(1, Math.floor(this.maxToolIters * 0.7));
+    let warnedForIterBudget = false;
     for (let iter = 0; iter < this.maxToolIters; iter++) {
+      if (this._aborted) {
+        yield {
+          turn: this._turn,
+          role: "warning",
+          content: `aborted at iter ${iter}/${this.maxToolIters} \u2014 forcing summary from what was gathered`
+        };
+        yield* this.forceSummaryAfterIterLimit({ reason: "aborted" });
+        return;
+      }
+      if (!warnedForIterBudget && iter >= warnAt) {
+        warnedForIterBudget = true;
+        yield {
+          turn: this._turn,
+          role: "warning",
+          content: `${iter}/${this.maxToolIters} tool calls used \u2014 approaching budget. Press Esc to force a summary now.`
+        };
+      }
       const messages = this.buildMessages(pendingUser);
       let assistantContent = "";
       let reasoningContent = "";
@@ -1319,8 +1356,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,
@@ -1440,9 +1477,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",
@@ -1459,9 +1515,9 @@ var CacheFirstLoop = class {
         };
       }
     }
-    yield* this.forceSummaryAfterIterLimit();
+    yield* this.forceSummaryAfterIterLimit({ reason: "budget" });
   }
-  async *forceSummaryAfterIterLimit() {
+  async *forceSummaryAfterIterLimit(opts = { reason: "budget" }) {
     try {
       const messages = this.buildMessages(null);
       const resp = await this.client.chat({
@@ -1470,7 +1526,8 @@ var CacheFirstLoop = class {
         // 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 annotated = `[tool-call budget (${this.maxToolIters}) reached \u2014 forcing summary from what I found]
+      const reasonPrefix = reasonPrefixFor(opts.reason, this.maxToolIters);
+      const annotated = `${reasonPrefix}
 
 ${summary}`;
       const summaryStats = this.stats.record(this._turn, this.model, resp.usage ?? new Usage());
@@ -1479,15 +1536,17 @@ ${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 = errorLabelFor(opts.reason, this.maxToolIters);
       yield {
         turn: this._turn,
         role: "error",
         content: "",
-        error: `tool-call budget (${this.maxToolIters}) reached and the fallback summary call failed: ${err.message}. Run /clear and retry with a narrower question, or pass --max-tool-iters higher.`
+        error: `${label} and the fallback summary call failed: ${err.message}. Run /clear and retry with a narrower question, or raise --max-tool-iters.`
       };
       yield { turn: this._turn, role: "done", content: "" };
     }
@@ -1507,6 +1566,18 @@ ${summary}`;
     return msg;
   }
 };
+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,
@@ -2160,7 +2231,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(
@@ -2168,7 +2239,7 @@ var McpClient = class {
         );
       }, this.requestTimeoutMs);
       this.pending.set(id, {
-        resolve: resolve2,
+        resolve: resolve4,
         reject,
         timeout
       });
@@ -2252,12 +2323,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();
       });
     });
   }
@@ -2268,8 +2339,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;
@@ -2335,8 +2406,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);
@@ -2363,8 +2434,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;
@@ -2532,15 +2603,140 @@ 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.1";
+var VERSION = "0.4.1";
 
 // src/cli/commands/chat.tsx
 import { render } from "ink";
 import React8, { useState as useState4 } from "react";
 
 // src/cli/ui/App.tsx
-import { Box as Box6, Static, Text as Text6, useApp } from "ink";
+import { Box as Box6, Static, Text as Text6, useApp, useInput } from "ink";
 import React6, { useCallback, useEffect as useEffect2, useMemo, useRef, useState as useState2 } from "react";
 
 // src/cli/ui/EventLog.tsx
@@ -2664,8 +2860,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) {
@@ -2743,10 +2970,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]);
@@ -2771,6 +3006,9 @@ var EventRow = React3.memo(function EventRow2({ event }) {
   if (event.role === "info") {
     return /* @__PURE__ */ React3.createElement(Box3, null, /* @__PURE__ */ React3.createElement(Text3, { dimColor: true }, event.text));
   }
+  if (event.role === "warning") {
+    return /* @__PURE__ */ React3.createElement(Box3, null, /* @__PURE__ */ React3.createElement(Text3, { color: "yellow" }, "\u25B8 "), /* @__PURE__ */ React3.createElement(Text3, { color: "yellow" }, event.text));
+  }
   return /* @__PURE__ */ React3.createElement(Box3, null, /* @__PURE__ */ React3.createElement(Text3, null, event.text));
 });
 function BranchBlock({ branch }) {
@@ -2809,7 +3047,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();
@@ -2873,6 +3121,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+/);
@@ -2901,6 +3150,10 @@ 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)",
+          "  /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)",
@@ -2942,6 +3195,45 @@ 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 "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;
@@ -3041,6 +3333,38 @@ function handleSlash(cmd, args, loop, ctx = {}) {
       return { unknown: true, info: `unknown command: /${cmd}  (try /help)` };
   }
 }
+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;
@@ -3052,13 +3376,18 @@ function App({
   branch,
   session,
   tools,
-  mcpSpecs
+  mcpSpecs,
+  codeMode
 }) {
   const { exit } = useApp();
   const [historical, setHistorical] = useState2([]);
   const [streaming, setStreaming] = useState2(null);
   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 [summary, setSummary] = useState2({
     turns: 0,
     totalCostUsd: 0,
@@ -3126,6 +3455,42 @@ function App({
       ]);
     }
   }, [session, loop]);
+  useInput((_input, key) => {
+    if (!key.escape) return;
+    if (!busy) return;
+    if (abortedThisTurn.current) return;
+    abortedThisTurn.current = true;
+    loop.abort();
+  });
+  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) => {
@@ -3142,7 +3507,13 @@ function App({
       setInput("");
       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
+        });
         if (result.exit) {
           transcriptRef.current?.end();
           exit();
@@ -3171,6 +3542,7 @@ function App({
       const reasoningBuf = { current: "" };
       setStreaming({ id: assistantId, role: "assistant", text: "", streaming: true });
       setBusy(true);
+      abortedThisTurn.current = false;
       const flush = () => {
         if (!contentBuf.current && !reasoningBuf.current) return;
         streamRef.text += contentBuf.current;
@@ -3213,12 +3585,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,
@@ -3227,8 +3600,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,
               {
@@ -3243,17 +3633,23 @@ function App({
               ...prev,
               { id: `e-${Date.now()}`, role: "error", text: ev.error ?? ev.content }
             ]);
+          } else if (ev.role === "warning") {
+            setHistorical((prev) => [
+              ...prev,
+              { id: `w-${Date.now()}-${Math.random()}`, role: "warning", text: ev.content }
+            ]);
           }
         }
         flush();
       } 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,
@@ -3264,10 +3660,53 @@ 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 }, /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, "/help \xB7 /preset ", "<fast|smart|max>", " \xB7 /mcp \xB7 /compact \xB7 /sessions \xB7 /setup \xB7 /clear \xB7 /exit"));
+function OngoingToolRow({ tool }) {
+  const [tick, setTick] = useState2(0);
+  useEffect2(() => {
+    const id = setInterval(() => setTick((t) => t + 1), 120);
+    return () => clearInterval(id);
+  }, []);
+  const frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+  const argsPreview = tool.args && tool.args.length > 0 && tool.args !== "{}" ? `  ${tool.args.length > 60 ? `${tool.args.slice(0, 60)}\u2026` : tool.args}` : "";
+  return /* @__PURE__ */ React6.createElement(Box6, { marginY: 1 }, /* @__PURE__ */ React6.createElement(Text6, { color: "cyan" }, frames[tick % frames.length]), /* @__PURE__ */ React6.createElement(Text6, { color: "yellow" }, ` tool<${tool.name}> running\u2026`), argsPreview ? /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, argsPreview) : null);
+}
+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 \xB7 /discard \xB7 /undo \xB7 /commit "msg" \u2014 edits NEVER write without /apply') : null, /* @__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 to commit to disk, /discard 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 = [];
@@ -3341,7 +3780,8 @@ function Root({ initialKey, tools, mcpSpecs, ...appProps }) {
       branch: appProps.branch,
       session: appProps.session,
       tools,
-      mcpSpecs
+      mcpSpecs,
+      codeMode: appProps.codeMode
     }
   );
 }
@@ -3397,14 +3837,40 @@ 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";
 
 // src/cli/ui/DiffApp.tsx
-import { Box as Box9, Static as Static2, Text as Text9, useApp as useApp3, useInput } from "ink";
+import { Box as Box9, Static as Static2, Text as Text9, useApp as useApp3, useInput as useInput2 } from "ink";
 import React10, { useState as useState5 } from "react";
 
 // src/cli/ui/RecordView.tsx
@@ -3449,7 +3915,7 @@ function DiffApp({ report }) {
   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] = useState5(Math.max(0, initialIdx));
-  useInput((input, key) => {
+  useInput2((input, key) => {
     if (input === "q" || key.ctrl && input === "c") {
       exit();
       return;
@@ -3535,8 +4001,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;
@@ -3544,7 +4010,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;
@@ -3629,13 +4095,13 @@ import { render as render3 } from "ink";
 import React13 from "react";
 
 // src/cli/ui/ReplayApp.tsx
-import { Box as Box10, Static as Static3, Text as Text10, useApp as useApp4, useInput as useInput2 } from "ink";
+import { Box as Box10, Static as Static3, Text as Text10, useApp as useApp4, useInput as useInput3 } from "ink";
 import React12, { useMemo as useMemo2, useState as useState6 } from "react";
 function ReplayApp({ meta, pages }) {
   const { exit } = useApp4();
   const maxIdx = Math.max(0, pages.length - 1);
   const [idx, setIdx] = useState6(maxIdx);
-  useInput2((input, key) => {
+  useInput3((input, key) => {
     if (input === "q" || key.ctrl && input === "c") {
       exit();
       return;
@@ -3990,12 +4456,12 @@ import { render as render4 } from "ink";
 import React16 from "react";
 
 // src/cli/ui/Wizard.tsx
-import { Box as Box12, Text as Text12, useApp as useApp5, useInput as useInput4 } from "ink";
+import { Box as Box12, Text as Text12, useApp as useApp5, useInput as useInput5 } from "ink";
 import TextInput3 from "ink-text-input";
 import React15, { useState as useState8 } from "react";
 
 // src/cli/ui/Select.tsx
-import { Box as Box11, Text as Text11, useInput as useInput3 } from "ink";
+import { Box as Box11, Text as Text11, useInput as useInput4 } from "ink";
 import React14, { useState as useState7 } from "react";
 function SingleSelect({
   items,
@@ -4008,7 +4474,7 @@ function SingleSelect({
     items.findIndex((i) => i.value === initialValue && !i.disabled)
   );
   const [index, setIndex] = useState7(initialIndex === -1 ? 0 : initialIndex);
-  useInput3((_input, key) => {
+  useInput4((_input, key) => {
     if (key.upArrow) {
       setIndex((i) => findNextEnabled(items, i, -1));
     } else if (key.downArrow) {
@@ -4042,7 +4508,7 @@ function MultiSelect({
     return first === -1 ? 0 : first;
   });
   const [selected, setSelected] = useState7(new Set(initialSelected));
-  useInput3((input, key) => {
+  useInput4((input, key) => {
     if (key.upArrow) {
       setIndex((i) => findNextEnabled(items, i, -1));
     } else if (key.downArrow) {
@@ -4128,7 +4594,7 @@ function Wizard({ onComplete, onCancel, existingApiKey, initial }) {
     catalogArgs: {}
   });
   const [error, setError] = useState8(null);
-  useInput4((_input, key) => {
+  useInput5((_input, key) => {
     if (key.escape && step !== "saved" && onCancel) onCancel();
   });
   if (step === "apiKey") {
@@ -4290,13 +4756,13 @@ function McpArgsStep({
   )), error ? /* @__PURE__ */ React15.createElement(Box12, { marginTop: 1 }, /* @__PURE__ */ React15.createElement(Text12, { color: "red" }, error)) : null));
 }
 function ReviewConfirm({ onConfirm }) {
-  useInput4((_i, key) => {
+  useInput5((_i, key) => {
     if (key.return) onConfirm();
   });
   return null;
 }
 function ExitOnEnter({ onExit }) {
-  useInput4((_i, key) => {
+  useInput5((_i, key) => {
     if (key.return) onExit();
   });
   return null;
@@ -4353,10 +4819,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;
 }
 
@@ -4384,13 +4850,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;
@@ -4471,6 +4937,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."