reasonix 0.4.1 → 0.4.5

package/dist/cli/index.js

@@ -722,7 +722,19 @@ function scavengeToolCalls(reasoningContent, opts) {
   const max = opts.maxCalls ?? 4;
   const notes = [];
   const out = [];
-  for (const candidate of iterateJsonObjects(reasoningContent)) {
+  for (const invoke of iterateDsmlInvokes(reasoningContent)) {
+    if (out.length >= max) break;
+    if (!opts.allowedNames.has(invoke.name)) continue;
+    out.push({
+      function: {
+        name: invoke.name,
+        arguments: JSON.stringify(invoke.args)
+      }
+    });
+    notes.push(`scavenged DSML call: ${invoke.name}`);
+  }
+  const nonDsml = stripDsmlBlocks(reasoningContent);
+  for (const candidate of iterateJsonObjects(nonDsml)) {
     if (out.length >= max) break;
     const call = coerceToToolCall(candidate, opts.allowedNames);
     if (call) {
@@ -732,6 +744,40 @@ function scavengeToolCalls(reasoningContent, opts) {
   }
   return { calls: out, notes };
 }
+function stripDsmlBlocks(text) {
+  let out = text;
+  out = out.replace(/<[｜|]DSML[｜|]function_calls>[\s\S]*?<\/?[｜|]DSML[｜|]function_calls>/g, "");
+  out = out.replace(/<[｜|]DSML[｜|]invoke\s+[^>]*>[\s\S]*?<\/[｜|]DSML[｜|]invoke>/g, "");
+  return out;
+}
+function* iterateDsmlInvokes(text) {
+  const INVOKE_RE = /<[｜|]DSML[｜|]invoke\s+name="([^"]+)">([\s\S]*?)<\/[｜|]DSML[｜|]invoke>/g;
+  for (const match of text.matchAll(INVOKE_RE)) {
+    const name = match[1];
+    const body = match[2];
+    if (!name || body === void 0) continue;
+    yield { name, args: parseDsmlParameters(body) };
+  }
+}
+function parseDsmlParameters(body) {
+  const PARAM_RE = /<[｜|]DSML[｜|]parameter\s+name="([^"]+)"(?:\s+string="(true|false)")?\s*>([\s\S]*?)<\/[｜|]DSML[｜|]parameter>/g;
+  const args = {};
+  for (const m of body.matchAll(PARAM_RE)) {
+    const key = m[1];
+    const stringFlag = m[2];
+    const raw = (m[3] ?? "").trim();
+    if (!key) continue;
+    if (stringFlag === "false") {
+      try {
+        args[key] = JSON.parse(raw);
+        continue;
+      } catch {
+      }
+    }
+    args[key] = raw;
+  }
+  return args;
+}
 function* iterateJsonObjects(text) {
   for (let i = 0; i < text.length; i++) {
     if (text[i] !== "{") continue;
@@ -917,14 +963,15 @@ var ToolCallRepair = class {
     this.opts = opts;
     this.storm = new StormBreaker(opts.stormWindow ?? 6, opts.stormThreshold ?? 3);
   }
-  process(declaredCalls, reasoningContent) {
+  process(declaredCalls, reasoningContent, content = null) {
     const report = {
       scavenged: 0,
       truncationsFixed: 0,
       stormsBroken: 0,
       notes: []
     };
-    const scavenged = scavengeToolCalls(reasoningContent, {
+    const combined = [reasoningContent ?? "", content ?? ""].filter(Boolean).join("\n");
+    const scavenged = scavengeToolCalls(combined || null, {
       allowedNames: this.opts.allowedToolNames,
       maxCalls: this.opts.maxScavenge ?? 4
     });
@@ -1283,6 +1330,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();
@@ -1296,9 +1376,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)`
+        };
+        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* this.forceSummaryAfterIterLimit({ reason: "aborted" });
+        yield { turn: this._turn, role: "done", content: stoppedMsg };
         return;
       }
       if (!warnedForIterBudget && iter >= warnAt) {
@@ -1461,7 +1549,8 @@ var CacheFirstLoop = class {
       const planState = preHarvestedPlanState ? preHarvestedPlanState : this.harvestEnabled ? await harvest(reasoningContent || null, this.client, this.harvestOptions) : emptyPlanState();
       const { calls: repairedCalls, report } = this.repair.process(
         toolCalls,
-        reasoningContent || null
+        reasoningContent || null,
+        assistantContent || null
       );
       this.appendAndPersist(this.assistantMessage(assistantContent, repairedCalls));
       yield {
@@ -1520,12 +1609,18 @@ 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 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}
 
@@ -1566,6 +1661,14 @@ ${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") {
@@ -2191,7 +2294,12 @@ var McpClient = class {
     this.startReaderIfNeeded();
     const result = await this.request("initialize", {
       protocolVersion: MCP_PROTOCOL_VERSION,
-      capabilities: { tools: {} },
+      // Advertise every method the client can consume so servers know
+      // they can send listChanged notifications etc. Sub-feature flags
+      // (e.g. `resources.subscribe`) are omitted — we don't implement
+      // those yet and the empty object means "method-level support, no
+      // sub-features."
+      capabilities: { tools: {}, resources: {}, prompts: {} },
       clientInfo: this.clientInfo
     });
     this._serverCapabilities = result.capabilities ?? {};
@@ -2215,6 +2323,45 @@ var McpClient = class {
       arguments: args ?? {}
     });
   }
+  /**
+   * List resources the server exposes. Supports a pagination cursor;
+   * callers interested in the full set should loop on `nextCursor`.
+   * Servers that don't support resources respond with method-not-found
+   * (−32601) — we surface that as a thrown Error so callers can gate
+   * on the `serverCapabilities.resources` field first.
+   */
+  async listResources(cursor) {
+    this.assertInitialized();
+    return this.request("resources/list", {
+      ...cursor ? { cursor } : {}
+    });
+  }
+  /** Read the contents of a resource by URI. */
+  async readResource(uri) {
+    this.assertInitialized();
+    return this.request("resources/read", {
+      uri
+    });
+  }
+  /** List prompt templates the server exposes. */
+  async listPrompts(cursor) {
+    this.assertInitialized();
+    return this.request("prompts/list", {
+      ...cursor ? { cursor } : {}
+    });
+  }
+  /**
+   * Fetch a rendered prompt by name. `args` supplies values for any
+   * required template arguments; the server validates. Returns messages
+   * ready to prepend to the model's input.
+   */
+  async getPrompt(name, args) {
+    this.assertInitialized();
+    return this.request("prompts/get", {
+      name,
+      ...args ? { arguments: args } : {}
+    });
+  }
   /** Close the transport and reject any outstanding requests. */
   async close() {
     for (const [, pending] of this.pending) {
@@ -2729,7 +2876,7 @@ function sep() {
 }
 
 // src/index.ts
-var VERSION = "0.4.1";
+var VERSION = "0.4.3";
 
 // src/cli/commands/chat.tsx
 import { render } from "ink";
@@ -2998,7 +3145,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));
@@ -3020,9 +3170,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() {
@@ -3150,6 +3300,9 @@ 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)",
+          "  /tool [N]                list tool calls (or dump full output of #N, 1=most recent)",
+          "  /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",
@@ -3195,6 +3348,63 @@ 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 "tool": {
+      const history = ctx.toolHistory?.() ?? [];
+      if (history.length === 0) {
+        return {
+          info: "no tool calls yet in this session. `/tool` lists them once the model has actually used a tool; `/tool N` dumps the full (untruncated) output of the Nth-most-recent."
+        };
+      }
+      const raw = (args[0] ?? "").toLowerCase();
+      if (raw === "" || raw === "list" || raw === "ls") {
+        return { info: formatToolList(history) };
+      }
+      const n = Number.parseInt(raw, 10);
+      if (!Number.isFinite(n) || n < 1) {
+        return {
+          info: "usage: /tool [N]   (no arg \u2192 list; N=1 \u2192 most recent result in full, N=2 \u2192 previous, \u2026)"
+        };
+      }
+      if (n > history.length) {
+        return {
+          info: `only ${history.length} tool call(s) in history \u2014 asked for #${n}. Try /tool with no arg to see the list.`
+        };
+      }
+      const entry = history[history.length - n];
+      if (!entry) {
+        return { info: `could not read tool call #${n}` };
+      }
+      return {
+        info: `\u21B3 tool<${entry.toolName}> #${n} (${entry.text.length} chars):
+
+${entry.text}`
+      };
+    }
     case "undo": {
       if (!ctx.codeUndo) {
         return {
@@ -3279,9 +3489,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];
@@ -3333,6 +3559,34 @@ function handleSlash(cmd, args, loop, ctx = {}) {
       return { unknown: true, info: `unknown command: /${cmd}  (try /help)` };
   }
 }
+function formatToolList(history) {
+  const total = history.length;
+  const header = `Tool calls in this session (${total}, most recent first):`;
+  const shown = Math.min(total, 10);
+  const lines = [header];
+  for (let i = 0; i < shown; i++) {
+    const entry = history[total - 1 - i];
+    if (!entry) continue;
+    const idx = i + 1;
+    const flat = entry.text.replace(/\s+/g, " ").trim();
+    const preview = flat.length > 80 ? `${flat.slice(0, 80)}\u2026` : flat;
+    const name = entry.toolName.length > 24 ? `${entry.toolName.slice(0, 23)}\u2026` : entry.toolName;
+    lines.push(
+      `  #${String(idx).padStart(2)}  ${name.padEnd(24)}  ${String(entry.text.length).padStart(6)} chars  ${preview}`
+    );
+  }
+  if (total > shown) {
+    lines.push(`  \u2026 (${total - shown} earlier, reach with /tool N)`);
+  }
+  lines.push("");
+  lines.push("View full output: /tool N   (N=1 \u2192 most recent)");
+  return lines.join("\n");
+}
+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);
@@ -3388,6 +3642,9 @@ function App({
   const [ongoingTool, setOngoingTool] = useState2(null);
   const lastEditSnapshots = useRef(null);
   const pendingEdits = useRef([]);
+  const promptHistory = useRef([]);
+  const historyCursor = useRef(-1);
+  const toolHistoryRef = useRef([]);
   const [summary, setSummary] = useState2({
     turns: 0,
     totalCostUsd: 0,
@@ -3456,11 +3713,28 @@ 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";
@@ -3502,9 +3776,16 @@ 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, {
@@ -3512,7 +3793,9 @@ function App({
           codeUndo: codeMode ? codeUndo : void 0,
           codeApply: codeMode ? codeApply : void 0,
           codeDiscard: codeMode ? codeDiscard : void 0,
-          codeRoot: codeMode?.rootDir
+          codeRoot: codeMode?.rootDir,
+          pendingEditCount: codeMode ? pendingEdits.current.length : void 0,
+          toolHistory: () => toolHistoryRef.current
         });
         if (result.exit) {
           transcriptRef.current?.end();
@@ -3533,8 +3816,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: "" };
@@ -3619,6 +3908,10 @@ function App({
           } else if (ev.role === "tool") {
             flush();
             setOngoingTool(null);
+            toolHistoryRef.current.push({
+              toolName: ev.toolName ?? "?",
+              text: ev.content
+            });
             setHistorical((prev) => [
               ...prev,
               {
@@ -3664,16 +3957,62 @@ function App({
 }
 function OngoingToolRow({ tool }) {
   const [tick, setTick] = useState2(0);
+  const [elapsed, setElapsed] = useState2(0);
   useEffect2(() => {
-    const id = setInterval(() => setTick((t) => t + 1), 120);
-    return () => clearInterval(id);
+    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 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);
+  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 \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"));
+  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 reasoning \xB7 /tool N full tool output"), /* @__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) => {
@@ -3693,7 +4032,7 @@ function formatPendingPreview(blocks) {
     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`;
+  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) {