reasonix 0.4.6 → 0.4.12

package/dist/cli/index.js

@@ -96,8 +96,8 @@ function computeWait(attempt, initial, cap, retryAfter) {
 }
 function sleep(ms, signal) {
   if (ms <= 0) return Promise.resolve();
-  return new Promise((resolve4, reject) => {
-    const timer = setTimeout(resolve4, ms);
+  return new Promise((resolve5, reject) => {
+    const timer = setTimeout(resolve5, ms);
     if (signal) {
       const onAbort = () => {
         clearTimeout(timer);
@@ -182,6 +182,27 @@ var DeepSeekClient = class {
     if (opts.responseFormat) payload.response_format = opts.responseFormat;
     return payload;
   }
+  /**
+   * Fetch the current DeepSeek account balance. Separate endpoint
+   * from chat completions, no billing impact. Returns null on any
+   * network/auth failure so callers can gate the balance display
+   * without a hard error — the rest of the session works regardless.
+   */
+  async getBalance(opts = {}) {
+    try {
+      const resp = await this._fetch(`${this.baseUrl}/user/balance`, {
+        method: "GET",
+        headers: { Authorization: `Bearer ${this.apiKey}` },
+        signal: opts.signal
+      });
+      if (!resp.ok) return null;
+      const data = await resp.json();
+      if (!data || !Array.isArray(data.balance_infos)) return null;
+      return data;
+    } catch {
+      return null;
+    }
+  }
   async chat(opts) {
     const ctrl = new AbortController();
     const timer = setTimeout(() => ctrl.abort(), this.timeoutMs);
@@ -328,8 +349,9 @@ Constraints:
 - Each item is plain text, at most {maxItemLen} characters, no markdown.
 - Write in the same language as the trace (Chinese in \u2192 Chinese out, etc.).
 - Do not quote back the trace; write short, specific phrases.`;
-async function harvest(reasoningContent, client, options = {}) {
+async function harvest(reasoningContent, client, options = {}, signal) {
   if (!client || !reasoningContent) return emptyPlanState();
+  if (signal?.aborted) return emptyPlanState();
   const minLen = options.minReasoningLen ?? 40;
   const trimmed = reasoningContent.trim();
   if (trimmed.length < minLen) return emptyPlanState();
@@ -349,7 +371,8 @@ async function harvest(reasoningContent, client, options = {}) {
       ],
       responseFormat: { type: "json_object" },
       temperature: 0,
-      maxTokens: 600
+      maxTokens: 600,
+      signal
     });
     return parsePlanState(resp.content, maxItems, maxItemLen);
   } catch {
@@ -563,7 +586,7 @@ var ToolRegistry = class {
       }
     }));
   }
-  async dispatch(name, argumentsRaw) {
+  async dispatch(name, argumentsRaw, opts = {}) {
     const tool = this._tools.get(name);
     if (!tool) {
       return JSON.stringify({ error: `unknown tool: ${name}` });
@@ -580,7 +603,7 @@ var ToolRegistry = class {
       args = nestArguments(args);
     }
     try {
-      const result = await tool.fn(args);
+      const result = await tool.fn(args, { signal: opts.signal });
       return typeof result === "string" ? result : JSON.stringify(result);
     } catch (err) {
       return JSON.stringify({
@@ -614,8 +637,20 @@ async function bridgeMcpTools(client, opts = {}) {
       name: registeredName,
       description: mcpTool.description ?? "",
       parameters: mcpTool.inputSchema,
-      fn: async (args) => {
-        const toolResult = await client.callTool(mcpTool.name, args);
+      fn: async (args, ctx) => {
+        const toolResult = await client.callTool(mcpTool.name, args, {
+          // Forward server-side progress frames to the bridge caller,
+          // tagged with the registered name so multi-server UIs can
+          // disambiguate. No-op when `onProgress` isn't configured —
+          // the client then also omits the _meta.progressToken and
+          // the server won't emit progress.
+          onProgress: opts.onProgress ? (info) => opts.onProgress({ toolName: registeredName, ...info }) : void 0,
+          // Thread the tool-dispatch AbortSignal all the way down to
+          // the MCP request so Esc truly cancels in flight — the
+          // client will emit notifications/cancelled AND reject the
+          // pending promise immediately, no "wait for subprocess".
+          signal: ctx?.signal
+        });
         return flattenMcpResult(toolResult, { maxChars: maxResultChars });
       }
     });
@@ -1126,6 +1161,16 @@ function costUsd(model, usage) {
   if (!p) return 0;
   return (usage.promptCacheHitTokens * p.inputCacheHit + usage.promptCacheMissTokens * p.inputCacheMiss + usage.completionTokens * p.output) / 1e6;
 }
+function inputCostUsd(model, usage) {
+  const p = DEEPSEEK_PRICING[model];
+  if (!p) return 0;
+  return (usage.promptCacheHitTokens * p.inputCacheHit + usage.promptCacheMissTokens * p.inputCacheMiss) / 1e6;
+}
+function outputCostUsd(model, usage) {
+  const p = DEEPSEEK_PRICING[model];
+  if (!p) return 0;
+  return usage.completionTokens * p.output / 1e6;
+}
 function claudeEquivalentCost(usage) {
   return (usage.promptTokens * CLAUDE_SONNET_PRICING.input + usage.completionTokens * CLAUDE_SONNET_PRICING.output) / 1e6;
 }
@@ -1153,6 +1198,12 @@ var SessionStats = class {
     const c = this.totalClaudeEquivalent;
     return c > 0 ? 1 - this.totalCost / c : 0;
   }
+  get totalInputCost() {
+    return this.turns.reduce((sum, t) => sum + inputCostUsd(t.model, t.usage), 0);
+  }
+  get totalOutputCost() {
+    return this.turns.reduce((sum, t) => sum + outputCostUsd(t.model, t.usage), 0);
+  }
   get aggregateCacheHitRatio() {
     let hit = 0;
     let miss = 0;
@@ -1168,6 +1219,8 @@ var SessionStats = class {
     return {
       turns: this.turns.length,
       totalCostUsd: round(this.totalCost, 6),
+      totalInputCostUsd: round(this.totalInputCost, 6),
+      totalOutputCostUsd: round(this.totalOutputCost, 6),
       claudeEquivalentUsd: round(this.totalClaudeEquivalent, 6),
       savingsVsClaudePct: round(this.savingsVsClaude * 100, 2),
       cacheHitRatio: round(this.aggregateCacheHitRatio, 4),
@@ -1204,11 +1257,13 @@ var CacheFirstLoop = class {
   _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.
+   * AbortController per active turn. Threaded through the DeepSeek
+   * HTTP calls AND every tool dispatch so Esc actually cancels the
+   * in-flight network/subprocess work — not "we'll get to it after
+   * the current call finishes." Re-created at the start of each
+   * `step()` (the prior turn's signal has already fired).
    */
-  _aborted = false;
+  _turnAbort = new AbortController();
   constructor(opts) {
     this.client = opts.client;
     this.prefix = opts.prefix;
@@ -1240,8 +1295,12 @@ var CacheFirstLoop = class {
       for (const msg of messages) this.log.append(msg);
       this.resumedMessageCount = messages.length;
       if (healedCount > 0) {
+        try {
+          rewriteSession(this.sessionName, messages);
+        } catch {
+        }
         process.stderr.write(
-          `\u25B8 session "${this.sessionName}": healed ${healedCount} oversized tool result(s) (was ${healedFrom.toLocaleString()} chars total). Old payloads were truncated to fit DeepSeek's context window; the conversation is preserved.
+          `\u25B8 session "${this.sessionName}": healed ${healedCount} entr${healedCount === 1 ? "y" : "ies"}${healedFrom > 0 ? ` (was ${healedFrom.toLocaleString()} chars oversized)` : " (dropped dangling tool_calls tail)"}. Rewrote session file.
 `
         );
       }
@@ -1262,7 +1321,7 @@ var CacheFirstLoop = class {
    */
   compact(tightCapChars = 4e3) {
     const before = this.log.toMessages();
-    const { messages, healedCount, healedFrom } = healLoadedMessages(before, tightCapChars);
+    const { messages, healedCount, healedFrom } = shrinkOversizedToolResults(before, tightCapChars);
     const afterBytes = messages.filter((m) => m.role === "tool").reduce((s, m) => s + (typeof m.content === "string" ? m.content.length : 0), 0);
     const charsSaved = healedFrom - afterBytes;
     if (healedCount > 0) {
@@ -1285,6 +1344,29 @@ var CacheFirstLoop = class {
       }
     }
   }
+  /**
+   * Start a fresh conversation WITHOUT exiting. Drops every message
+   * in the in-memory log AND rewrites the session file to empty so
+   * a resume won't re-hydrate the old turns. Unlike `/forget`, which
+   * deletes the session entirely, this keeps the session name and
+   * config intact — it's the "new chat" button.
+   *
+   * The immutable prefix (system prompt + tool specs) is preserved
+   * — that's the cache-first invariant, not part of the conversation.
+   * Returns the number of messages dropped so the UI can show it.
+   */
+  clearLog() {
+    const dropped = this.log.length;
+    this.log.compactInPlace([]);
+    if (this.sessionName) {
+      try {
+        rewriteSession(this.sessionName, []);
+      } catch {
+      }
+    }
+    this.scratch.reset();
+    return { dropped };
+  }
   /**
    * Reconfigure model/harvest/branch/stream mid-session. The loop's log,
    * scratch, and stats are preserved — only the per-turn behavior changes.
@@ -1316,19 +1398,21 @@ var CacheFirstLoop = class {
     this.stream = this.branchEnabled ? false : this._streamPreference;
   }
   buildMessages(pendingUser) {
-    const msgs = [...this.prefix.toMessages(), ...this.log.toMessages()];
+    const healed = healLoadedMessages(this.log.toMessages(), DEFAULT_MAX_RESULT_CHARS);
+    const msgs = [...this.prefix.toMessages(), ...healed.messages];
     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.
+   * Signal the currently-running {@link step} to stop **now**. Cancels
+   * the in-flight network request (DeepSeek HTTP/SSE) AND any tool call
+   * currently dispatching (MCP `notifications/cancelled` + promise
+   * reject). The loop itself also sees `signal.aborted` at each
+   * iteration boundary and exits quickly instead of looping again.
+   * Called by the TUI on Esc.
    */
   abort() {
-    this._aborted = true;
+    this._turnAbort.abort();
   }
   /**
    * Drop everything in the log after (and including) the most recent
@@ -1366,13 +1450,14 @@ var CacheFirstLoop = class {
   async *step(userInput) {
     this._turn++;
     this.scratch.reset();
-    this._aborted = false;
+    this._turnAbort = new AbortController();
+    const signal = this._turnAbort.signal;
     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) {
+      if (signal.aborted) {
         yield {
           turn: this._turn,
           role: "warning",
@@ -1389,6 +1474,13 @@ var CacheFirstLoop = class {
         yield { turn: this._turn, role: "done", content: stoppedMsg };
         return;
       }
+      if (iter > 0) {
+        yield {
+          turn: this._turn,
+          role: "status",
+          content: "tool result uploaded \xB7 model thinking before next response\u2026"
+        };
+      }
       if (!warnedForIterBudget && iter >= warnAt) {
         warnedForIterBudget = true;
         yield {
@@ -1435,7 +1527,8 @@ var CacheFirstLoop = class {
             {
               model: this.model,
               messages,
-              tools: toolSpecs.length ? toolSpecs : void 0
+              tools: toolSpecs.length ? toolSpecs : void 0,
+              signal
             },
             {
               ...this.branchOptions,
@@ -1444,8 +1537,8 @@ var CacheFirstLoop = class {
             }
           );
           for (let k = 0; k < budget; k++) {
-            const sample = queue.shift() ?? await new Promise((resolve4) => {
-              waiter = resolve4;
+            const sample = queue.shift() ?? await new Promise((resolve5) => {
+              waiter = resolve5;
             });
             yield {
               turn: this._turn,
@@ -1485,7 +1578,8 @@ var CacheFirstLoop = class {
           for await (const chunk of this.client.stream({
             model: this.model,
             messages,
-            tools: toolSpecs.length ? toolSpecs : void 0
+            tools: toolSpecs.length ? toolSpecs : void 0,
+            signal
           })) {
             if (chunk.contentDelta) {
               assistantContent += chunk.contentDelta;
@@ -1524,7 +1618,8 @@ var CacheFirstLoop = class {
           const resp = await this.client.chat({
             model: this.model,
             messages,
-            tools: toolSpecs.length ? toolSpecs : void 0
+            tools: toolSpecs.length ? toolSpecs : void 0,
+            signal
           });
           assistantContent = resp.content;
           reasoningContent = resp.reasoningContent ?? "";
@@ -1546,7 +1641,14 @@ var CacheFirstLoop = class {
         pendingUser = null;
       }
       this.scratch.reasoning = reasoningContent || null;
-      const planState = preHarvestedPlanState ? preHarvestedPlanState : this.harvestEnabled ? await harvest(reasoningContent || null, this.client, this.harvestOptions) : emptyPlanState();
+      if (!preHarvestedPlanState && this.harvestEnabled && (reasoningContent?.trim().length ?? 0) >= 40) {
+        yield {
+          turn: this._turn,
+          role: "status",
+          content: "extracting plan state from reasoning\u2026"
+        };
+      }
+      const planState = preHarvestedPlanState ? preHarvestedPlanState : this.harvestEnabled ? await harvest(reasoningContent || null, this.client, this.harvestOptions, signal) : emptyPlanState();
       const { calls: repairedCalls, report } = this.repair.process(
         toolCalls,
         reasoningContent || null,
@@ -1568,15 +1670,38 @@ var CacheFirstLoop = class {
       }
       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;
+        const before = usage.promptTokens;
+        const compactResult = this.compact(4e3);
+        if (compactResult.healedCount > 0) {
+          const approxSaved = Math.round(compactResult.charsSaved / 4);
+          const after = before - approxSaved;
+          yield {
+            turn: this._turn,
+            role: "warning",
+            content: `context ${before.toLocaleString()}/${ctxMax.toLocaleString()} \u2014 auto-compacted ${compactResult.healedCount} oversized tool result(s), saved ~${approxSaved.toLocaleString()} tokens (now ~${after.toLocaleString()}). Continuing.`
+          };
+        } else {
+          yield {
+            turn: this._turn,
+            role: "warning",
+            content: `context ${before.toLocaleString()}/${ctxMax.toLocaleString()} (${Math.round(
+              before / ctxMax * 100
+            )}%) \u2014 nothing to auto-compact. Forcing summary from what was gathered.`
+          };
+          const tail = this.log.entries[this.log.entries.length - 1];
+          if (tail && tail.role === "assistant" && Array.isArray(tail.tool_calls) && tail.tool_calls.length > 0) {
+            const kept = this.log.entries.slice(0, -1);
+            this.log.compactInPlace([...kept]);
+            if (this.sessionName) {
+              try {
+                rewriteSession(this.sessionName, kept);
+              } catch {
+              }
+            }
+          }
+          yield* this.forceSummaryAfterIterLimit({ reason: "context-guard" });
+          return;
+        }
       }
       for (const call of repairedCalls) {
         const name = call.function?.name ?? "";
@@ -1588,7 +1713,7 @@ var CacheFirstLoop = class {
           toolName: name,
           toolArgs: args
         };
-        const result = await this.tools.dispatch(name, args);
+        const result = await this.tools.dispatch(name, args, { signal });
         this.appendAndPersist({
           role: "tool",
           tool_call_id: call.id ?? "",
@@ -1608,6 +1733,11 @@ var CacheFirstLoop = class {
   }
   async *forceSummaryAfterIterLimit(opts = { reason: "budget" }) {
     try {
+      yield {
+        turn: this._turn,
+        role: "status",
+        content: "summarizing what was gathered\u2026"
+      };
       const messages = this.buildMessages(null);
       messages.push({
         role: "user",
@@ -1615,8 +1745,9 @@ var CacheFirstLoop = class {
       });
       const resp = await this.client.chat({
         model: this.model,
-        messages
+        messages,
         // no tools → model is forced to answer in text
+        signal: this._turnAbort.signal
       });
       const rawContent = resp.content?.trim() ?? "";
       const cleaned = stripHallucinatedToolMarkup(rawContent);
@@ -1689,7 +1820,7 @@ function summarizeBranch(chosen, samples) {
     temperatures: samples.map((s) => s.temperature)
   };
 }
-function healLoadedMessages(messages, maxChars) {
+function shrinkOversizedToolResults(messages, maxChars) {
   let healedCount = 0;
   let healedFrom = 0;
   const out = messages.map((msg) => {
@@ -1702,6 +1833,51 @@ function healLoadedMessages(messages, maxChars) {
   });
   return { messages: out, healedCount, healedFrom };
 }
+function healLoadedMessages(messages, maxChars) {
+  const shrunk = shrinkOversizedToolResults(messages, maxChars);
+  let healedCount = shrunk.healedCount;
+  const out = [];
+  const openCallIds = /* @__PURE__ */ new Set();
+  let droppedAssistantCalls = 0;
+  let droppedStrayTools = 0;
+  for (let i = 0; i < shrunk.messages.length; i++) {
+    const msg = shrunk.messages[i];
+    if (msg.role === "assistant" && Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0) {
+      const needed = /* @__PURE__ */ new Set();
+      for (const call of msg.tool_calls) {
+        if (call?.id) needed.add(call.id);
+      }
+      const candidates = [];
+      let j = i + 1;
+      while (j < shrunk.messages.length && needed.size > 0) {
+        const nxt = shrunk.messages[j];
+        if (nxt.role !== "tool") break;
+        const id = nxt.tool_call_id ?? "";
+        if (!needed.has(id)) break;
+        needed.delete(id);
+        candidates.push(nxt);
+        j++;
+      }
+      if (needed.size === 0) {
+        out.push(msg);
+        for (const r of candidates) out.push(r);
+        i = j - 1;
+      } else {
+        droppedAssistantCalls += 1;
+        droppedStrayTools += candidates.length;
+        i = j - 1;
+      }
+      continue;
+    }
+    if (msg.role === "tool") {
+      droppedStrayTools += 1;
+      continue;
+    }
+    out.push(msg);
+  }
+  healedCount += droppedAssistantCalls + droppedStrayTools;
+  return { messages: out, healedCount, healedFrom: shrunk.healedFrom };
+}
 function formatLoopError(err) {
   const msg = err.message ?? "";
   if (msg.includes("maximum context length")) {
@@ -1712,13 +1888,348 @@ function formatLoopError(err) {
   return msg;
 }
 
+// src/tools/filesystem.ts
+import { promises as fs } from "fs";
+import * as pathMod from "path";
+var DEFAULT_MAX_READ_BYTES = 2 * 1024 * 1024;
+var DEFAULT_MAX_LIST_BYTES = 256 * 1024;
+function registerFilesystemTools(registry, opts) {
+  const rootDir = pathMod.resolve(opts.rootDir);
+  const allowWriting = opts.allowWriting !== false;
+  const maxReadBytes = opts.maxReadBytes ?? DEFAULT_MAX_READ_BYTES;
+  const maxListBytes = opts.maxListBytes ?? DEFAULT_MAX_LIST_BYTES;
+  const safePath = (raw) => {
+    if (typeof raw !== "string" || raw.length === 0) {
+      throw new Error("path must be a non-empty string");
+    }
+    const resolved = pathMod.resolve(rootDir, raw);
+    const normRoot = pathMod.resolve(rootDir);
+    const rel = pathMod.relative(normRoot, resolved);
+    if (rel.startsWith("..") || pathMod.isAbsolute(rel)) {
+      throw new Error(`path escapes sandbox root (${normRoot}): ${raw}`);
+    }
+    return resolved;
+  };
+  registry.register({
+    name: "read_file",
+    description: "Read a file under the sandbox root. Returns the full contents (truncated with a notice if larger than the per-call cap). Paths may be relative to the root or absolute-under-root.",
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Path to read (relative to rootDir or absolute)." },
+        head: { type: "integer", description: "If set, return only the first N lines." },
+        tail: { type: "integer", description: "If set, return only the last N lines." }
+      },
+      required: ["path"]
+    },
+    fn: async (args) => {
+      const abs = safePath(args.path);
+      const stat = await fs.stat(abs);
+      if (stat.isDirectory()) {
+        throw new Error(`not a file: ${args.path} (it's a directory)`);
+      }
+      const raw = await fs.readFile(abs);
+      if (raw.length > maxReadBytes) {
+        const head = raw.slice(0, maxReadBytes).toString("utf8");
+        return `${head}
+
+[\u2026truncated ${raw.length - maxReadBytes} bytes \u2014 file is ${raw.length} B, cap ${maxReadBytes} B. Retry with head/tail for targeted view.]`;
+      }
+      const text = raw.toString("utf8");
+      if (typeof args.head === "number" && args.head > 0) {
+        return text.split(/\r?\n/).slice(0, args.head).join("\n");
+      }
+      if (typeof args.tail === "number" && args.tail > 0) {
+        let lines = text.split(/\r?\n/);
+        if (lines.length > 0 && lines[lines.length - 1] === "") lines = lines.slice(0, -1);
+        return lines.slice(Math.max(0, lines.length - args.tail)).join("\n");
+      }
+      return text;
+    }
+  });
+  registry.register({
+    name: "list_directory",
+    description: "List entries in a directory under the sandbox root. Returns one line per entry, marking directories with a trailing slash. Not recursive \u2014 use directory_tree for that.",
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Directory to list (default: root)." }
+      }
+    },
+    fn: async (args) => {
+      const abs = safePath(args.path ?? ".");
+      const entries = await fs.readdir(abs, { withFileTypes: true });
+      const lines = [];
+      for (const e of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+        lines.push(e.isDirectory() ? `${e.name}/` : e.name);
+      }
+      return lines.join("\n") || "(empty directory)";
+    }
+  });
+  registry.register({
+    name: "directory_tree",
+    description: "Recursively list entries in a directory. Shows indented tree structure with directories marked '/'. Caps output so a huge tree doesn't drown the context.",
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Root of the tree (default: sandbox root)." },
+        maxDepth: { type: "integer", description: "Max recursion depth (default 4)." }
+      }
+    },
+    fn: async (args) => {
+      const startAbs = safePath(args.path ?? ".");
+      const maxDepth = typeof args.maxDepth === "number" ? args.maxDepth : 4;
+      const lines = [];
+      let totalBytes = 0;
+      let truncated = false;
+      const walk2 = async (dir, depth) => {
+        if (truncated) return;
+        if (depth > maxDepth) return;
+        let entries;
+        try {
+          entries = await fs.readdir(dir, { withFileTypes: true });
+        } catch {
+          return;
+        }
+        entries.sort((a, b) => a.name.localeCompare(b.name));
+        for (const e of entries) {
+          if (truncated) return;
+          const indent = "  ".repeat(depth);
+          const line = e.isDirectory() ? `${indent}${e.name}/` : `${indent}${e.name}`;
+          totalBytes += line.length + 1;
+          if (totalBytes > maxListBytes) {
+            lines.push(`  [\u2026 tree truncated at ${maxListBytes} bytes \u2026]`);
+            truncated = true;
+            return;
+          }
+          lines.push(line);
+          if (e.isDirectory()) {
+            await walk2(pathMod.join(dir, e.name), depth + 1);
+          }
+        }
+      };
+      await walk2(startAbs, 0);
+      return lines.join("\n") || "(empty tree)";
+    }
+  });
+  registry.register({
+    name: "search_files",
+    description: "Find files whose NAME matches a substring or regex. Case-insensitive. Walks the directory recursively under the sandbox root. Returns one path per line.",
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Directory to start the search at (default: root)." },
+        pattern: {
+          type: "string",
+          description: "Substring (or regex) to match against filenames."
+        }
+      },
+      required: ["pattern"]
+    },
+    fn: async (args) => {
+      const startAbs = safePath(args.path ?? ".");
+      const needle = args.pattern.toLowerCase();
+      let re = null;
+      try {
+        re = new RegExp(args.pattern, "i");
+      } catch {
+        re = null;
+      }
+      const matches = [];
+      let totalBytes = 0;
+      const walk2 = async (dir) => {
+        let entries;
+        try {
+          entries = await fs.readdir(dir, { withFileTypes: true });
+        } catch {
+          return;
+        }
+        for (const e of entries) {
+          const full = pathMod.join(dir, e.name);
+          const lower = e.name.toLowerCase();
+          const hit = re ? re.test(e.name) : lower.includes(needle);
+          if (hit) {
+            const rel = pathMod.relative(rootDir, full);
+            if (totalBytes + rel.length + 1 > maxListBytes) {
+              matches.push("[\u2026 search truncated \u2014 refine pattern \u2026]");
+              return;
+            }
+            matches.push(rel);
+            totalBytes += rel.length + 1;
+          }
+          if (e.isDirectory()) await walk2(full);
+        }
+      };
+      await walk2(startAbs);
+      return matches.length === 0 ? "(no matches)" : matches.join("\n");
+    }
+  });
+  registry.register({
+    name: "get_file_info",
+    description: "Stat a path under the sandbox root. Returns type (file|directory|symlink), size in bytes, mtime in ISO-8601.",
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string" }
+      },
+      required: ["path"]
+    },
+    fn: async (args) => {
+      const abs = safePath(args.path);
+      const st = await fs.lstat(abs);
+      const type = st.isDirectory() ? "directory" : st.isSymbolicLink() ? "symlink" : "file";
+      return JSON.stringify({
+        type,
+        size: st.size,
+        mtime: st.mtime.toISOString()
+      });
+    }
+  });
+  if (!allowWriting) return registry;
+  registry.register({
+    name: "write_file",
+    description: "Create or overwrite a file under the sandbox root with the given content. Parent directories are created as needed.",
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string" },
+        content: { type: "string" }
+      },
+      required: ["path", "content"]
+    },
+    fn: async (args) => {
+      const abs = safePath(args.path);
+      await fs.mkdir(pathMod.dirname(abs), { recursive: true });
+      await fs.writeFile(abs, args.content, "utf8");
+      return `wrote ${args.content.length} chars to ${pathMod.relative(rootDir, abs)}`;
+    }
+  });
+  registry.register({
+    name: "edit_file",
+    description: "Apply a SEARCH/REPLACE edit to an existing file. `search` must match exactly (whitespace sensitive) \u2014 no regex. The match must be unique in the file; otherwise the edit is refused to avoid surprise rewrites. This flat-string shape replaces the `{oldText, newText}[]` JSON array form that previously triggered R1 DSML hallucinations.",
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string" },
+        search: { type: "string", description: "Exact text to find (must be unique)." },
+        replace: { type: "string", description: "Text to substitute in place of `search`." }
+      },
+      required: ["path", "search", "replace"]
+    },
+    fn: async (args) => {
+      const abs = safePath(args.path);
+      const before = await fs.readFile(abs, "utf8");
+      if (args.search.length === 0) {
+        throw new Error("edit_file: search cannot be empty");
+      }
+      const firstIdx = before.indexOf(args.search);
+      if (firstIdx < 0) {
+        throw new Error(`edit_file: search text not found in ${pathMod.relative(rootDir, abs)}`);
+      }
+      const nextIdx = before.indexOf(args.search, firstIdx + 1);
+      if (nextIdx >= 0) {
+        throw new Error(
+          `edit_file: search text appears multiple times in ${pathMod.relative(rootDir, abs)} \u2014 include more context to disambiguate`
+        );
+      }
+      const after = before.slice(0, firstIdx) + args.replace + before.slice(firstIdx + args.search.length);
+      await fs.writeFile(abs, after, "utf8");
+      const rel = pathMod.relative(rootDir, abs);
+      const header = `edited ${rel} (${args.search.length}\u2192${args.replace.length} chars)`;
+      const startLine = before.slice(0, firstIdx).split(/\r?\n/).length;
+      const diff = renderEditDiff(args.search, args.replace, startLine);
+      return `${header}
+${diff}`;
+    }
+  });
+  registry.register({
+    name: "create_directory",
+    description: "Create a directory (and any missing parents) under the sandbox root.",
+    parameters: {
+      type: "object",
+      properties: { path: { type: "string" } },
+      required: ["path"]
+    },
+    fn: async (args) => {
+      const abs = safePath(args.path);
+      await fs.mkdir(abs, { recursive: true });
+      return `created ${pathMod.relative(rootDir, abs)}/`;
+    }
+  });
+  registry.register({
+    name: "move_file",
+    description: "Rename/move a file or directory under the sandbox root.",
+    parameters: {
+      type: "object",
+      properties: {
+        source: { type: "string" },
+        destination: { type: "string" }
+      },
+      required: ["source", "destination"]
+    },
+    fn: async (args) => {
+      const src = safePath(args.source);
+      const dst = safePath(args.destination);
+      await fs.mkdir(pathMod.dirname(dst), { recursive: true });
+      await fs.rename(src, dst);
+      return `moved ${pathMod.relative(rootDir, src)} \u2192 ${pathMod.relative(rootDir, dst)}`;
+    }
+  });
+  return registry;
+}
+function renderEditDiff(search, replace, startLine) {
+  const a = search.split(/\r?\n/);
+  const b = replace.split(/\r?\n/);
+  const diff = lineDiff(a, b);
+  const hunk = `@@ -${startLine},${a.length} +${startLine},${b.length} @@`;
+  const body = diff.map((d) => `${d.op === " " ? " " : d.op} ${d.line}`).join("\n");
+  return `${hunk}
+${body}`;
+}
+function lineDiff(a, b) {
+  const n = a.length;
+  const m = b.length;
+  const dp = Array.from({ length: n + 1 }, () => new Array(m + 1).fill(0));
+  for (let i2 = 1; i2 <= n; i2++) {
+    for (let j2 = 1; j2 <= m; j2++) {
+      if (a[i2 - 1] === b[j2 - 1]) dp[i2][j2] = dp[i2 - 1][j2 - 1] + 1;
+      else dp[i2][j2] = Math.max(dp[i2 - 1][j2], dp[i2][j2 - 1]);
+    }
+  }
+  const out = [];
+  let i = n;
+  let j = m;
+  while (i > 0 && j > 0) {
+    if (a[i - 1] === b[j - 1]) {
+      out.unshift({ op: " ", line: a[i - 1] });
+      i--;
+      j--;
+    } else if ((dp[i - 1][j] ?? 0) > (dp[i][j - 1] ?? 0)) {
+      out.unshift({ op: "-", line: a[i - 1] });
+      i--;
+    } else {
+      out.unshift({ op: "+", line: b[j - 1] });
+      j--;
+    }
+  }
+  while (i > 0) {
+    out.unshift({ op: "-", line: a[i - 1] });
+    i--;
+  }
+  while (j > 0) {
+    out.unshift({ op: "+", line: b[j - 1] });
+    j--;
+  }
+  return out;
+}
+
 // src/env.ts
 import { readFileSync as readFileSync3 } from "fs";
-import { resolve } from "path";
+import { resolve as resolve2 } from "path";
 function loadDotenv(path = ".env") {
   let raw;
   try {
-    raw = readFileSync3(resolve(process.cwd(), path), "utf8");
+    raw = readFileSync3(resolve2(process.cwd(), path), "utf8");
   } catch {
     return;
   }
@@ -1896,6 +2407,8 @@ function computeReplayStats(records) {
 }
 function summarizeTurns(turns) {
   const totalCost = turns.reduce((s, t) => s + t.cost, 0);
+  const totalInput = turns.reduce((s, t) => s + inputCostUsd(t.model, t.usage), 0);
+  const totalOutput = turns.reduce((s, t) => s + outputCostUsd(t.model, t.usage), 0);
   const totalClaude = turns.reduce((s, t) => s + claudeEquivalentCost(t.usage), 0);
   let hit = 0;
   let miss = 0;
@@ -1909,6 +2422,8 @@ function summarizeTurns(turns) {
   return {
     turns: turns.length,
     totalCostUsd: round2(totalCost, 6),
+    totalInputCostUsd: round2(totalInput, 6),
+    totalOutputCostUsd: round2(totalOutput, 6),
     claudeEquivalentUsd: round2(totalClaude, 6),
     savingsVsClaudePct: round2(savingsVsClaude * 100, 2),
     cacheHitRatio: round2(cacheHitRatio, 4),
@@ -2279,6 +2794,13 @@ var McpClient = class {
   _serverInfo = { name: "", version: "" };
   _protocolVersion = "";
   _instructions;
+  // Progress-token → handler for notifications/progress routing. Tokens
+  // are minted per call when the caller supplies an onProgress
+  // callback; cleared when the final response lands (or the pending
+  // request rejects). No leaks — the `try/finally` in callTool
+  // guarantees cleanup even on timeout.
+  progressHandlers = /* @__PURE__ */ new Map();
+  nextProgressToken = 1;
   constructor(opts) {
     this.transport = opts.transport;
     this.clientInfo = opts.clientInfo ?? { name: "reasonix", version: "0.3.0-dev" };
@@ -2333,13 +2855,36 @@ var McpClient = class {
     this.assertInitialized();
     return this.request("tools/list", {});
   }
-  /** Invoke a tool by name. Returns the raw MCP result (caller unwraps content). */
-  async callTool(name, args) {
+  /**
+   * Invoke a tool by name. When `onProgress` is supplied, attaches a
+   * fresh progress token so the server can send incremental updates
+   * via `notifications/progress`; they're routed to the callback until
+   * the final response arrives (or the request times out, in which
+   * case the handler is simply dropped — no extra notification).
+   *
+   * When `signal` is supplied, aborting it:
+   *   1) fires `notifications/cancelled` to the server (MCP 2024-11-05
+   *      way of saying "forget this request, I no longer care"), and
+   *   2) rejects the pending promise immediately with an AbortError,
+   *      so the caller doesn't have to wait for the subprocess to
+   *      finish its in-flight file write or network request.
+   * The server MAY still emit a late response; we drop it in dispatch
+   * since the request id is gone from `pending`.
+   */
+  async callTool(name, args, opts = {}) {
     this.assertInitialized();
-    return this.request("tools/call", {
-      name,
-      arguments: args ?? {}
-    });
+    const params = { name, arguments: args ?? {} };
+    let token;
+    if (opts.onProgress) {
+      token = this.nextProgressToken++;
+      this.progressHandlers.set(token, opts.onProgress);
+      params._meta = { progressToken: token };
+    }
+    try {
+      return await this.request("tools/call", params, opts.signal);
+    } finally {
+      if (token !== void 0) this.progressHandlers.delete(token);
+    }
   }
   /**
    * List resources the server exposes. Supports a pagination cursor;
@@ -2393,24 +2938,56 @@ var McpClient = class {
   assertInitialized() {
     if (!this.initialized) throw new Error("MCP client not initialized \u2014 call initialize() first");
   }
-  async request(method, params) {
+  async request(method, params, signal) {
     const id = this.nextId++;
     const frame = { jsonrpc: "2.0", id, method, params };
-    const promise = new Promise((resolve4, reject) => {
+    let abortHandler = null;
+    const promise = new Promise((resolve5, reject) => {
       const timeout = setTimeout(() => {
         this.pending.delete(id);
+        if (abortHandler && signal) signal.removeEventListener("abort", abortHandler);
         reject(
           new Error(`MCP request ${method} (id=${id}) timed out after ${this.requestTimeoutMs}ms`)
         );
       }, this.requestTimeoutMs);
       this.pending.set(id, {
-        resolve: resolve4,
+        resolve: resolve5,
         reject,
         timeout
       });
+      if (signal) {
+        if (signal.aborted) {
+          this.pending.delete(id);
+          clearTimeout(timeout);
+          reject(new Error(`MCP request ${method} (id=${id}) aborted before send`));
+          return;
+        }
+        abortHandler = () => {
+          this.pending.delete(id);
+          clearTimeout(timeout);
+          void this.transport.send({
+            jsonrpc: "2.0",
+            method: "notifications/cancelled",
+            params: { requestId: id, reason: "aborted by user" }
+          }).catch(() => {
+          });
+          reject(new Error(`MCP request ${method} (id=${id}) aborted by user`));
+        };
+        signal.addEventListener("abort", abortHandler, { once: true });
+      }
     });
-    await this.transport.send(frame);
-    return promise;
+    try {
+      await this.transport.send(frame);
+    } catch (err) {
+      this.pending.delete(id);
+      if (abortHandler && signal) signal.removeEventListener("abort", abortHandler);
+      throw err;
+    }
+    try {
+      return await promise;
+    } finally {
+      if (abortHandler && signal) signal.removeEventListener("abort", abortHandler);
+    }
   }
   startReaderIfNeeded() {
     if (this.readerStarted) return;
@@ -2431,7 +3008,16 @@ var McpClient = class {
     }
   }
   dispatch(msg) {
-    if (!("id" in msg) || msg.id === null || msg.id === void 0) return;
+    if (!("id" in msg) || msg.id === null || msg.id === void 0) {
+      if ("method" in msg && msg.method === "notifications/progress") {
+        const p = msg.params;
+        if (!p || p.progressToken === void 0) return;
+        const handler = this.progressHandlers.get(p.progressToken);
+        if (!handler) return;
+        handler({ progress: p.progress, total: p.total, message: p.message });
+      }
+      return;
+    }
     if (!("result" in msg) && !("error" in msg)) return;
     const pending = this.pending.get(msg.id);
     if (!pending) return;
@@ -2488,12 +3074,12 @@ var StdioTransport = class {
   }
   async send(message) {
     if (this.closed) throw new Error("MCP transport is closed");
-    return new Promise((resolve4, reject) => {
+    return new Promise((resolve5, reject) => {
       const line = `${JSON.stringify(message)}
 `;
       this.child.stdin.write(line, "utf8", (err) => {
         if (err) reject(err);
-        else resolve4();
+        else resolve5();
       });
     });
   }
@@ -2504,8 +3090,8 @@ var StdioTransport = class {
         continue;
       }
       if (this.closed) return;
-      const next = await new Promise((resolve4) => {
-        this.waiters.push(resolve4);
+      const next = await new Promise((resolve5) => {
+        this.waiters.push(resolve5);
       });
       if (next === null) return;
       yield next;
@@ -2571,8 +3157,8 @@ var SseTransport = class {
   constructor(opts) {
     this.url = opts.url;
     this.headers = opts.headers ?? {};
-    this.endpointReady = new Promise((resolve4, reject) => {
-      this.resolveEndpoint = resolve4;
+    this.endpointReady = new Promise((resolve5, reject) => {
+      this.resolveEndpoint = resolve5;
       this.rejectEndpoint = reject;
     });
     this.endpointReady.catch(() => void 0);
@@ -2599,8 +3185,8 @@ var SseTransport = class {
         continue;
       }
       if (this.closed) return;
-      const next = await new Promise((resolve4) => {
-        this.waiters.push(resolve4);
+      const next = await new Promise((resolve5) => {
+        this.waiters.push(resolve5);
       });
       if (next === null) return;
       yield next;
@@ -2800,7 +3386,7 @@ async function trySection(load) {
 
 // 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";
+import { dirname as dirname4, resolve as resolve3 } 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 = [];
@@ -2818,8 +3404,8 @@ function parseEditBlocks(text) {
   return out;
 }
 function applyEditBlock(block, rootDir) {
-  const absRoot = resolve2(rootDir);
-  const absTarget = resolve2(absRoot, block.path);
+  const absRoot = resolve3(rootDir);
+  const absTarget = resolve3(absRoot, block.path);
   if (absTarget !== absRoot && !absTarget.startsWith(`${absRoot}${sep()}`)) {
     return {
       path: block.path,
@@ -2838,7 +3424,7 @@ function applyEditBlock(block, rootDir) {
           message: "file does not exist; to create it, use an empty SEARCH block"
         };
       }
-      mkdirSync3(dirname3(absTarget), { recursive: true });
+      mkdirSync3(dirname4(absTarget), { recursive: true });
       writeFileSync3(absTarget, block.replace, "utf8");
       return { path: block.path, status: "created" };
     }
@@ -2869,13 +3455,13 @@ function applyEditBlocks(blocks, rootDir) {
   return blocks.map((b) => applyEditBlock(b, rootDir));
 }
 function snapshotBeforeEdits(blocks, rootDir) {
-  const absRoot = resolve2(rootDir);
+  const absRoot = resolve3(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);
+    const abs = resolve3(absRoot, b.path);
     if (!existsSync2(abs)) {
       snapshots.push({ path: b.path, prevContent: null });
       continue;
@@ -2889,9 +3475,9 @@ function snapshotBeforeEdits(blocks, rootDir) {
   return snapshots;
 }
 function restoreSnapshots(snapshots, rootDir) {
-  const absRoot = resolve2(rootDir);
+  const absRoot = resolve3(rootDir);
   return snapshots.map((snap) => {
-    const abs = resolve2(absRoot, snap.path);
+    const abs = resolve3(absRoot, snap.path);
     if (abs !== absRoot && !abs.startsWith(`${absRoot}${sep()}`)) {
       return {
         path: snap.path,
@@ -2928,11 +3514,11 @@ var VERSION = "0.4.3";
 
 // src/cli/commands/chat.tsx
 import { render } from "ink";
-import React9, { useState as useState4 } from "react";
+import React9, { useState as useState5 } from "react";
 
 // src/cli/ui/App.tsx
-import { Box as Box7, Static, Text as Text7, useApp, useInput } from "ink";
-import React7, { useCallback, useEffect as useEffect2, useMemo, useRef, useState as useState2 } from "react";
+import { Box as Box7, Static, Text as Text7, useApp, useInput as useInput2 } from "ink";
+import React7, { useCallback, useEffect as useEffect3, useMemo, useRef, useState as useState3 } from "react";
 
 // src/cli/ui/EventLog.tsx
 import { Box as Box3, Text as Text3 } from "ink";
@@ -3125,6 +3711,25 @@ function parseBlocks(raw) {
       out.push({ kind: "heading", level: hm[1].length, text: hm[2].trim() });
       continue;
     }
+    if (line.includes("|")) {
+      const next = (lines[i + 1] ?? "").trim();
+      if (/^\|?\s*:?-{2,}:?\s*(\|\s*:?-{2,}:?\s*)+\|?\s*$/.test(next)) {
+        flushPara();
+        flushList();
+        const header = splitTableRow(line);
+        const rows = [];
+        let j = i + 2;
+        while (j < lines.length) {
+          const r = lines[j].replace(/\s+$/g, "");
+          if (r.trim() === "" || !r.includes("|")) break;
+          rows.push(splitTableRow(r));
+          j++;
+        }
+        out.push({ kind: "table", header, rows });
+        i = j - 1;
+        continue;
+      }
+    }
     const bm = line.match(/^\s*[-*+]\s+(.+)$/);
     if (bm) {
       flushPara();
@@ -3167,10 +3772,55 @@ function BlockView({ block }) {
       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 "table":
+      return /* @__PURE__ */ React2.createElement(TableBlockRow, { 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 splitTableRow(line) {
+  const SENTINEL = "\0";
+  const masked = line.replace(/\\\|/g, SENTINEL);
+  const trimmed = masked.trim().replace(/^\||\|$/g, "");
+  return trimmed.split("|").map((c) => c.trim().replace(new RegExp(SENTINEL, "g"), "|"));
+}
+function TableBlockRow({ block }) {
+  const colCount = Math.max(block.header.length, ...block.rows.map((r) => r.length));
+  const widths = [];
+  for (let c = 0; c < colCount; c++) {
+    const cellLengths = [displayWidth(block.header[c] ?? "")];
+    for (const r of block.rows) cellLengths.push(displayWidth(r[c] ?? ""));
+    widths.push(Math.min(40, Math.max(3, ...cellLengths)));
+  }
+  const pad2 = (s, w) => {
+    const dw = displayWidth(s);
+    if (dw >= w) return s;
+    return s + " ".repeat(w - dw);
+  };
+  const separator = widths.map((w) => "\u2500".repeat(w)).join("\u2500\u253C\u2500");
+  return /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column" }, /* @__PURE__ */ React2.createElement(Box2, null, block.header.map((cell, ci) => (
+    // biome-ignore lint/suspicious/noArrayIndexKey: table columns never reorder — derived from a static header array
+    /* @__PURE__ */ React2.createElement(Text2, { key: `h-${ci}`, bold: true, color: "cyan" }, pad2(cell, widths[ci] ?? 3), ci < colCount - 1 ? " \u2502 " : "")
+  ))), /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, separator), block.rows.map((row2, ri) => (
+    // biome-ignore lint/suspicious/noArrayIndexKey: table rows render in source order and don't reorder
+    /* @__PURE__ */ React2.createElement(Box2, { key: `r-${ri}` }, Array.from({ length: colCount }).map((_, ci) => (
+      // biome-ignore lint/suspicious/noArrayIndexKey: same — column axis is fixed by the table shape
+      /* @__PURE__ */ React2.createElement(Text2, { key: `c-${ri}-${ci}` }, pad2(row2[ci] ?? "", widths[ci] ?? 3), ci < colCount - 1 ? " \u2502 " : "")
+    )))
+  )));
+}
+function displayWidth(s) {
+  let w = 0;
+  for (const ch of s) {
+    const code = ch.codePointAt(0) ?? 0;
+    if (code >= 4352 && code <= 4447 || code >= 11904 && code <= 12350 || code >= 12353 && code <= 13311 || code >= 13312 && code <= 19903 || code >= 19968 && code <= 40959 || code >= 40960 && code <= 42191 || code >= 44032 && code <= 55203 || code >= 63744 && code <= 64255 || code >= 65072 && code <= 65103 || code >= 65280 && code <= 65376 || code >= 65504 && code <= 65510) {
+      w += 2;
+    } else {
+      w += 1;
+    }
+  }
+  return w;
+}
 function EditBlockRow({ block }) {
   const isNewFile = block.search.length === 0;
   const searchLines = block.search.split("\n");
@@ -3196,7 +3846,8 @@ var EventRow = React3.memo(function EventRow2({ event }) {
     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)));
+    const isEditFile = (event.toolName === "edit_file" || event.toolName?.endsWith("_edit_file")) && !isError;
+    return /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React3.createElement(Text3, { color }, `tool<${event.toolName ?? "?"}>  ${marker}`), isEditFile ? /* @__PURE__ */ React3.createElement(EditFileDiff, { text: event.text }) : /* @__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));
@@ -3209,6 +3860,20 @@ var EventRow = React3.memo(function EventRow2({ event }) {
   }
   return /* @__PURE__ */ React3.createElement(Box3, null, /* @__PURE__ */ React3.createElement(Text3, null, event.text));
 });
+function EditFileDiff({ text }) {
+  const lines = text.split(/\r?\n/);
+  const [statusHeader, hunkHeader, ...body] = lines;
+  return /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column" }, /* @__PURE__ */ React3.createElement(Text3, { dimColor: true }, ` ${statusHeader ?? ""}`), hunkHeader !== void 0 ? /* @__PURE__ */ React3.createElement(Text3, { color: "cyan", bold: true }, hunkHeader) : null, body.map((line, i) => {
+    const key = `${i}-${line.slice(0, 32)}`;
+    if (line.startsWith("- ")) {
+      return /* @__PURE__ */ React3.createElement(Text3, { key, color: "red" }, line);
+    }
+    if (line.startsWith("+ ")) {
+      return /* @__PURE__ */ React3.createElement(Text3, { key, color: "green" }, line);
+    }
+    return /* @__PURE__ */ React3.createElement(Text3, { key, dimColor: true }, line);
+  }));
+}
 function BranchBlock({ branch }) {
   const per = branch.uncertainties.map((u, i) => {
     const marker = i === branch.chosenIndex ? "\u25B8" : " ";
@@ -3245,8 +3910,21 @@ function StreamingAssistant({ event }) {
   }
   const tail = lastLine(event.text, 140);
   const reasoningTail = event.reasoning ? lastLine(event.reasoning, 120) : "";
+  const preFirstByte = !event.text && !event.reasoning;
   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)"));
+  let label;
+  let labelColor;
+  if (preFirstByte) {
+    label = "request sent \xB7 waiting for server";
+    labelColor = "yellow";
+  } else if (reasoningOnly) {
+    label = `R1 reasoning \xB7 ${event.reasoning?.length ?? 0} chars of thought`;
+    labelColor = "cyan";
+  } else {
+    label = event.reasoning ? `writing response \xB7 ${event.text.length} chars \xB7 after ${event.reasoning.length} chars of reasoning` : `writing response \xB7 ${event.text.length} chars`;
+    labelColor = "green";
+  }
+  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, { color: labelColor }, ` ${label} `), /* @__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 }, "  connection open, first byte typically in 5-60s depending on model + load"));
 }
 function Pulse() {
   const [tick, setTick] = useState(0);
@@ -3271,9 +3949,44 @@ function truncate2(s, max) {
 }
 
 // src/cli/ui/PromptInput.tsx
-import { Box as Box4, Text as Text4 } from "ink";
-import TextInput from "ink-text-input";
-import React4 from "react";
+import { Box as Box4, Text as Text4, useInput } from "ink";
+import React4, { useEffect as useEffect2, useState as useState2 } from "react";
+
+// src/cli/ui/multiline-keys.ts
+var BACKSLASH_SUFFIX = /\\$/;
+function processMultilineKey(value, key) {
+  if (key.tab || key.upArrow || key.downArrow || key.leftArrow || key.rightArrow || key.escape || key.pageUp || key.pageDown) {
+    return { next: null, submit: false };
+  }
+  if (key.input === "\n" || key.ctrl && key.input === "j") {
+    return { next: `${value}
+`, submit: false };
+  }
+  if (key.return) {
+    if (key.shift) {
+      return { next: `${value}
+`, submit: false };
+    }
+    if (BACKSLASH_SUFFIX.test(value)) {
+      return { next: `${value.slice(0, -1)}
+`, submit: false };
+    }
+    return { next: null, submit: true, submitValue: value };
+  }
+  if (key.backspace || key.delete) {
+    if (value.length === 0) return { next: null, submit: false };
+    return { next: value.slice(0, -1), submit: false };
+  }
+  if ((key.ctrl || key.meta) && key.input.length === 0) {
+    return { next: null, submit: false };
+  }
+  if (key.input.length > 0 && !key.ctrl && !key.meta) {
+    return { next: value + key.input, submit: false };
+  }
+  return { next: null, submit: false };
+}
+
+// src/cli/ui/PromptInput.tsx
 function PromptInput({
   value,
   onChange,
@@ -3281,17 +3994,53 @@ function PromptInput({
   disabled,
   placeholder
 }) {
-  const effectivePlaceholder = disabled ? placeholder ?? "\u2026waiting for response\u2026" : placeholder ?? "type a message, or /command";
-  return /* @__PURE__ */ React4.createElement(Box4, { borderStyle: "round", borderColor: disabled ? "gray" : "cyan", paddingX: 1 }, /* @__PURE__ */ React4.createElement(Text4, { bold: true, color: disabled ? "gray" : "cyan" }, "you \u203A", " "), /* @__PURE__ */ React4.createElement(
-    TextInput,
-    {
-      value,
-      onChange,
-      onSubmit,
-      focus: !disabled,
-      placeholder: effectivePlaceholder
+  const [showCursor, setShowCursor] = useState2(true);
+  useEffect2(() => {
+    if (disabled) {
+      setShowCursor(false);
+      return;
     }
-  ));
+    setShowCursor(true);
+    const id = setInterval(() => setShowCursor((s) => !s), 500);
+    return () => clearInterval(id);
+  }, [disabled]);
+  useInput(
+    (input, key) => {
+      const keyEvent = {
+        input,
+        return: key.return,
+        shift: key.shift,
+        ctrl: key.ctrl,
+        meta: key.meta,
+        backspace: key.backspace,
+        delete: key.delete,
+        tab: key.tab,
+        upArrow: key.upArrow,
+        downArrow: key.downArrow,
+        leftArrow: key.leftArrow,
+        rightArrow: key.rightArrow,
+        escape: key.escape,
+        pageUp: key.pageUp,
+        pageDown: key.pageDown
+      };
+      const action = processMultilineKey(value, keyEvent);
+      if (action.next !== null) onChange(action.next);
+      if (action.submit) onSubmit(action.submitValue ?? value);
+    },
+    { isActive: !disabled }
+  );
+  const effectivePlaceholder = disabled ? placeholder ?? "\u2026waiting for response\u2026" : placeholder ?? "type a message, or /command \xB7 Ctrl+J for newline";
+  const lines = value.length > 0 ? value.split("\n") : [""];
+  const borderColor = disabled ? "gray" : "cyan";
+  return /* @__PURE__ */ React4.createElement(Box4, { borderStyle: "round", borderColor, paddingX: 1, flexDirection: "column" }, lines.map((line, i) => {
+    const isLast = i === lines.length - 1;
+    const isFirst = i === 0;
+    const showPlaceholder = isFirst && value.length === 0;
+    return (
+      // biome-ignore lint/suspicious/noArrayIndexKey: stable by construction — lines are derived from `value.split("\n")` and never reordered
+      /* @__PURE__ */ React4.createElement(Box4, { key: i }, isFirst ? /* @__PURE__ */ React4.createElement(Text4, { bold: true, color: borderColor }, "you \u203A", " ") : /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, "     "), showPlaceholder && isLast && !disabled ? /* @__PURE__ */ React4.createElement(Text4, { color: borderColor }, showCursor ? "\u258C" : " ") : null, showPlaceholder ? /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, effectivePlaceholder) : /* @__PURE__ */ React4.createElement(Text4, null, line), !showPlaceholder && isLast && !disabled ? /* @__PURE__ */ React4.createElement(Text4, { color: borderColor }, showCursor ? "\u258C" : " ") : null)
+    );
+  }));
 }
 
 // src/cli/ui/SlashSuggestions.tsx
@@ -3331,7 +4080,8 @@ function StatsPanel({
   model,
   prefixHash,
   harvestOn,
-  branchBudget
+  branchBudget,
+  balance
 }) {
   const hitPct = (summary.cacheHitRatio * 100).toFixed(1);
   const hitColor = summary.cacheHitRatio >= 0.7 ? "green" : summary.cacheHitRatio >= 0.4 ? "yellow" : "red";
@@ -3339,7 +4089,7 @@ function StatsPanel({
   const ctxMax = DEEPSEEK_CONTEXT_TOKENS[model] ?? DEFAULT_CONTEXT_TOKENS;
   const ctxRatio = summary.lastPromptTokens / ctxMax;
   const ctxColor = ctxRatio >= 0.8 ? "red" : ctxRatio >= 0.5 ? "yellow" : void 0;
-  return /* @__PURE__ */ React6.createElement(Box6, { borderStyle: "round", borderColor: "cyan", flexDirection: "column", paddingX: 1 }, /* @__PURE__ */ React6.createElement(Box6, { justifyContent: "space-between" }, /* @__PURE__ */ React6.createElement(Text6, null, /* @__PURE__ */ React6.createElement(Text6, { color: "cyan", bold: true }, "Reasonix"), /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, " \xB7 model "), /* @__PURE__ */ React6.createElement(Text6, { color: "yellow" }, model), /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, " \xB7 prefix "), /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, prefixHash), harvestOn ? /* @__PURE__ */ React6.createElement(Text6, { color: "magenta" }, " \xB7 harvest") : null, branchOn ? /* @__PURE__ */ React6.createElement(Text6, { color: "blue" }, " \xB7 branch", branchBudget) : null), /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, "turns ", summary.turns, " \xB7 type /help")), /* @__PURE__ */ React6.createElement(Box6, { marginTop: 1, gap: 3 }, /* @__PURE__ */ React6.createElement(Text6, null, /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, "cache hit "), /* @__PURE__ */ React6.createElement(Text6, { color: hitColor, bold: true }, hitPct, "%")), /* @__PURE__ */ React6.createElement(Text6, null, /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, "cost "), /* @__PURE__ */ React6.createElement(Text6, { color: "green" }, "$", summary.totalCostUsd.toFixed(6))), /* @__PURE__ */ React6.createElement(Text6, null, /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, "vs Claude "), /* @__PURE__ */ React6.createElement(Text6, null, "$", summary.claudeEquivalentUsd.toFixed(6))), /* @__PURE__ */ React6.createElement(Text6, null, /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, "saving "), /* @__PURE__ */ React6.createElement(Text6, { color: "green", bold: true }, summary.savingsVsClaudePct.toFixed(1), "%")), summary.lastPromptTokens > 0 ? /* @__PURE__ */ React6.createElement(Text6, null, /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, "ctx "), /* @__PURE__ */ React6.createElement(Text6, { color: ctxColor, bold: ctxColor !== void 0 }, formatTokens(summary.lastPromptTokens), "/", formatTokens(ctxMax)), /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, " (", (ctxRatio * 100).toFixed(0), "%)"), ctxRatio >= 0.8 ? /* @__PURE__ */ React6.createElement(Text6, { color: "red", bold: true }, " ", "\xB7 /compact") : null) : null));
+  return /* @__PURE__ */ React6.createElement(Box6, { borderStyle: "round", borderColor: "cyan", flexDirection: "column", paddingX: 1 }, /* @__PURE__ */ React6.createElement(Box6, { justifyContent: "space-between" }, /* @__PURE__ */ React6.createElement(Text6, null, /* @__PURE__ */ React6.createElement(Text6, { color: "cyan", bold: true }, "Reasonix"), /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, " \xB7 model "), /* @__PURE__ */ React6.createElement(Text6, { color: "yellow" }, model), /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, " \xB7 prefix "), /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, prefixHash), harvestOn ? /* @__PURE__ */ React6.createElement(Text6, { color: "magenta" }, " \xB7 harvest") : null, branchOn ? /* @__PURE__ */ React6.createElement(Text6, { color: "blue" }, " \xB7 branch", branchBudget) : null), /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, "turns ", summary.turns, " \xB7 type /help")), /* @__PURE__ */ React6.createElement(Box6, { marginTop: 1, gap: 3 }, /* @__PURE__ */ React6.createElement(Text6, null, /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, "cache hit "), /* @__PURE__ */ React6.createElement(Text6, { color: hitColor, bold: true }, hitPct, "%")), /* @__PURE__ */ React6.createElement(Text6, null, /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, "cost "), /* @__PURE__ */ React6.createElement(Text6, { color: "green", bold: true }, "$", summary.totalCostUsd.toFixed(6)), /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, " (in ", "$", summary.totalInputCostUsd.toFixed(6), " \xB7 out ", "$", summary.totalOutputCostUsd.toFixed(6), ")")), summary.lastPromptTokens > 0 ? /* @__PURE__ */ React6.createElement(Text6, null, /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, "ctx "), /* @__PURE__ */ React6.createElement(Text6, { color: ctxColor, bold: ctxColor !== void 0 }, formatTokens(summary.lastPromptTokens), "/", formatTokens(ctxMax)), /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, " (", (ctxRatio * 100).toFixed(0), "%)"), ctxRatio >= 0.8 ? /* @__PURE__ */ React6.createElement(Text6, { color: "red", bold: true }, " ", "\xB7 /compact") : null) : null, balance ? /* @__PURE__ */ React6.createElement(Text6, null, /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, "balance "), /* @__PURE__ */ React6.createElement(Text6, { color: balance.total < 1 ? "red" : balance.total < 5 ? "yellow" : "green", bold: true }, balance.currency === "USD" ? "$" : "", balance.total.toFixed(2), balance.currency !== "USD" ? ` ${balance.currency}` : "")) : null));
 }
 function formatTokens(n) {
   if (n < 1e3) return String(n);
@@ -3368,7 +4118,8 @@ var SLASH_COMMANDS = [
   { cmd: "sessions", summary: "list saved sessions (current marked with \u25B8)" },
   { cmd: "forget", summary: "delete the current session from disk" },
   { cmd: "setup", summary: "reminds you to exit and run `reasonix setup`" },
-  { cmd: "clear", summary: "clear the visible scrollback (log + session kept)" },
+  { cmd: "clear", summary: "clear visible scrollback only (log/context kept)" },
+  { cmd: "new", summary: "start a fresh conversation (clear context + scrollback)" },
   { cmd: "exit", summary: "quit the TUI" },
   // Code-mode only
   { cmd: "apply", summary: "commit pending edit blocks to disk", contextual: "code" },
@@ -3401,7 +4152,18 @@ function handleSlash(cmd, args, loop, ctx = {}) {
     case "quit":
       return { exit: true };
     case "clear":
-      return { clear: true };
+      return {
+        clear: true,
+        info: "\u25B8 cleared visible scrollback only. Context (message log) is intact \u2014 next turn still sees everything. Use /new to start fresh, or /forget to delete the session entirely."
+      };
+    case "new":
+    case "reset": {
+      const { dropped } = loop.clearLog();
+      return {
+        clear: true,
+        info: `\u25B8 new conversation \u2014 dropped ${dropped} message(s) from context. Same session, fresh slate.`
+      };
+    }
     case "help":
     case "?":
       return {
@@ -3425,7 +4187,8 @@ function handleSlash(cmd, args, loop, ctx = {}) {
           '  /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)",
+          "  /new                     start fresh: drop all context + clear scrollback",
+          "  /clear                   clear displayed scrollback only (context kept \u2014 model still sees it)",
           "  /exit                    quit",
           "",
           "Presets:",
@@ -3785,24 +4548,30 @@ function App({
   tools,
   mcpSpecs,
   mcpServers,
+  progressSink,
   codeMode
 }) {
   const { exit } = useApp();
-  const [historical, setHistorical] = useState2([]);
-  const [streaming, setStreaming] = useState2(null);
-  const [input, setInput] = useState2("");
-  const [busy, setBusy] = useState2(false);
+  const [historical, setHistorical] = useState3([]);
+  const [streaming, setStreaming] = useState3(null);
+  const [input, setInput] = useState3("");
+  const [busy, setBusy] = useState3(false);
   const abortedThisTurn = useRef(false);
-  const [ongoingTool, setOngoingTool] = useState2(null);
+  const [ongoingTool, setOngoingTool] = useState3(null);
+  const [toolProgress, setToolProgress] = useState3(null);
+  const [statusLine, setStatusLine] = useState3(null);
+  const [balance, setBalance] = useState3(null);
   const lastEditSnapshots = useRef(null);
   const pendingEdits = useRef([]);
   const promptHistory = useRef([]);
   const historyCursor = useRef(-1);
   const toolHistoryRef = useRef([]);
-  const [slashSelected, setSlashSelected] = useState2(0);
-  const [summary, setSummary] = useState2({
+  const [slashSelected, setSlashSelected] = useState3(0);
+  const [summary, setSummary] = useState3({
     turns: 0,
     totalCostUsd: 0,
+    totalInputCostUsd: 0,
+    totalOutputCostUsd: 0,
     claudeEquivalentUsd: 0,
     savingsVsClaudePct: 0,
     cacheHitRatio: 0,
@@ -3817,7 +4586,7 @@ function App({
       startedAt: (/* @__PURE__ */ new Date()).toISOString()
     });
   }
-  useEffect2(() => {
+  useEffect3(() => {
     return () => {
       transcriptRef.current?.end();
     };
@@ -3826,7 +4595,7 @@ function App({
     if (!input.startsWith("/") || input.includes(" ")) return null;
     return suggestSlashCommands(input.slice(1), !!codeMode);
   }, [input, codeMode]);
-  useEffect2(() => {
+  useEffect3(() => {
     setSlashSelected((prev) => {
       if (!slashMatches || slashMatches.length === 0) return 0;
       if (prev >= slashMatches.length) return slashMatches.length - 1;
@@ -3845,8 +4614,33 @@ function App({
     loopRef.current = l;
     return l;
   }, [model, system, harvest2, branch, session, tools]);
+  useEffect3(() => {
+    let cancelled = false;
+    void (async () => {
+      const bal = await loop.client.getBalance().catch(() => null);
+      if (cancelled || !bal || !bal.balance_infos.length) return;
+      const primary = bal.balance_infos[0];
+      setBalance({ currency: primary.currency, total: Number(primary.total_balance) });
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [loop]);
+  useEffect3(() => {
+    if (!progressSink) return;
+    progressSink.current = (info) => {
+      setToolProgress({
+        progress: info.progress,
+        total: info.total,
+        message: info.message
+      });
+    };
+    return () => {
+      if (progressSink.current) progressSink.current = null;
+    };
+  }, [progressSink]);
   const sessionBannerShown = useRef(false);
-  useEffect2(() => {
+  useEffect3(() => {
     if (sessionBannerShown.current) return;
     sessionBannerShown.current = true;
     if (!session) {
@@ -3878,7 +4672,7 @@ function App({
       ]);
     }
   }, [session, loop]);
-  useInput((_input, key) => {
+  useInput2((_input, key) => {
     if (key.escape && busy) {
       if (abortedThisTurn.current) return;
       abortedThisTurn.current = true;
@@ -3993,6 +4787,16 @@ function App({
           exit();
           return;
         }
+        if (result.clear && result.info) {
+          setHistorical([
+            {
+              id: `sys-${Date.now()}`,
+              role: "info",
+              text: result.info
+            }
+          ]);
+          return;
+        }
         if (result.clear) {
           setHistorical([]);
           return;
@@ -4041,7 +4845,12 @@ function App({
       try {
         for await (const ev of loop.step(text)) {
           writeTranscript(ev);
-          if (ev.role === "assistant_delta") {
+          if (ev.role !== "status") {
+            setStatusLine((cur) => cur ? null : cur);
+          }
+          if (ev.role === "status") {
+            setStatusLine(ev.content);
+          } else if (ev.role === "assistant_delta") {
             if (ev.content) contentBuf.current += ev.content;
             if (ev.reasoningDelta) reasoningBuf.current += ev.reasoningDelta;
           } else if (ev.role === "branch_start") {
@@ -4065,6 +4874,7 @@ function App({
             flush();
             const repairNote = ev.repair ? describeRepair(ev.repair) : "";
             setStreaming(null);
+            setSummary(loop.stats.summary());
             const finalText = ev.content || streamRef.text;
             setHistorical((prev) => [
               ...prev,
@@ -4096,9 +4906,11 @@ function App({
             }
           } else if (ev.role === "tool_start") {
             setOngoingTool({ name: ev.toolName ?? "?", args: ev.toolArgs });
+            setToolProgress(null);
           } else if (ev.role === "tool") {
             flush();
             setOngoingTool(null);
+            setToolProgress(null);
             toolHistoryRef.current.push({
               toolName: ev.toolName ?? "?",
               text: ev.content
@@ -4129,8 +4941,17 @@ function App({
         clearInterval(timer);
         setStreaming(null);
         setOngoingTool(null);
+        setToolProgress(null);
+        setStatusLine(null);
         setSummary(loop.stats.summary());
         setBusy(false);
+        void (async () => {
+          const bal = await loop.client.getBalance().catch(() => null);
+          if (bal?.balance_infos.length) {
+            const p = bal.balance_infos[0];
+            setBalance({ currency: p.currency, total: Number(p.total_balance) });
+          }
+        })();
       }
     },
     [
@@ -4154,14 +4975,33 @@ function App({
       model: loop.model,
       prefixHash,
       harvestOn: loop.harvestEnabled,
-      branchBudget: loop.branchOptions.budget
+      branchBudget: loop.branchOptions.budget,
+      balance
     }
-  ), /* @__PURE__ */ React7.createElement(Static, { items: historical }, (item) => /* @__PURE__ */ React7.createElement(EventRow, { key: item.id, event: item })), streaming ? /* @__PURE__ */ React7.createElement(Box7, { marginY: 1 }, /* @__PURE__ */ React7.createElement(EventRow, { event: streaming })) : null, ongoingTool ? /* @__PURE__ */ React7.createElement(OngoingToolRow, { tool: ongoingTool }) : null, /* @__PURE__ */ React7.createElement(PromptInput, { value: input, onChange: setInput, onSubmit: handleSubmit, disabled: busy }), /* @__PURE__ */ React7.createElement(SlashSuggestions, { matches: slashMatches, selectedIndex: slashSelected }));
+  ), /* @__PURE__ */ React7.createElement(Static, { items: historical }, (item) => /* @__PURE__ */ React7.createElement(EventRow, { key: item.id, event: item })), streaming ? /* @__PURE__ */ React7.createElement(Box7, { marginY: 1 }, /* @__PURE__ */ React7.createElement(EventRow, { event: streaming })) : null, ongoingTool ? /* @__PURE__ */ React7.createElement(OngoingToolRow, { tool: ongoingTool, progress: toolProgress }) : null, !ongoingTool && statusLine ? /* @__PURE__ */ React7.createElement(StatusRow, { text: statusLine }) : null, busy && !streaming && !ongoingTool && !statusLine ? /* @__PURE__ */ React7.createElement(StatusRow, { text: "processing\u2026" }) : null, /* @__PURE__ */ React7.createElement(PromptInput, { value: input, onChange: setInput, onSubmit: handleSubmit, disabled: busy }), /* @__PURE__ */ React7.createElement(SlashSuggestions, { matches: slashMatches, selectedIndex: slashSelected }));
 }
-function OngoingToolRow({ tool }) {
-  const [tick, setTick] = useState2(0);
-  const [elapsed, setElapsed] = useState2(0);
-  useEffect2(() => {
+function StatusRow({ text }) {
+  const [tick, setTick] = useState3(0);
+  const [elapsed, setElapsed] = useState3(0);
+  useEffect3(() => {
+    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"];
+  return /* @__PURE__ */ React7.createElement(Box7, { marginY: 1 }, /* @__PURE__ */ React7.createElement(Text7, { color: "magenta" }, frames[tick % frames.length]), /* @__PURE__ */ React7.createElement(Text7, { color: "magenta" }, ` ${text}`), /* @__PURE__ */ React7.createElement(Text7, { dimColor: true }, ` ${elapsed}s`));
+}
+function OngoingToolRow({
+  tool,
+  progress
+}) {
+  const [tick, setTick] = useState3(0);
+  const [elapsed, setElapsed] = useState3(0);
+  useEffect3(() => {
     const start = Date.now();
     const frameId = setInterval(() => setTick((t) => t + 1), 120);
     const secId = setInterval(() => setElapsed(Math.floor((Date.now() - start) / 1e3)), 1e3);
@@ -4172,7 +5012,19 @@ function OngoingToolRow({ tool }) {
   }, []);
   const frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
   const summary = summarizeToolArgs(tool.name, tool.args);
-  return /* @__PURE__ */ React7.createElement(Box7, { marginY: 1, flexDirection: "column" }, /* @__PURE__ */ React7.createElement(Box7, null, /* @__PURE__ */ React7.createElement(Text7, { color: "cyan" }, frames[tick % frames.length]), /* @__PURE__ */ React7.createElement(Text7, { color: "yellow" }, ` tool<${tool.name}> running\u2026`), /* @__PURE__ */ React7.createElement(Text7, { dimColor: true }, ` ${elapsed}s`)), summary ? /* @__PURE__ */ React7.createElement(Box7, { paddingLeft: 2 }, /* @__PURE__ */ React7.createElement(Text7, { dimColor: true }, summary)) : null);
+  return /* @__PURE__ */ React7.createElement(Box7, { marginY: 1, flexDirection: "column" }, /* @__PURE__ */ React7.createElement(Box7, null, /* @__PURE__ */ React7.createElement(Text7, { color: "cyan" }, frames[tick % frames.length]), /* @__PURE__ */ React7.createElement(Text7, { color: "yellow" }, ` tool<${tool.name}> running\u2026`), /* @__PURE__ */ React7.createElement(Text7, { dimColor: true }, ` ${elapsed}s`)), progress ? /* @__PURE__ */ React7.createElement(Box7, { paddingLeft: 2 }, /* @__PURE__ */ React7.createElement(Text7, { color: "cyan" }, renderProgressLine(progress))) : null, summary ? /* @__PURE__ */ React7.createElement(Box7, { paddingLeft: 2 }, /* @__PURE__ */ React7.createElement(Text7, { dimColor: true }, summary)) : null);
+}
+function renderProgressLine(p) {
+  const msg = p.message ? `  ${p.message}` : "";
+  if (p.total && p.total > 0) {
+    const ratio = Math.max(0, Math.min(1, p.progress / p.total));
+    const width = 20;
+    const filled = Math.round(ratio * width);
+    const bar = "\u2588".repeat(filled) + "\u2591".repeat(width - filled);
+    const pct2 = (ratio * 100).toFixed(0);
+    return `[${bar}] ${p.progress}/${p.total} ${pct2}%${msg}`;
+  }
+  return `progress: ${p.progress}${msg}`;
 }
 function summarizeToolArgs(name, args) {
   if (!args || args === "{}") return "";
@@ -4257,11 +5109,11 @@ function describeRepair(repair) {
 
 // src/cli/ui/Setup.tsx
 import { Box as Box8, Text as Text8, useApp as useApp2 } from "ink";
-import TextInput2 from "ink-text-input";
-import React8, { useState as useState3 } from "react";
+import TextInput from "ink-text-input";
+import React8, { useState as useState4 } from "react";
 function Setup({ onReady }) {
-  const [value, setValue] = useState3("");
-  const [error, setError] = useState3(null);
+  const [value, setValue] = useState4("");
+  const [error, setError] = useState4(null);
   const { exit } = useApp2();
   const handleSubmit = (raw) => {
     const trimmed = raw.trim();
@@ -4283,7 +5135,7 @@ function Setup({ onReady }) {
     onReady(trimmed);
   };
   return /* @__PURE__ */ React8.createElement(Box8, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1 }, /* @__PURE__ */ React8.createElement(Text8, { bold: true, color: "cyan" }, "Welcome to Reasonix."), /* @__PURE__ */ React8.createElement(Box8, { marginTop: 1 }, /* @__PURE__ */ React8.createElement(Text8, null, "Paste your DeepSeek API key to get started.")), /* @__PURE__ */ React8.createElement(Text8, { dimColor: true }, "Get one (free credit on signup): https://platform.deepseek.com/api_keys"), /* @__PURE__ */ React8.createElement(Text8, { dimColor: true }, "Saved locally to ", defaultConfigPath()), /* @__PURE__ */ React8.createElement(Box8, { marginTop: 1 }, /* @__PURE__ */ React8.createElement(Text8, { bold: true, color: "cyan" }, "key \u203A "), /* @__PURE__ */ React8.createElement(
-    TextInput2,
+    TextInput,
     {
       value,
       onChange: setValue,
@@ -4295,8 +5147,8 @@ function Setup({ onReady }) {
 }
 
 // src/cli/commands/chat.tsx
-function Root({ initialKey, tools, mcpSpecs, mcpServers, ...appProps }) {
-  const [key, setKey] = useState4(initialKey);
+function Root({ initialKey, tools, mcpSpecs, mcpServers, progressSink, ...appProps }) {
+  const [key, setKey] = useState5(initialKey);
   if (!key) {
     return /* @__PURE__ */ React9.createElement(
       Setup,
@@ -4321,6 +5173,7 @@ function Root({ initialKey, tools, mcpSpecs, mcpServers, ...appProps }) {
       tools,
       mcpSpecs,
       mcpServers,
+      progressSink,
       codeMode: appProps.codeMode
     }
   );
@@ -4333,9 +5186,10 @@ async function chatCommand(opts) {
   const successfulSpecs = [];
   const failedSpecs = [];
   const mcpServers = [];
-  let tools;
+  const progressSink = { current: null };
+  let tools = opts.seedTools;
   if (requestedSpecs.length > 0) {
-    tools = new ToolRegistry();
+    if (!tools) tools = new ToolRegistry();
     for (const raw of requestedSpecs) {
       try {
         const spec = parseMcpSpec(raw);
@@ -4343,7 +5197,11 @@ async function chatCommand(opts) {
         const transport = spec.transport === "sse" ? new SseTransport({ url: spec.url }) : new StdioTransport({ command: spec.command, args: spec.args });
         const mcp2 = new McpClient({ transport });
         await mcp2.initialize();
-        const bridge = await bridgeMcpTools(mcp2, { registry: tools, namePrefix: prefix });
+        const bridge = await bridgeMcpTools(mcp2, {
+          registry: tools,
+          namePrefix: prefix,
+          onProgress: (info) => progressSink.current?.(info)
+        });
         let report;
         try {
           report = await inspectMcpServer(mcp2);
@@ -4381,7 +5239,7 @@ async function chatCommand(opts) {
         );
       }
     }
-    if (successfulSpecs.length === 0) {
+    if (successfulSpecs.length === 0 && !opts.seedTools) {
       tools = void 0;
     }
   }
@@ -4394,6 +5252,7 @@ async function chatCommand(opts) {
         tools,
         mcpSpecs,
         mcpServers,
+        progressSink,
         ...opts
       }
     ),
@@ -4407,14 +5266,15 @@ async function chatCommand(opts) {
 }
 
 // src/cli/commands/code.tsx
-import { basename, resolve as resolve3 } from "path";
+import { basename, resolve as resolve4 } from "path";
 async function codeCommand(opts = {}) {
   const { codeSystemPrompt: codeSystemPrompt2 } = await import("./prompt-MMANQ36Z.js");
-  const rootDir = resolve3(opts.dir ?? process.cwd());
+  const rootDir = resolve4(opts.dir ?? process.cwd());
   const session = opts.noSession ? void 0 : `code-${sanitizeName(basename(rootDir))}`;
-  const fsSpec = `filesystem=npx -y @modelcontextprotocol/server-filesystem ${quoteIfNeeded(rootDir)}`;
+  const tools = new ToolRegistry();
+  registerFilesystemTools(tools, { rootDir });
   process.stderr.write(
-    `\u25B8 reasonix code: rooted at ${rootDir}, session "${session ?? "(ephemeral)"}"
+    `\u25B8 reasonix code: rooted at ${rootDir}, session "${session ?? "(ephemeral)"}" \xB7 ${tools.size} native fs tool(s)
 `
   );
   await chatCommand({
@@ -4424,13 +5284,10 @@ async function codeCommand(opts = {}) {
     system: codeSystemPrompt2(rootDir),
     transcript: opts.transcript,
     session,
-    mcp: [fsSpec],
+    seedTools: tools,
     codeMode: { rootDir }
   });
 }
-function quoteIfNeeded(s) {
-  return /\s|"/.test(s) ? `"${s.replace(/"/g, '\\"')}"` : s;
-}
 
 // src/cli/commands/diff.ts
 import { writeFileSync as writeFileSync4 } from "fs";
@@ -4439,8 +5296,8 @@ import { render as render2 } from "ink";
 import React12 from "react";
 
 // src/cli/ui/DiffApp.tsx
-import { Box as Box10, Static as Static2, Text as Text10, useApp as useApp3, useInput as useInput2 } from "ink";
-import React11, { useState as useState5 } from "react";
+import { Box as Box10, Static as Static2, Text as Text10, useApp as useApp3, useInput as useInput3 } from "ink";
+import React11, { useState as useState6 } from "react";
 
 // src/cli/ui/RecordView.tsx
 import { Box as Box9, Text as Text9 } from "ink";
@@ -4483,8 +5340,8 @@ function DiffApp({ report }) {
   const { exit } = useApp3();
   const maxIdx = Math.max(0, report.pairs.length - 1);
   const initialIdx = report.firstDivergenceTurn ? report.pairs.findIndex((p) => p.turn === report.firstDivergenceTurn) : 0;
-  const [idx, setIdx] = useState5(Math.max(0, initialIdx));
-  useInput2((input, key) => {
+  const [idx, setIdx] = useState6(Math.max(0, initialIdx));
+  useInput3((input, key) => {
     if (input === "q" || key.ctrl && input === "c") {
       exit();
       return;
@@ -4728,13 +5585,13 @@ import { render as render3 } from "ink";
 import React14 from "react";
 
 // src/cli/ui/ReplayApp.tsx
-import { Box as Box11, Static as Static3, Text as Text11, useApp as useApp4, useInput as useInput3 } from "ink";
-import React13, { useMemo as useMemo2, useState as useState6 } from "react";
+import { Box as Box11, Static as Static3, Text as Text11, useApp as useApp4, useInput as useInput4 } from "ink";
+import React13, { useMemo as useMemo2, useState as useState7 } from "react";
 function ReplayApp({ meta, pages }) {
   const { exit } = useApp4();
   const maxIdx = Math.max(0, pages.length - 1);
-  const [idx, setIdx] = useState6(maxIdx);
-  useInput3((input, key) => {
+  const [idx, setIdx] = useState7(maxIdx);
+  useInput4((input, key) => {
     if (input === "q" || key.ctrl && input === "c") {
       exit();
       return;
@@ -4757,6 +5614,8 @@ function ReplayApp({ meta, pages }) {
   const summary = {
     turns: cumStats.turns,
     totalCostUsd: cumStats.totalCostUsd,
+    totalInputCostUsd: cumStats.totalInputCostUsd,
+    totalOutputCostUsd: cumStats.totalOutputCostUsd,
     claudeEquivalentUsd: cumStats.claudeEquivalentUsd,
     savingsVsClaudePct: cumStats.savingsVsClaudePct,
     cacheHitRatio: cumStats.cacheHitRatio,
@@ -5089,13 +5948,13 @@ import { render as render4 } from "ink";
 import React17 from "react";
 
 // src/cli/ui/Wizard.tsx
-import { Box as Box13, Text as Text13, useApp as useApp5, useInput as useInput5 } from "ink";
-import TextInput3 from "ink-text-input";
-import React16, { useState as useState8 } from "react";
+import { Box as Box13, Text as Text13, useApp as useApp5, useInput as useInput6 } from "ink";
+import TextInput2 from "ink-text-input";
+import React16, { useState as useState9 } from "react";
 
 // src/cli/ui/Select.tsx
-import { Box as Box12, Text as Text12, useInput as useInput4 } from "ink";
-import React15, { useState as useState7 } from "react";
+import { Box as Box12, Text as Text12, useInput as useInput5 } from "ink";
+import React15, { useState as useState8 } from "react";
 function SingleSelect({
   items,
   initialValue,
@@ -5106,8 +5965,8 @@ function SingleSelect({
     0,
     items.findIndex((i) => i.value === initialValue && !i.disabled)
   );
-  const [index, setIndex] = useState7(initialIndex === -1 ? 0 : initialIndex);
-  useInput4((_input, key) => {
+  const [index, setIndex] = useState8(initialIndex === -1 ? 0 : initialIndex);
+  useInput5((_input, key) => {
     if (key.upArrow) {
       setIndex((i) => findNextEnabled(items, i, -1));
     } else if (key.downArrow) {
@@ -5136,12 +5995,12 @@ function MultiSelect({
   onCancel,
   footer
 }) {
-  const [index, setIndex] = useState7(() => {
+  const [index, setIndex] = useState8(() => {
     const first = items.findIndex((i) => !i.disabled);
     return first === -1 ? 0 : first;
   });
-  const [selected, setSelected] = useState7(new Set(initialSelected));
-  useInput4((input, key) => {
+  const [selected, setSelected] = useState8(new Set(initialSelected));
+  useInput5((input, key) => {
     if (key.upArrow) {
       setIndex((i) => findNextEnabled(items, i, -1));
     } else if (key.downArrow) {
@@ -5219,15 +6078,15 @@ var PRESET_DESCRIPTIONS = {
 var CATALOG_BY_NAME = new Map(MCP_CATALOG.map((e) => [e.name, e]));
 function Wizard({ onComplete, onCancel, existingApiKey, initial }) {
   const { exit } = useApp5();
-  const [step, setStep] = useState8(existingApiKey ? "preset" : "apiKey");
-  const [data, setData] = useState8({
+  const [step, setStep] = useState9(existingApiKey ? "preset" : "apiKey");
+  const [data, setData] = useState9({
     apiKey: existingApiKey ?? "",
     preset: initial?.preset ?? "fast",
     selectedCatalog: deriveInitialCatalog(initial?.mcp ?? []),
     catalogArgs: {}
   });
-  const [error, setError] = useState8(null);
-  useInput5((_input, key) => {
+  const [error, setError] = useState9(null);
+  useInput6((_input, key) => {
     if (key.escape && step !== "saved" && onCancel) onCancel();
   });
   if (step === "apiKey") {
@@ -5343,9 +6202,9 @@ function ApiKeyStep({
   error,
   onError
 }) {
-  const [value, setValue] = useState8("");
+  const [value, setValue] = useState9("");
   return /* @__PURE__ */ React16.createElement(Box13, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1 }, /* @__PURE__ */ React16.createElement(Text13, { bold: true, color: "cyan" }, "Welcome to Reasonix."), /* @__PURE__ */ React16.createElement(Box13, { marginTop: 1 }, /* @__PURE__ */ React16.createElement(Text13, null, "Paste your DeepSeek API key to get started.")), /* @__PURE__ */ React16.createElement(Text13, { dimColor: true }, "Get one (free credit on signup): https://platform.deepseek.com/api_keys"), /* @__PURE__ */ React16.createElement(Text13, { dimColor: true }, "Saved locally to ", defaultConfigPath()), /* @__PURE__ */ React16.createElement(Box13, { marginTop: 1 }, /* @__PURE__ */ React16.createElement(Text13, { bold: true, color: "cyan" }, "key \u203A "), /* @__PURE__ */ React16.createElement(
-    TextInput3,
+    TextInput2,
     {
       value,
       onChange: setValue,
@@ -5369,9 +6228,9 @@ function McpArgsStep({
   onSubmit,
   onError
 }) {
-  const [value, setValue] = useState8("");
+  const [value, setValue] = useState9("");
   return /* @__PURE__ */ React16.createElement(StepFrame, { title: `Configure ${entry.name}`, step: 2, total: 3 }, /* @__PURE__ */ React16.createElement(Box13, { flexDirection: "column" }, /* @__PURE__ */ React16.createElement(Text13, null, entry.summary), entry.note ? /* @__PURE__ */ React16.createElement(Box13, { marginTop: 1 }, /* @__PURE__ */ React16.createElement(Text13, { dimColor: true }, entry.note)) : null, /* @__PURE__ */ React16.createElement(Box13, { marginTop: 1 }, /* @__PURE__ */ React16.createElement(Text13, null, "Required parameter: "), /* @__PURE__ */ React16.createElement(Text13, { bold: true }, entry.userArgs)), /* @__PURE__ */ React16.createElement(Box13, { marginTop: 1 }, /* @__PURE__ */ React16.createElement(Text13, { bold: true, color: "cyan" }, entry.userArgs, " \u203A "), /* @__PURE__ */ React16.createElement(
-    TextInput3,
+    TextInput2,
     {
       value,
       onChange: setValue,
@@ -5389,13 +6248,13 @@ function McpArgsStep({
   )), error ? /* @__PURE__ */ React16.createElement(Box13, { marginTop: 1 }, /* @__PURE__ */ React16.createElement(Text13, { color: "red" }, error)) : null));
 }
 function ReviewConfirm({ onConfirm }) {
-  useInput5((_i, key) => {
+  useInput6((_i, key) => {
     if (key.return) onConfirm();
   });
   return null;
 }
 function ExitOnEnter({ onExit }) {
-  useInput5((_i, key) => {
+  useInput6((_i, key) => {
     if (key.return) onExit();
   });
   return null;
@@ -5452,10 +6311,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 ? ` ${quoteIfNeeded2(userArg)}` : "";
+  const tail = userArg ? ` ${quoteIfNeeded(userArg)}` : "";
   return `${entry.name}=npx -y ${entry.package}${tail}`;
 }
-function quoteIfNeeded2(s) {
+function quoteIfNeeded(s) {
   return /\s|"/.test(s) ? `"${s.replace(/"/g, '\\"')}"` : s;
 }